Java: Các cải tiến trong các lớp Collections

Từ Java SE 6 đã giới thiệu các lớp Collections mới như một phần của API Collection. Cụ thể như sau:

ArrayDeque

Lớp ArrayDeque thực thi interface Deque. Lớp này nhanh hơn ngăn xếp và danh sách liên kết khi được sử dụng như một hàng đợi. Nó không giới hạn dung lượng và không cho phép giá trị rỗng. Nó không phải là chủ đề an toàn. Nói cách khác, nó không cho phép truy cập đồng thời bởi nhiều luồng.

Lớp ArrayDeque cung cấp các phương thức addFirst(E e), addLast(E e), getFirst (), getLast(), removeFirst() và removeLast() để thêm, truy xuất và loại bỏ các phần tử từ vị trí đầu tiên và cuối cùng tương ứng. Các phần tử có thể được truy cập và duyệt theo hướng tiến và lùi tương ứng. Lớp ArrayDeque cũng cung cấp phương thức contains() trả về true nếu hàm chứa phần tử được chỉ định.

Ví dụ sau cho thấy việc sử dụng một số phương thức có sẵn trong lớp ArrayDeque.

import java.util.ArrayDeque;
import java.util.Iterator;
public static void main(String args[]){
  ArrayDeque arrDeque=new ArrayDeque();
  arrDeque.addLast("Mango");
  arrDeque.addLast("Apple");
  arrDeque.addFirst("Banana");
  for(Iterator iter=arrDeque.iterator();iter.hasNext();){
    System.out.println(iter.next());
  }
  for(Iterator descendingIter=arrDeque.descendingIterator();descendingIter.hasNext();){
    System.out.println(descendingIter.next());
  }
  System.out.println("First Element: "+arrDeque.getFirst());
  System.out.println("Last Element: "+arrDeque.getLast());
  System.out.println("Contains \"Apple\" : "+arrDeque.contains("Apple"));
}

Ví dụ trên tạo ra một thể hiện của ArrayDeque, thêm các phần tử vào nó và sau đó duyệt theo các hướng tiến và lùi. Các phương thức getFirst() và getLast() lần lượt truy xuất các phần tử đầu tiên và cuối cùng là Banana và Apple . Phương thức contains() kiểm tra xem Arraydeque có chứa phần tử là Apple hay không và trả về true sau khi tìm thấy phần tử được chỉ định.

ConcurrentSkipListSet

Lớp ConcurrentSkipListSet thực thi interface NavigableSet. Các phần tử được sắp xếp dựa trên thứ tự tự nhiên hoặc theo Comparator. Comparator là một interface sử dụng phương thức compare() để sắp xếp các đối tượng không có thứ tự tự nhiên. Trong thời gian tạo tập hợp, Comparator được cung cấp. Lớp ConcurrentSkipListSet cung cấp các phương thức trả về các trình vòng lặp theo thứ tự tăng dần hoặc giảm dần. Nó cũng cung cấp các phương thức để trả về các kết quả phù hợp nhất của các phần tử trong một collection.

Cú pháp:

ConcurrentSkipListSet()

Hàm tạo tạo một thể hiện với các phần tử của nó được sắp xếp theo thứ tự tự nhiên.

Bảng dưới đây liệt kê và mô tả các phương thức khác nhau có sẵn trong lớp ConcurrentSkipListSet.

Lưu ý rằng đối số e là phần tử được so khớp trong danh sách.

Phương thức	Mô tả
ceiling(E e)	Trả về phần tử nhỏ nhất lớn hơn hoặc bằng e hoặc null nếu không có phần tử như vậy
floor(E e)	Trả về phần tử lớn nhất nhỏ hơn hoặc bằng e hoặc null nếu không có phần tử như vậy
higher(E e)	Trả về phần tử nhỏ nhất lớn hơn e hoặc null nếu không có phần tử như vậy
lower(E e)	Trả về phần tử lớn nhất nhỏ hơn e hoặc null nếu không có phần tử như vậy

Các phương thức của lớp ConcurrentSkipListSet

Ví dụ sau cho thấy việc sử dụng một số phương thức có sẵn trong lớp ConcurrentSkipListSet.

import java.util.Iterator;
import java.util.concurrent.ConcurrentSkipListSet;
...
public static void main(String args[]){
  ConcurrentSkipListSet fruitSet=new ConcurrentSkipListSet();
  fruitSet.add("Banana");
  fruitSet.add("Peach");
  fruitSet.add("Apple");
  fruitSet.add("Mango");
  fruitSet.add("Orange");
  // Displays in ascending order
  Iterator iterator=fruitSet.iterator();
  System.out.print("In ascending order :");
  while(iterator.hasNext())
    System.out.print(iterator.next()+" ");
  // Displays in descending order System.out.println("In descending order: " + fruitSet.descendingSet() + "\n");
  System.out.println("Lower element: "+fruitSet.lower("Mango"));
  System.out.println("Higher element: "+fruitSet.higher("Apple"));
}

Ví dụ trên tạo một thể hiện ConcurrentSkipListSet và thêm các phần tử vào đó. Sau đó, nó sắp xếp các phần tử của nó theo thứ tự tăng dần và giảm dần, và tìm các phần tử thấp hơn và cao hơn. Ở đây, các phần tử được hiển thị theo thứ tự giảm dần bằng cách sử dụng phương thức downdingSet(). Ngoài ra, các phương thức lower() và higher() trả về phần tử trước Mango và sau Apple là Banana tương ứng.

ConcurrentSkipListMap

Lớp ConcurrentSkipListMap thực thi interface ConcurrentNavigableMap. Nó thuộc về gói java.util.concurrent. Giống như lớp ConcurrentHashMap, lớp ConcurrentSkipListMap cho phép sửa đổi mà không cần khóa toàn bộ map.

Cú pháp:

ConcurrentSkipListMap()

Hàm tạo tạo một map trống mới trong đó map được sắp xếp theo thứ tự tự nhiên của các key.

Phương thức	Mô tả
descendingMap()	Đảo ngược tất cả dữ liệu theo thứ tự giảm dần
firstEntry()	Trả về dữ liệu hiện có với key thấp nhất trong map
ceilingEntry(phím K)	Trả về giá trị gần nhất lớn hơn hoặc bằng key được chỉ định hoặc null nếu không có key như vậy
lastEntry()	Trả về dữ liệu hiện có với key lớn nhất trong map
put(K key, V value)	Chèn giá trị trước đó được liên kết với key được chỉ định hoặc null nếu không có giá trị đó. Ở đây, key là key liên kết với một giá trị đã chỉ định và giá trị là giá trị mà một key được chỉ định được liên kết.

Các phương thức của lớp ConcurrentSkipListMap

Ví dụ sau cho thấy việc sử dụng một số phương pháp có sẵn trong lớp ConcurrentSkipListMap.

import java.util.concurrent.ConcurrentSkipListMap;
  ...
  ...
public static void main(String args[]){
  ConcurrentSkipListMap fruits=new ConcurrentSkipListMap();
  fruits.put(1, "Apple");
  fruits.put(2, "Banana");
  fruits.put(3, "Mango");
  fruits.put(4, "Orange");
  fruits.put(5, "Peach");
  // Retrieves first data
  System.out.println("First data: " +fruits.firstEntry()+ "\n");
  // Retrieves last data
  System.out.println("Last data: " +fruits.lastEntry()+ "\n");
  // Displays all data in descending order
  System.out.println("Data in reverse order: " +fruits.descendingMap());
}
...

Ví dụ trên sẽ chèn, truy xuất và đảo ngược dữ liệu từ một thể hiện của ConcurrentSkipListMap. Phương thức firstEntry() và lastEntry() hiển thị kết quả ánh xạ key-value cho phần tử đầu tiên và phần tử cuối cùng tương ứng.

LinkedBlockingDeque

Lớp LinkedBlockingDeque thực thi interface BlockingDeque. Lớp thuộc về gói java.util.concurrent. Trong lớp này, bạn có thể chỉ định dung lượng lưu trữ các phần tử. Nếu bạn không chỉ định dung lượng thì dung lượng tối đa sẽ có giá trị là Integer.MAX_VALUE. Lớp chứa các nút được liên kết được tạo động sau mỗi lần chèn. Cú pháp cho các hàm tạo như sau:

Cú pháp:

• LinkedBlockingDeque()

Hàm tạo tạo một thể hiện có dung lượng mặc định như được chỉ định trong Integer.MAX_ VALUE.

• LinkedBlockingDeque (int capacity)

Hàm tạo tạo một thể hiện với dung lượng được chỉ định.

Các phương thức

Bảng sau trình bày một số phương thức khác nhau có sẵn trong lớp LinkedBlockingDeque.

Lưu ý rằng đối số e là phần tử được thêm vào deque.

Phương thức	Mô tả
addFirst(E e)	Chèn phần tử được chỉ định e, vào đầu deque. Nó không vi phạm giới hạn dung lượng
pollFirst()	Loại bỏ và trả về phần tử đầu tiên của deque nếu có, nếu không nó sẽ trả về null
peekFirst()	Trả về nhưng không loại bỏ phần tử đầu tiên của deque nếu có, nếu không nó sẽ trả về null

Các phương thức của lớp LinkedBlockingDeque

/* ProducerDeque.Java */
import java.util.concurrent.BlockingDeque;

class ProducerDeque implements Runnable {
  private String name;
  private BlockingDeque blockDeque;

  public ProducerDeque(String name, BlockingDeque blockDeque) {
    this.name = name;
    this.blockDeque = blockDeque;
  }

  public void run() {
    for (int i = 1; i < 10; i++) {
      try {
        blockDeque.addFirst(i);
        System.out.println(name + puts + i);
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      } catch (IllegalStateException ex) {
        System.out.println(Deque filled upto the maximum capacity);
        System.exit(0);
      }
    }
  }
}
/* ConsumerDeque.Java */
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

class ConsumerDeque implements Runnable {
  private String name;
  private BlockingDeque blockDeque;

  public ConsumerDeque(String name, BlockingDeque blockDeque) {
    this.name = name;
    this.blockDeque = blockDeque;
  }
  public void run() {
    for (int i = 1; i < 10; i++) {
      try {
        int j = (Integer) blockDeque.peekFirst();
        System.out.println(name + takes + j);
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}
/* LinkedBlockingDequeClass.Java */
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class LinkedBlockingDequeClass {
  public static void main(String[] args) {
    BlockingDeque blockDeque = new LinkedBlockingDeque(5);
    Runnable produce = new ProducerDeque(Producer, blockDeque);
    Runnable consume = new ConsumerDeque(Consumer, blockDeque);
    new Thread(produce).start();
    new Thread(consume).start();
  }
}

Ví dụ trên tạo ra ba lớp là ProducerDeque, ConsumerDeque và LinkedBlockingDequeClass. Lớp ProducerDeque tạo một thể hiện của BlockingDeque gọi phương thức addFirst() để chèn 10 số nguyên vào phía trước deque. Lớp ConsumerDeque cũng tạo ra một thể hiện của BlockingDeque gọi phương thức peekFirst() để truy xuất và loại bỏ giá trị số nguyên cuối cùng có trong deque. Trong lớp chính, LinkedBlockingDequeClass, một đối tượng của lớp LinkedBlockingDeque được tạo cho phép bạn lưu trữ tối đa 5 phần tử trong deque. Nếu bạn cố gắng chèn nhiều hơn 5 phần tử vào deque, nó sẽ tạo ra IllegalStateException. Lớp chính, khi thực thi trước tiên chạy luồng Producer và chèn giá trị số nguyên 1 vào phía trước deque.

Tiếp theo, thread Consumer chạy và lấy giá trị số nguyên 1, nhưng không loại bỏ nó khỏi phần đầu. Một lần nữa, thread Producer thực thi và chèn 2 ở phía trước deque. Bây giờ, một lần nữa, thread Consumer chạy và lấy giá trị 2 hiện diện ở phía trước của deque, nhưng không loại bỏ nó khỏi phần đầu. Quá trình này lặp lại cho đến khi giá trị nguyên 4 được truy xuất từ ​​phần đầu của queue. Bây giờ, ngay sau khi giá trị số nguyên 5 cố gắng nhập deque, một thông báo sẽ hiển thị rằng deque được lấp đầy với dung lượng tối đa. Điều này là do deque đã đạt đến dung lượng tối đa, một IllegalStateEception được ném ra.

AbstractMap.SimpleEntry

AbstractMap.SimpleEntry là lớp tĩnh được lồng bên trong lớp AbstractMap. Lớp này được sử dụng để triển khai map tùy chỉnh. Một thể hiện của lớp này lưu trữ cặp key-value của một mục nhập duy nhất trong một map. Giá trị của mục nhập có thể được thay đổi.

Phương thức getKey() trả về key của mục nhập trong thể hiện. Phương thức getValue() trả về giá trị của mục nhập. Phương thức setValue() cập nhật giá trị của mục nhập.

Cú pháp:

AbstractMap.SimpleEntry(K key, V value)

Hàm tạo tạo một thể hiện với cặp key-value được chỉ định được biểu thị bằng khóa và giá trị.

Ví dụ sau cho thấy việc triển khai lớp tĩnh AbstractMap.SimpleEntry và việc sử dụng một số phương thức có sẵn của nó.

AbstractMap.SimpleEntry<String,String> se = new AbstractMap.SimpleEntry<S tring,String>(1,Apple);
System.out.println(se.getKey());
System.out.println(se.getValue());
se.setValue(Orange);
System.out.println(se.getValue());

Ví dụ trên tạo thể hiện với mục nhập có cặp key-value là (1, Apple). Sau đó, nó truy xuất key và value bằng phương thức getKey() và getValue() và thay thế giá trị của mục nhập cuối cùng từ Apple sang Orange bằng phương thức setValue().

AbstractMap.SimpleImmutableEntry

Lớp AbstractMap.SimpleImmutableEntry là lớp astatic được lồng bên trong lớp AbstractMap. Như tên cho thấy, nó không cho phép sửa đổi một giá trị trong một mục nhập. Nếu bất kỳ nỗ lực nào để thay đổi một giá trị được thực hiện, nó sẽ dẫn đến việc ném ra UnsupportedOperationException.