Danh sách tất cả các bộ sưu tập

"Chào, Amigo."

"Này, Rishi."

"Ellie nói với tôi rằng bạn muốn có thêm các ví dụ về bộ sưu tập. Tôi sẽ cung cấp cho bạn một vài ví dụ. Đây là danh sách các bộ sưu tập và giao diện:"

"Hmm. Khá nhiều đấy. Bốn danh sách, ba bộ và bốn bản đồ."

"Có, tất cả chúng đều là các triển khai khác nhau của giao diện Danh sách, Tập hợp và Bản đồ."

"Sự khác biệt giữa các triển khai này là gì?"

"Đó chính xác là những gì chúng ta sẽ nói hôm nay. Hãy kiên nhẫn."

"Bạn có bất cứ câu hỏi nào khác không?"

"Tôi biết cách hiển thị danh sách trên màn hình. Làm cách nào để hiển thị Tập hợp hoặc Bản đồ?"

"Các phần tử của Danh sách có thứ tự đã đặt, vì vậy bạn chỉ có thể sử dụng chỉ mục để hiển thị chúng. Đối với Tập hợp hoặc Bản đồ, không có thứ tự cụ thể. Thực tế, thứ tự của các phần tử của chúng có thể thay đổi khi các mục bị xóa hoặc mới các mục được thêm vào."

"Tuyệt vời."

"Đây là lý do tại sao các đối tượng đặc biệt, được gọi là trình vòng lặp , được phát minh để hoạt động với các phần tử của bộ sưu tập. Chúng cho phép bạn xem qua tất cả các phần tử trong một bộ sưu tập, ngay cả khi chúng chỉ có tên thay vì chỉ số (Bản đồ) hoặc không có tên cũng như chỉ số ( Bộ)."

"Đây là một số ví dụ:"

public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

     // Get an iterator for the set
     Iterator&ltString> iterator = set.iterator();

    while (iterator.hasNext())        // Check if there is another element
    {
       // Get the current element and move to the next one
       String text = iterator.next();

        System.out.println(text);
    }
}

public static void main(String[] args)
{
    List&ltString> list = new ArrayList&ltString>();
    list.add("Rain");
    list.add("In");
    list.add("Spain");

    Iterator&ltString> iterator = list.iterator();// Get an iterator for the list

    while (iterator.hasNext())      // Check if there is another element
    {
        // Get the current element and move to the next one
        String text = iterator.next();

        System.out.println(text);
    }
}

public static void main(String[] args)
{
    // All elements are stored in pairs
    Map<String, String> map = new HashMap<String, String>();
    map.put("first", "Rain");
    map.put("second", "In");
    map.put("third", "Spain");

    Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();

   while (iterator.hasNext())
    {
        // Get a key-value pair
        Map.Entry<String, String> pair = iterator.next();
        String key = pair.getKey();            // Key
        String value = pair.getValue();        // Value
        System.out.println(key + ":" + value);
    }
}

"Chà. Tôi tự hỏi tất cả những điều đó có nghĩa là gì."

"Nó thực sự khá đơn giản. Đầu tiên, chúng ta lấy một đối tượng đặc biệt, một iterator, từ bộ sưu tập. Iterator chỉ có hai phương thức.

1. Phương thức next() trả về phần tử tiếp theo trong tập hợp.

2. Phương thức hasNext() kiểm tra xem có còn phần tử nào chưa được trả về bởi next() hay không."

"OK. Tôi nghĩ mọi chuyện đã rõ ràng hơn rồi. Hãy để tôi cố gắng nhắc lại cho bạn nghe những gì tôi đã hiểu."

"Vì vậy... Đầu tiên, chúng ta cần gọi phương thức iterator() trên một bộ sưu tập để lấy đối tượng trình lặp ma thuật này."

"Sau đó, chúng tôi lấy từng phần tử một miễn là còn bất kỳ phần tử nào để lấy. Chúng tôi lấy phần tử tiếp theo trong bộ sưu tập bằng cách gọi next() và chúng tôi kiểm tra xem có còn phần tử nào trong bộ sưu tập hay không bằng cách gọi hasNext() trên iterator. Điều đó có đúng không?"

"Ừ, ít nhiều cũng được. Nhưng hãy đợi phần hay."

"Java có ký hiệu viết tắt để làm việc với các trình vòng lặp. Theo mẫu của while và for , một câu lệnh đặc biệt nữa đã được thêm vào: for each . Nó cũng được biểu thị bằng cách sử dụng từ khóa for ."

"Câu lệnh for-each chỉ được sử dụng để làm việc với các bộ sưu tập và bộ chứa. Nó ngầm sử dụng một trình vòng lặp, nhưng chúng ta chỉ thấy phần tử được trả về."

"Hãy để tôi chỉ cho bạn các cách viết tay và viết tắt để làm việc với một trình vòng lặp:"

public static void main(String[] args)
{
  Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

    Iterator&ltString> iterator = set.iterator();
  while (iterator.hasNext())
  {
    String text = iterator.next();
    System.out.println(text);
  }
}

public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

   for (String text : set)
    {
        System.out.println(text);
    }
}

"Lưu ý rằng các từ được đánh dấu màu đỏ hoặc xanh lá cây không có ở phần bên phải. Trên thực tế, ba dòng được thay thế bằng một:"

Iterator&ltString> iterator = set.iterator();
while (iterator.hasNext())
{
    String text = iterator.next();

for (String text : set)

"Cái này trông đẹp đấy. Tôi thích nó theo cách này hơn nhiều."

"Hãy xem phiên bản tốc ký của các ví dụ trên:"

public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

    for (String text : set)
    {
        System.out.println(text);
    }
}

public static void main(String[] args)
{
    List&ltString> list = new ArrayList&ltString>();
    list.add("Rain");
    list.add("In");
    list.add("Spain");

     for (String text : list)
    {
        System.out.println(text);
    }
}

public static void main(String[] args)
{
    Map<String, String> map = new HashMap<String, String>();
    map.put("first", "Rain");
    map.put("second", "In");
    map.put("third", "Spain");

    for (Map.Entry<String, String> pair : map.entrySet())
    {
        String key = pair.getKey();                      // Key
        String value = pair.getValue();                  // Value
        System.out.println(key + ":" + value);
    }
}

"Bây giờ bạn đang nói chuyện!"

"Tôi vui vì bạn thích nó."