Tìm hiểu Java Collections Framework pptx

ìm hiểu Java Collections Framework
Trả lời Liên hệ
Khung cộng tác của các sưu tập Java (Java Collections Framework) là rộng lớn. Có rất nhiều lớp và giao diện trong khung
cộng tác. Tại đây, chúng ta sẽ trình bày nhiều hơn, dù không phải là tất cả về chúng.
Các giao diện và các lớp sưu tập
Khung công tác của các sưu tập Java dựa trên triển khai thực hiện cụ thể một số giao diện định nghĩa các kiểu sưu tập
(collection):
•
Giao diện List định nghĩa một sưu tập các phần tử Object có thể dẫn hướng.
•
Giao diện Set định nghĩa một sưu tập không có các phần tử trùng lặp.
•
Giao diện Map định nghĩa một sưu tập các cặp khóa - giá trị.
Chúng ta sẽ nói về một vài triển khai thực hiện cụ thể trong hướng dẫn này. Đây không phải là một danh sách đầy đủ, nhưng
nhiều khả năng bạn thường xuyên thấy những thứ sau đây trong các dự án phát triển bằng ngôn ngữ Java:
Giao diện Các triển khai thực hiện
List ArrayList, Vector
Set HashSet, TreeSet
Map HashMap
Tất cả các giao diện trong khung cộng tác, trừ Map là các giao diện con của giao diện Collection, trong đó định nghĩa cấu trúc
chung nhất của một sưu tập. Mỗi sưu tập gồm nhiều phần tử. Với vai trò là trình thực hiện các giao diện con của Collection, tất
cả kiểu sưu tập chia sẻ chung (theo trực giác) một số hành vi:
•
Các phương thức để mô tả kích thước của sưu tập (như size() và isEmpty()).
•
Các phương thức để mô tả nội dung của sưu tập (như contains() và containsAll()).
•
Các phương thức để hỗ trợ thao tác về nội dung của sưu tập (như add(), remove() và clear()).
•
Các phương thức để cho phép bạn chuyển đổi một sưu tập thành một mảng (như toArray()).
•

Một phương thức để cho phép bạn nhận được một trình vòng lặp (iterator) trên mảng các phần tử (iterator()).
Chúng ta sẽ nói về một số phương thức trên trong phần này. Đồng thời chúng ta sẽ thảo luận trình vòng lặp (iterator) là gì và
cách sử dụng nó như thế nào.
Lưu ý rằng các Map là đặc biệt. Thật sự chúng hoàn toàn không là một sưu tập. Tuy nhiên, chúng có hành vi rất giống các sưu
tập, vì vậy chúng ta cũng nói về chúng trong phần này.
Các triển khai thực hiện Danh sách (List)
Các phiên bản cũ hơn của JDK chứa một lớp được gọi là Vector. Nó vẫn còn có trong các phiên bản mới hơn, nhưng bạn chỉ
nên sử dụng nó khi bạn cần có một sưu tập đồng bộ hoá đó là, một trong những yếu tố là an toàn phân luồng. (Nói về phân
luồng đã vượt ra ngoài phạm vi của bài viết này, chúng ta sẽ thảo luận ngắn gọn về khái niệm ấy trong phần Tóm tắt). Trong
các trường hợp khác, bạn nên sử dụng lớp ArrayList. Bạn vẫn có thể sử dụng Vector, nhưng nó áp đặt một số chi phí thêm mà
bạn thường không cần.
Một ArrayList là cái như tên của nó gợi ý: danh sách các phần tử theo thứ tự. Chúng ta đã thấy làm thế nào để tạo ra một
danh sách và làm thế nào để thêm các phần tử vào nó, trong bài hướng dẫn giới thiệu trước. Khi chúng ta tạo ra một lớp Wallet
lồng trong trong hướng dẫn này, chúng ta đã tích hợp vào đó một ArrayList để giữ các hoá đơn thanh toán của Adult:
Phương thức getMoneyTotal() sử dụng một trình vòng lặp (iterator) để duyệt qua danh sách các hoá đơn thanh toán và tính
tổng giá trị của chúng. Một Iterator tương tự như một Enumeration trong các phiên bản cũ hơn của ngôn ngữ Java. Khi bạn
nhận được một trình vòng lặp trên sưu tập (bằng cách gọi iterator()), trình vòng lặp cho phép bạn duyệt qua (traverse) toàn bộ
sưu tập bằng cách sử dụng một số phương thức quan trọng, được minh họa trong mã lệnh ở trên:
hasNext() cho bạn biết còn có một phần tử tiếp theo khác trong sưu tập không.
next() cho bạn phần tử tiếp theo đó.
Như chúng ta đã thảo luận ở trên, bạn phải ép kiểu đúng khi bạn trích ra các phần tử từ sưu tập khi sử dụng next().
Tuy nhiên, Iterator còn cho chúng ta một số khả năng bổ sung thêm. Chúng ta có thể loại bỏ các phần tử khỏi lớp ArrayList
bằng cách gọi remove() (hay removeAll(), hay clear()), nhưng chúng ta cũng có thể sử dụng Iterator để làm điều đó. Hãy thêm
một phương thức rất đơn giản được gọi là spendMoney() tới Adult:
Phương thức này gọi removeBill() trên Wallet:
Chúng ta nhận được một Iterator trên các hoá đơn thanh toán ArrayList, và duyệt qua danh sách để tìm một kết quả khớp với
giá trị hóa đơn được chuyển qua (aBill). Nếu chúng ta tìm thấy một kết quả khớp, chúng ta gọi remove() trên trình vòng lặp để
loại bỏ hóa đơn đó. Cũng đơn giản, nhưng còn chưa phải là đơn giản hết mức. Mã dưới đây thực hiện cùng một công việc và
dễ đọc hơn nhiều:
Có thể bạn sẽ không thường xuyên gọi remove() trên một Iterator nhưng sẽ rất tốt nếu có công cụ đó khi bạn cần nó.

Lúc này, chúng ta có thể loại bỏ chỉ một hóa đơn riêng lẻ mỗi lần khỏi Wallet. Sẽ là tốt hơn nếu sử dụng sức mạnh của một
List để giúp chúng ta loại bỏ nhiều hóa đơn cùng một lúc, như sau:
Chúng ta cần phải thêm removeBills() vào wallet của chúng ta để thực hiện việc này. Hãy thử mã dưới đây:
Đây là việc triển khai thực hiện dễ dàng nhất mà chúng ta có thể sử dụng. Chúng ta gọi removeAll() trên List các hoá đơn của
chúng ta, chuyển qua một Collection. Sau đó phương thức này loại bỏ tất cả các phần tử khỏi danh sách có trong Collection.
Hãy thử chạy mã dưới đây:
Các kết quả không phải là những gì mà chúng ta muốn. Chúng ta đã kết thúc mà không còn hóa đơn nào trong ví cả. Tại sao?
Bởi vì removeAll() loại bỏ tất cả các kết quả khớp. Nói cách khác, bất kỳ và tất cả các kết quả khớp với một mục trong List
mà chúng ta chuyển cho phương thức đều bị loại bỏ. Các hoá đơn thanh toán mà chúng ta đã chuyển cho phương thức có chứa
1 và 2. Ví của chúng ta có chứa hai số 1 và một số 2. Khi removeAll() tìm kiếm kết quả khớp với phần tử số 1, nó tìm thấy hai
kết quả khớp và loại bỏ chúng cả hai. Đó không phải là những gì mà chúng ta muốn! Chúng ta cần thay đổi mã của chúng ta
trong removeBills() để sửa lại điều này:
Mã này chỉ loại bỏ một kết quả khớp riêng rẽ, chứ không phải là tất cả các kết quả khớp. Nhớ cẩn thận với removeAll().
Triển khai thực hiện tập hợp
Có hai triển khai thực hiện Tập hợp (Set) thường được sử dụng phổ biến:
•
HashSet, không đảm bảo thứ tự vòng lặp.
•
TreeSet, bảo đảm thứ tự vòng lặp.
Các tài liệu hướng dẫn ngôn ngữ Java gợi ý rằng bạn sẽ đi đến chỗ sử dụng triển khai thực hiện thứ nhất trong hầu hết các
trường hợp. Nói chung, nếu bạn cần phải chắc chắn rằng các phần tử trong Set của bạn xếp theo một thứ tự nhất định nào đó
khi bạn duyệt qua nó bằng một trình vòng lặp, thì hãy sử dụng triển khai thực hiện thứ hai. Nếu không, sử dụng cách thứ nhất.
Thứ tự của các phần tử trong một TreeSet (có thực hiện giao diện SortedSet) được gọi là thứ tự tự nhiên (natural ordering);
điều này có nghĩa là, hầu hết mọi trường hợp, bạn sẽ có khả năng sắp xếp các phần tử dựa trên phép so sánh equals().
Giả sử rằng mỗi Adult có một tập hợp các biệt hiệu. Chúng ta thực sự không quan tâm đến chúng được sắp đặt thế nào, nhưng
các bản sao sẽ không có ý nghĩa. Chúng ta có thể sử dụng một HashSet để lưu giữ chúng. Trước tiên, chúng ta thêm một biến
cá thể:
Sau đó chúng ta thêm một phương thức để thêm biệt hiệu vào Set:
Bây giờ hãy thử chạy mã này:
Bạn sẽ thấy chỉ có một Bobby đơn lẻ xuất hiện trên màn hình.

Các triển khai thực hiện Map
Map (Ánh xạ) là một tập hợp các cặp khóa - giá trị. Nó không thể chứa các khóa giống hệt nhau. Mỗi khóa phải ánh xạ tới một
giá trị đơn lẻ, nhưng giá trị đó có thể là bất kỳ kiểu gì. Bạn có thể nghĩ về một ánh xạ như là List có đặt tên. Hãy tưởng tượng
một List trong đó mỗi phần tử có một tên mà bạn có thể sử dụng để trích ra phần tử đó trực tiếp. Khóa có thể là bất cứ cái gì
kiểu Object, giống như giá trị. Một lần nữa, điều đó có nghĩa là bạn không thể lưu trữ các giá trị kiểu nguyên thủy (primitive)
trực tiếp vào trong một Map (bạn có ghét các giá trị kiểu nguyên thủy không đấy ?). Thay vào đó, bạn phải sử dụng các lớp
bao gói kiểu nguyên thủy để lưu giữ các giá trị đó.
Mặc dù đây là một chiến lược tài chính mạo hiểm, chúng ta sẽ cung cấp cho mỗi Adult một tập hợp các thẻ tín dụng đơn giản
nhất có thể chấp nhận được. Mỗi thẻ sẽ có một tên và một số dư (ban đầu là 0). Trước tiên, chúng ta thêm một biến cá thể:
Sau đó chung ta thêm một phương thức để bổ sung thêm một thẻ tín dụng (CreditCard)tới Map:
Giao diện của Map khác với các giao diện của các sưu tập khác. Bạn gọi put() với một khóa và một giá trị để thêm một mục
vào ánh xạ. Bạn gọi get() với khóa để trích ra một giá trị. Chúng ta sẽ làm việc này trong một phương thức để hiển thị số dư
của một thẻ:
Tất cả những gì còn lại là thêm phương thức charge() để cho phép cộng thêm vào số dư của chúng ta:
Bây giờ hãy thử chạy mã dưới đây, nó sẽ hiển thị cho bạn 19.95 trên màn hình.
Một thẻ tín dụng điển hình có một tên, một số tài khoản, một hạn mức tín dụng và một số dư. Mỗi mục trong một Map chỉ có
thể có một khóa và một giá trị. Các thẻ tín dụng rất đơn giản của chúng ta rất phù hợp, bởi vì chúng chỉ có một tên và một số
dư hiện tại. Chúng ta có thể làm cho phức tạp hơn bằng cách tạo ra một lớp được gọi là CreditCard, với các biến cá thể dành
cho tất cả các đặc tính của một thẻ tín dụng, sau đó lưu trữ các cá thể của lớp này như các giá trị cho các mục trong Map của
chúng ta.
Có một số khía cạnh thú vị khác về giao diện Map để trình bày trước khi chúng ta đi tiếp (đây không phải là một danh sách
đầy đủ):
Phương thức Hành vi
containsKey() Trả lời Map có chứa khóa đã cho hay không.
containsValue() Trả lời Map có chứa giá trị đã cho hay không.
keySet() Trả về một Set tập hợp các khóa.
values() Trả về một Set tập hợp các giá trị.
entrySet() Trả về một Set tập hợp các cặp khóa - giá trị, được định nghĩa như là các cá thể của các Map.Entry.
remove() Cho phép bạn loại bỏ giá trị cho một khóa đã cho.
isEmpty() Trả lời Map có rỗng không (rỗng có nghĩa là, không chứa khóa nào).

Một số trong các phương thức này, chẳng hạn như isEmpty() chỉ là để cho tiện thôi, nhưng một số là rất quan trọng. Ví dụ,
cách duy nhất để thực hiện vòng lặp qua các phần tử trong một Map là thông qua một trong các tập hợp có liên quan (tập hợp
các khóa, các giá trị, hoặc các cặp khóa-giá trị).
Lớp Collections
Khi bạn đang sử dụng khung cộng tác các sưu tập Java, bạn cần phải nắm được những gì có sẵn trong lớp Collections. Lớp
này gồm có một kho lưu trữ các phương thức tĩnh để hỗ trợ các thao tác trên sưu tập. Chúng tôi sẽ không trình bày tất cả
chúng ở đây, bởi vì bạn có thể tự mình đọc API, nhưng chúng tôi sẽ trình bày hai phương thức thường xuyên xuất hiện trong
mã Java:
•
copy()
•
sort()
Phương thức đầu tiên cho phép bạn sao chép các nội dung của một sưu tập này tới một sưu tập khác, như sau:
Mã này sao chép từ nguồn (source) vào đích (target). Đích phải có cùng kích thước như nguồn, vì thế bạn không thể sao chép
một List vào một List rỗng.
Phương thức sort() sắp xếp các phần tử theo thứ tự tự nhiên của chúng. Tất cả các phần tử phải triển khai thực hiện giao diện
Comparable sao cho chúng có thể so sánh với nhau. Các lớp có sẵn giống như String đã thực hiện điều này. Vì vậy, đối với
một tập hợp các chuỗi ký tự, chúng ta có thể sắp xếp chúng theo thứ tự tăng dẫn theo kiểu biên soạn từ điển bằng mã sau đây:

Bạn sẽ nhận được [four, one, three, two] trên màn hình. Nhưng bạn có thể sắp xếp các lớp mà bạn tạo ra như thế nào? Chúng
ta có thể làm điều này cho Adult. Trước tiên, chúng ta làm cho lớp Adult có thể so sánh lẫn nhau:
Sau đó, chúng ta ghi đè compareTo() để so sánh hai cá thể Adult Chúng ta sẽ duy trì việc so sánh rất đơn giản để làm ví dụ, do
đó nó làm rất ít việc:
Bất kỳ số nào nhỏ hơn 0 có nghĩa là "bé hơn", và -1 là giá trị thích hợp để sử dụng. Tương tự, 1 là thuận tiện để dành cho "lớn
hơn". Như bạn có thể thấy, 0 có nghĩa là "bằng nhau". So sánh hai đối tượng theo cách này rõ ràng là một quá trình thủ công.
Bạn cần phải đi qua các biến cá thể và so sánh từng biến. Trong trường hợp này, chúng ta so sánh tên và họ và sắp xếp thực tế
theo họ. Nhưng bạn nên biết, tại sao ví dụ của chúng ta lại rất đơn giản. Mỗi Adult có nhiều hơn là chỉ tên và họ. Nếu chúng ta
muốn làm một phép so sánh sâu hơn, chúng ta sẽ phải so sánh các Wallet của mỗi Adult để xem xem chúng có bằng nhau
không, nghĩa là chúng ta sẽ phải triển khai thực hiện compareTo() trên Wallet và phần còn lại. Ngoài ra, để thật chính xác khi
so sánh, bất cứ khi nào bạn ghi đè compareTo(), bạn cần phải chắc chắn là phép so sánh là tương thích với equals(). Chúng ta

không triển khai thực hiện equals(), vì thế chúng ta không lo lắng về việc tương thích với nó, nhưng chúng ta có thể phải làm.
Trong thực tế, tôi đã thấy mã có bao gồm một dòng như sau, trước khi trả về EQUAL:
Cách tiếp cận khác để so sánh các đối tượng là trích thuật toán trong compareTo() vào một đối tượng có kiểu Trình so sánh
(Comparator), sau đó gọi Collections.sort() với sưu tập cần sắp xếp và Comparator, như sau:
Bạn sẽ thấy "Al Jones" và "Bob Smith", theo thứ tự đó, trong cửa sổ màn hình của bạn.
Có một số lý do thích đáng để sử dụng cách tiếp cận thứ hai. Các lý do kỹ thuật vượt ra ngoài phạm vi của hướng dẫn này.
Tuy nhiên, từ viễn cảnh của phát triển hướng đối tượng, đây có thể là một ý tưởng tốt khi tách biệt phần mã so sánh vào trong
đối tượng khác, hơn là cung cấp cho mỗi Adult khả năng tự so sánh với nhau. Tuy nhiên, vì đây thực sự là những gì mà
equals() thực hiện, mặc dù kết quả là toán tử boolean, có các lập luận thích hợp ủng hộ cho cả hai cách tiếp cận.
Using collections
Khi nào bạn nên sử dụng một kiểu sưu tập cụ thể ? Đó là một phán xét cần đến năng lực của bạn, và chính vì thế mà bạn hy
vọng sẽ được trả lương hậu hĩ khi là một lập trình viên.
Bất chấp những gì mà nhiều chuyên gia tin tưởng, có rất ít các quy tắc chắc chắn và nhanh chóng để xác định cần sử dụng
những lớp nào trong một tình huống đã cho nào đó. Theo kinh nghiệm cá nhân của tôi, trong phần lớn các lần khi sử dụng các
sưu tập, một ArrayList hoặc một HashMap (hãy nhớ, một Map không thật sự là một sưu tập) đều bị chơi khăm. Rất có khả
năng, bạn cũng từng có trải nghiệm như vậy. Dưới đây là một số quy tắc ngón tay cái, một số là hiển nhiên hơn những cái còn
lại:
•
Khi bạn nghĩ rằng mình cần có một sưu tập, hãy bắt đầu với một List, sau đó cứ để cho các mã sẽ báo cho bạn biết
có cần một kiểu khác không.
•
Nếu bạn chỉ cần nhóm các thứ gì đó, hãy sử dụng một Set.
•
Nếu thứ tự trong vòng lặp là rất quan trọng khi duyệt qua một sưu tập, hãy sử dụng Tree một hương vị khác của
sưu tập, khi ở đó có sẵn.
•
Tránh sử dụng Vector, trừ khi bạn cần khả năng đồng bộ hóa của nó.
•
Không nên lo lắng về việc tối ưu hóa cho đến khi (và trừ khi) hiệu năng trở thành một vấn đề.
Các bộ sưu tập là một trong những khía cạnh mạnh mẽ nhất của ngôn ngữ Java. Đừng ngại khi sử dụng chúng, nhưng cần cảnh

giác về các vụ "Tìm ra rồi" (gotchas). Ví dụ, có một cách thuận tiện để chuyển đổi từ một Array thành một ArrayList:
Mã này đưa ra một UnsupportedOperationException, vì List được Arrays.asList() trả về là không thay đổi được. Bạn không
thể thêm một phần tử mới vào một List không thay đổi. Hãy để ý.
Theo IBM Việt Nam