Khi nào tôi nên sử dụng luồng?

Tôi vừa gặp một câu hỏi khi sử dụng a Listvà stream()phương thức của nó . Mặc dù tôi biết cách sử dụng chúng, nhưng tôi không chắc chắn về thời điểm sử dụng chúng.

Ví dụ, tôi có một danh sách, chứa nhiều đường dẫn đến các vị trí khác nhau. Bây giờ, tôi muốn kiểm tra xem một đường dẫn đã cho có chứa bất kỳ đường dẫn nào được chỉ định trong danh sách hay không. Tôi muốn trả lại booleandựa trên việc điều kiện đó có được đáp ứng hay không.

Tất nhiên, đây không phải là một nhiệm vụ khó khăn. Nhưng tôi băn khoăn không biết nên sử dụng luồng hay vòng lặp for (-each).

Danh sách

private static final List<String> EXCLUDE_PATHS = Arrays.asList(new String[]{
    "my/path/one",
    "my/path/two"
});

Ví dụ - Luồng

private boolean isExcluded(String path){
    return EXCLUDE_PATHS.stream()
                        .map(String::toLowerCase)
                        .filter(path::contains)
                        .collect(Collectors.toList())
                        .size() > 0;
}

Ví dụ - Cho-Mỗi vòng lặp

private boolean isExcluded(String path){
    for (String excludePath : EXCLUDE_PATHS) {
        if(path.contains(excludePath.toLowerCase())){
            return true;
        }
    }
    return false;
}

Lưu ý rằng paththam số luôn là chữ thường .

Dự đoán đầu tiên của tôi là cách tiếp cận cho từng cách nhanh hơn, vì vòng lặp sẽ trả lại ngay lập tức, nếu điều kiện được đáp ứng. Trong khi luồng sẽ vẫn lặp lại tất cả các mục trong danh sách để hoàn tất quá trình lọc.

Giả định của tôi có đúng không? Nếu vậy, tại sao (hay đúng hơn là khi nào ) tôi lại sử dụng stream()?

Giả định của bạn là đúng. Việc triển khai luồng của bạn chậm hơn vòng lặp.

Tuy nhiên, việc sử dụng luồng này sẽ nhanh như vòng lặp for:

EXCLUDE_PATHS.stream()  
                               .map(String::toLowerCase)
                               .anyMatch(path::contains);

Điều này lặp lại qua các mục, áp dụng String::toLowerCasevà bộ lọc cho từng mục một và kết thúc ở mục đầu tiên phù hợp.

Cả hai collect()& anyMatch()đều là hoạt động đầu cuối. anyMatch()Tuy nhiên, thoát ở mục tìm thấy đầu tiên, trong khi collect()yêu cầu tất cả các mục phải được xử lý.

Quyết định có sử dụng Luồng hay không không nên dựa trên việc xem xét hiệu suất mà dựa trên khả năng đọc. Khi thực sự nói đến hiệu suất, có những cân nhắc khác.

Với .filter(path::contains).collect(Collectors.toList()).size() > 0cách tiếp cận của bạn , bạn đang xử lý tất cả các phần tử và thu thập chúng vào một tệp tạm thời List, trước khi so sánh kích thước, tuy nhiên, điều này hầu như không bao giờ quan trọng đối với một Luồng bao gồm hai phần tử.

Việc sử dụng .map(String::toLowerCase).anyMatch(path::contains)có thể tiết kiệm chu kỳ CPU và bộ nhớ, nếu bạn có số lượng phần tử lớn hơn đáng kể. Tuy nhiên, điều này sẽ chuyển đổi từng Stringthành phần biểu diễn chữ thường của nó, cho đến khi tìm thấy kết quả khớp. Rõ ràng, có một điểm trong việc sử dụng

private static final List<String> EXCLUDE_PATHS =
    Stream.of("my/path/one", "my/path/two").map(String::toLowerCase)
          .collect(Collectors.toList());

private boolean isExcluded(String path) {
    return EXCLUDE_PATHS.stream().anyMatch(path::contains);
}

thay thế. Vì vậy, bạn không phải lặp lại chuyển đổi thành chữ thường trong mỗi lần gọi isExcluded. Nếu số phần tử trong EXCLUDE_PATHShoặc độ dài của các chuỗi trở nên thực sự lớn, bạn có thể cân nhắc sử dụng

private static final List<Predicate<String>> EXCLUDE_PATHS =
    Stream.of("my/path/one", "my/path/two").map(String::toLowerCase)
          .map(s -> Pattern.compile(s, Pattern.LITERAL).asPredicate())
          .collect(Collectors.toList());

private boolean isExcluded(String path){
    return EXCLUDE_PATHS.stream().anyMatch(p -> p.test(path));
}

Biên dịch một chuỗi dưới dạng mẫu regex với LITERALcờ, làm cho nó hoạt động giống như các hoạt động chuỗi thông thường, nhưng cho phép công cụ dành một chút thời gian để chuẩn bị, ví dụ như sử dụng thuật toán Boyer Moore, để hiệu quả hơn khi so sánh thực tế.

Tất nhiên, điều này chỉ thành công nếu có đủ các bài kiểm tra tiếp theo để bù lại thời gian chuẩn bị. Việc xác định xem trường hợp này có xảy ra hay không, là một trong những cân nhắc về hiệu suất thực tế, bên cạnh câu hỏi đầu tiên liệu hoạt động này có bao giờ là quan trọng về hiệu suất hay không. Không phải là câu hỏi nên sử dụng Luồng hay forvòng lặp.

Nhân tiện, các ví dụ mã ở trên giữ nguyên logic của mã gốc của bạn, điều này có vẻ đáng ngờ đối với tôi. isExcludedPhương thức của bạn trả về true, nếu đường dẫn được chỉ định chứa bất kỳ phần tử nào trong danh sách, vì vậy nó trả về truefor /some/prefix/to/my/path/one, cũng như my/path/one/and/some/suffixhoặc thậm chí /some/prefix/to/my/path/one/and/some/suffix.

Even dummy/path/onerousđược coi là đáp ứng các tiêu chí vì nó containslà chuỗi my/path/one…

Vâng. Bạn đúng rồi. Cách tiếp cận luồng của bạn sẽ có một số chi phí. Nhưng bạn có thể sử dụng một cấu trúc như vậy:

private boolean isExcluded(String path) {
    return  EXCLUDE_PATHS.stream().map(String::toLowerCase).anyMatch(path::contains);
}

Lý do chính để sử dụng luồng là chúng làm cho mã của bạn đơn giản và dễ đọc hơn.

Mục tiêu của các luồng trong Java là đơn giản hóa sự phức tạp của việc viết mã song song. Nó lấy cảm hứng từ lập trình chức năng. Dòng nối tiếp chỉ để làm cho mã sạch hơn.

Nếu chúng ta muốn có hiệu suất, chúng ta nên sử dụngllelStream, được thiết kế để. Nói chung, một trong những nối tiếp chậm hơn.

Có một bài viết tốt để đọc về , và hiệu suất . ForLoopStreamParallelStream

Trong mã của bạn, chúng tôi có thể sử dụng các phương pháp kết thúc để dừng tìm kiếm ở trận đấu đầu tiên. (anyMatch ...)

Như những người khác đã đề cập nhiều điểm tốt, nhưng tôi chỉ muốn đề cập đến đánh giá lười biếng trong đánh giá luồng. Khi chúng tôi map()tạo một luồng các đường dẫn chữ thường, chúng tôi không tạo toàn bộ luồng ngay lập tức, thay vào đó luồng được xây dựng một cách lười biếng , đó là lý do tại sao hiệu suất phải tương đương với vòng lặp for truyền thống. Nó không thực hiện quét toàn bộ map()và anyMatch()được thực hiện cùng một lúc. Khi anyMatch()trả về true, nó sẽ bị đoản mạch.