Các sưu tập
Khung công tác của các sưu tập Java (Java Collections Framework) là rộng lớn. Trong hướng dẫn Giới thiệu về lập trình Java, tôi đã nói về lớp ArrayList, nhưng đó là chỉ bàn sơ qua trên bề mặt. 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ửObjectcó 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:
protected class Wallet { protected ArrayList bills = new ArrayList(); protected void addBill(int aBill) { bills.add(new Integer(aBill)); } protected int getMoneyTotal() { int total = 0; for (Iterator i = bills.iterator(); i.hasNext(); ) { Integer wrappedBill = (Integer) i.next(); int bill = wrappedBill.intValue(); total += bill; } return total; } } |
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 ArrayListbằ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:
public void spendMoney(int aBill) { this.wallet.removeBill(aBill); } |
Phương thức này gọi removeBill() trên Wallet:
protected void removeBill(int aBill) { Iterator iterator = bills.iterator(); while (iterator.hasNext()) { Integer bill = (Integer) iterator.next(); if (bill.intValue() == aBill) iterator.remove(); } } |
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:
protected void removeBill(int aBill) { bills.remove(new Integer(aBill)); } |
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ộtList để giúp chúng ta loại bỏ nhiều hóa đơn cùng một lúc, như sau:
public void spendMoney(List bills) { this.wallet.removeBills(bills); } |
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:
protected void removeBills(List billsToRemove) { this.bills.removeAll(bills); } |
Đâ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ó trongCollection. Hãy thử chạy mã dưới đây:
List someBills = new ArrayList(); someBills.add(new Integer(1)); someBills.add(new Integer(2)); Adult anAdult = new Adult(); anAdult.acceptMoney(1); anAdult.acceptMoney(1); anAdult.acceptMoney(2); List billsToRemove = new ArrayList(); billsToRemove.add(new Integer(1)); billsToRemove.add(new Integer(2)); anAdult.spendMoney(someBills); System.out.println(anAdult.wallet.bills); |
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 trongremoveBills() để sửa lại điều này:
protected void removeBills(List billsToRemove) { Iterator iterator = billsToRemove.iterator(); while (iterator.hasNext()) { this.bills.remove(iterator.next()); } } |
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().
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ể:
protected Set nicknames = new HashSet(); |
Sau đó chúng ta thêm một phương thức để thêm biệt hiệu vào Set:
public void addNickname(String aNickname) { nicknames.add(aNickname); } |
Bây giờ hãy thử chạy mã này:
Adult anAdult = new Adult(); anAdult.addNickname("Bobby"); anAdult.addNickname("Bob"); anAdult.addNickname("Bobby"); System.out.println(anAdult.nicknames); |
Bạn sẽ thấy chỉ có một Bobby đơn lẻ xuất hiện trên màn hình.
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ộtList 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ểuObject, 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ể:
protected Map creditCards = new HashMap(); |
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:
public void addCreditCard(String aCardName) { creditCards.put(aCardName, new Double(0)); } |
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ẻ:
public double getBalanceFor(String cardName) { Double balance = (Double) creditCards.get(cardName); return balance.doubleValue(); } |
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:
public void charge(String cardName, double amount) { Double balance = (Double) creditCards.get(cardName); double primitiveBalance = balance.doubleValue(); primitiveBalance += amount; balance = new Double(primitiveBalance); creditCards.put(cardName, balance); } |
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.
Adult anAdult = new Adult(); anAdult.addCreditCard("Visa"); anAdult.addCreditCard("MasterCard"); anAdult.charge("Visa", 19.95); adAdult.showBalanceFor("Visa"); |
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ị).
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:
List source = new ArrayList(); source.add("one"); source.add("two"); List target = new ArrayList(); target.add("three"); target.add("four"); Collections.copy(target, source); System.out.println(target); |
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ệnComparable 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:
List strings = new ArrayList(); strings.add("one"); strings.add("two"); strings.add("three"); strings.add("four"); Collections.sort(strings); System.out.println(strings); |
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:
public class Adult extends Person implements Comparable { ... } |
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:
public int compareTo(Object other) { final int LESS_THAN = -1; final int EQUAL = 0; final int GREATER_THAN = 1; Adult otherAdult = (Adult) other; if ( this == otherAdult ) return EQUAL; int comparison = this.firstname.compareTo(otherAdult.firstname); if (comparison != EQUAL) return comparison; comparison = this.lastname.compareTo(otherAdult.lastname); if (comparison != EQUAL) return comparison; return EQUAL; } |
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:
assert this.equals(otherAdult) : "compareTo inconsistent with equals."; |
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:
public class AdultComparator implements Comparator { public int compare(Object object1, Object object2) { final int LESS_THAN = -1; final int EQUAL = 0; final int GREATER_THAN = 1; if ((object1 == null) ;amp;amp (object2 == null)) return EQUAL; if (object1 == null) return LESS_THAN; if (object2 == null) return GREATER_THAN; Adult adult1 = (Adult) object1; Adult adult2 = (Adult) object2; if (adult1 == adult2) return EQUAL; int comparison = adult1.firstname.compareTo(adult2.firstname); if (comparison != EQUAL) return comparison; comparison = adult1.lastname.compareTo(adult2.lastname); if (comparison != EQUAL) return comparison; return EQUAL; } } public class CommunityApplication { public static void main(String[] args) { Adult adult1 = new Adult(); adult1.setFirstname("Bob"); adult1.setLastname("Smith"); Adult adult2 = new Adult(); adult2.setFirstname("Al"); adult2.setLastname("Jones"); List adults = new ArrayList(); adults.add(adult1); adults.add(adult2); Collections.sort(adults, new AdultComparator()); System.out.println(adults); } } |
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.
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:
Adult adult1 = new Adult(); Adult adult2 = new Adult(); Adult adult3 = new Adult(); List immutableList = Arrays.asList(new Object[] { adult1, adult2, adult3 }); immutableList.add(new Adult()); |
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 để ý.
