Duyệt collection trong Java: for-each, Iterator, forEach

Một việc, nhiều công cụ

Bạn đã gom dữ liệu vào một ArrayList, một HashSet hay một HashMap, và giờ muốn đi qua từng phần tử. Java có vài cách để làm việc này. Chọn cách nào tùy vào việc bạn có cần chỉ số không, có cần xóa phần tử giữa vòng lặp không, và bạn thích cú pháp kiểu phương thức hay kiểu vòng lặp.

Tin vui là mọi Collection (list, set, queue) đều hỗ trợ cùng một vòng lặp for nâng cao, nên học một lần là bạn duyệt được tất cả theo cùng một cách.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (String lang : langs) {
            System.out.println(lang);
        }
    }
}

Hãy đọc dấu hai chấm là "trong": "với mỗi lang trong langs". Bạn không bao giờ đụng đến chỉ số, nên không có gì để viết sai.

Vòng lặp for-each

Vòng lặp for nâng cao là lựa chọn mặc định khi bạn chỉ cần "làm gì đó với từng phần tử". Nó dễ đọc và hoạt động giống hệt nhau trên mọi loại collection. Ví dụ dưới đây dùng HashSet, loại hoàn toàn không có chỉ số:

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("urgent");
        tags.add("review");
        tags.add("urgent");   // duplicate ignored by a Set

        for (String tag : tags) {
            System.out.println(tag);
        }
    }
}

Một điều cần nhớ về HashSet: nó không có thứ tự xác định, nên các phần tử có thể được in ra theo bất kỳ thứ tự nào. Dù vậy, for-each vẫn đi qua mỗi phần tử đúng một lần.

Khi bạn cần chỉ số

For-each cho bạn phần tử nhưng không cho vị trí của nó. Nếu bạn thật sự cần chỉ số, chẳng hạn để đánh số dòng hoặc để xem các phần tử kế bên, hãy dùng vòng lặp đếm với size() và get(i). Cách này dùng được với List vì list có vị trí; set và map không có chỉ số nên không áp dụng được.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (int i = 0; i < langs.size(); i++) {
            System.out.println((i + 1) + ". " + langs.get(i));
        }
    }
}

Đừng dùng cách này chỉ vì thói quen. Nếu bạn không dùng i vào việc gì ngoài get(i), phiên bản for-each ngắn hơn và khó viết sai hơn.

Duyệt một Map

Map không phải là Collection, nên bạn không thể dùng for-each trực tiếp trên nó. Thay vào đó, bạn duyệt qua một trong ba view của nó. Phổ biến nhất là entrySet(), trả về từng cặp khóa và giá trị cùng lúc:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 28);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Nếu chỉ cần khóa, hãy duyệt ages.keySet(); nếu chỉ cần giá trị, hãy duyệt ages.values(). Nên dùng entrySet() khi cần cả hai: duyệt khóa rồi gọi ages.get(key) bên trong sẽ tra cứu thêm một lần ở mỗi lần lặp mà chẳng được lợi gì.

Iterator

For-each thực ra là cú pháp rút gọn (syntactic sugar) của một Iterator, một đối tượng đi qua collection từng phần tử một bằng hasNext() và next(). Bạn hiếm khi tự viết vòng lặp này, trừ một trường hợp quan trọng: đây là cách an toàn để xóa phần tử trong lúc duyệt.

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));

        Iterator<Integer> it = nums.iterator();
        while (it.hasNext()) {
            int n = it.next();
            if (n % 2 == 0) {
                it.remove();   // safe: removes the element just returned
            }
        }

        System.out.println(nums);
    }
}

it.remove() xóa phần tử mà next() vừa trả về, và iterator vẫn dùng tiếp được. Đây là cách duy nhất được cho phép để thay đổi collection trong một vòng lặp tự viết.

Cái bẫy: ConcurrentModificationException

Nếu bạn gọi add hoặc remove trên chính collection bên trong vòng lặp for-each, bạn sẽ gặp ConcurrentModificationException: iterator nhận ra collection đã bị thay đổi bên dưới nó và từ chối chạy tiếp. Đây là một trong những lỗi phổ biến nhất của người mới, và như mọi ngoại lệ lúc chạy, nó làm phương thức dừng lại nếu bạn không tránh được nó.

List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4));
for (int n : nums) {
    if (n % 2 == 0) {
        nums.remove(Integer.valueOf(n));   // throws ConcurrentModificationException
    }
}

Cách sửa hầu như luôn là removeIf, vừa thể hiện ý định trong một dòng vừa lo phần duyệt giúp bạn:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // drop the even numbers
        System.out.println(nums);
    }
}

removeIf dùng được với mọi Collection, nên cùng lời gọi đó cũng dọn dẹp được một HashSet.

Phương thức forEach

Mọi collection còn có phương thức forEach nhận một lambda và chạy nó trên từng phần tử. Đây là lựa chọn theo phong cách hàm, dạng biểu thức, thay cho vòng lặp, rất tiện cho những câu lệnh ngắn một dòng:

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");
        langs.forEach(lang -> System.out.println(lang));

        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 28);
        ages.forEach((name, age) -> System.out.println(name + ": " + age));
    }
}

Lưu ý rằng Map.forEach nhận trực tiếp một lambda hai tham số (key, value), không cần entrySet(). Dùng forEach cho những tác vụ phụ nhanh gọn; quay lại vòng lặp for thông thường khi phần thân dài ra hoặc bạn cần break thoát sớm, điều mà lambda không làm được.

Tiếp theo: phương thức

Giờ bạn đã gói dữ liệu vào collection và duyệt qua nó bằng mọi cách Java hỗ trợ. Bước tiếp theo là đóng gói hành vi: tự viết phương thức để đặt tên cho một khối logic, truyền dữ liệu vào và dùng lại nó. Đó là nội dung của trang tiếp theo.