⌨️ Метод forEachOrdered интерфейса Stream

Метод forEachOrdered в интерфейсе Stream используется для обработки каждого элемента потока с сохранением порядка обработки, даже если поток является параллельным.

В отличие от метода forEach(), который не гарантирует порядок выполнения в параллельных потоках, метод forEachOrdered() всегда сохраняет порядок элементов, как если бы поток был последовательным.

Этот метод полезен, если вам нужно выполнить действия для каждого элемента в параллельном потоке, но при этом важен порядок обработки (например, вывод или запись данных в определенной последовательности).

Параллельный поток с forEach:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.parallelStream().forEach(n -> System.out.println(n));
// Порядок не определён, например 3 1 4 2 5

Параллельный поток с forEachOrdered:

numbers.parallelStream()
     .forEachOrdered(n -> System.out.println(n));
// 1 2 3 4 5

#java #Stream #forEachOrdered

⌨️ Stream.reduce() vs Collectors.joining()

Когда требуется конкатенировать строки с использованием Stream, можно выбрать один из двух методов: Stream.reduce() или Stream.collect(Collectors.joining()).

Пример с Stream.reduce():

List<String> list = List.of("Str1", "Str2", "Str3");
String result = list.stream().reduce("", (a, b) -> a + b);
System.out.println(result); // Str1Str2Str3

Пример с Collectors.joining():

List<String> list = List.of("Str1", "Str2", "Str3");
String result = list.stream().collect(Collectors.joining());
System.out.println(result); // Str1Str2Str3

Использование reduce() для конкатенации строк не является оптимальным с точки зрения производительности. При каждом вызове операции +, создается новая строка, так как строки в Java неизменяемы. Это приводит к увеличению нагрузки на память из-за создания множества промежуточных объектов.

В свою очередь, метод Collectors.joining() использует StringBuilder для сборки строк, что значительно эффективнее. Он избегает создания лишних объектов и снижает потребление памяти.

#java #Stream #reduce #joining

⌨️ Вычислить максимальное значение в одну строку

В этом нам помогут наши любимые стримы.

Так:

List<Integer> iList = List.of(1,2,3,4,5);
Integer max = iList.stream().reduce(Integer::max).orElse(null);
System.out.println(max);

А еще лучше вот так:

List<Integer> iList = List.of(1,2,3,4,5);
iList.stream().reduce(Integer::max).ifPresent(System.out::println);

#java #Stream #max

⌨️ Срезы в стримах. Метод takeWhile

В Java 9 появилось два новых метода, полезных для выбора элементов потока с хорошей производительностью: takeWhile и dropWhile.

Допустим, у нас есть следующий список блюд:

List<Dish> specialMenu = Arrays.asList(
new Dish("seasonal fruit", 120),
new Dish("prawns", 300),
new Dish("rice", 350),
new Dish("chicken", 400),
new Dish("french fries", 530));

Для получения блюд с калорийностью меньше 320, можно воспользоваться операцией filter. Недостаток операции filter в том, что она требует прохода в цикле по всему потоку данных с применением предиката ко всем элементам.

В нашем примере список уже отсортирован по числу калорий. Вместо того, чтобы пройтись по каждому элементу, можно прекратить работу сразу же после обнаружения блюда, содержащего 320 калорий или более. В случае небольшого списка это может показаться не таким уж громадным преимуществом, но при работе с потенциально большим потоком элементов окажется весьма полезным.

Поможет нам в этом операция takeWhile! Она позволяет выполнить срез любого потока данных (даже бесконечного) с помощью предиката. И, к счастью, она прекращает работу сразу же по обнаружении неподходящего элемента. Вот как ее следует использовать:

List<Dish> sliceMenu1 
    = specialMenu.stream()
                 .takeWhile(dish -> dish.getCalories() < 320)
                 .collect(toList());

#java #stream #takeWhile

⌨️ Stream.reduce() vs Collectors.joining()

Когда требуется конкатенировать строки с использованием Stream, можно выбрать один из двух методов: Stream.reduce() или Stream.collect(Collectors.joining()).

Пример с Stream.reduce():

List<String> list = List.of("Str1", "Str2", "Str3");
String result = list.stream().reduce("", (a, b) -> a + b);
System.out.println(result); // Str1Str2Str3

Пример с Collectors.joining():

List<String> list = List.of("Str1", "Str2", "Str3");
String result = list.stream().collect(Collectors.joining());
System.out.println(result); // Str1Str2Str3

Использование reduce() для конкатенации строк не является оптимальным с точки зрения производительности. При каждом вызове операции +, создается новая строка, так как строки в Java неизменяемы. Это приводит к увеличению нагрузки на память из-за создания множества промежуточных объектов.

В свою очередь, метод Collectors.joining() использует StringBuilder для сборки строк, что значительно эффективнее. Он избегает создания лишних объектов и снижает потребление памяти.

#java #Stream #reduce #joining

⌨️ Полезные стримы. Группировка

Дан список людей с именем и городом проживания. Нужно сгруппировать их по городам.

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

record Person(String name, String city) {}

public class StreamExample {
    public static void main(String[] args) {
        List<Person> people = List.of(
    new Person("Alice", "New York"),
    new Person("Bob", "Los Angeles"),
    new Person("Charlie", "New York"),
    new Person("David", "Los Angeles"),
    new Person("Edward", "San Francisco")
        );

        Map<String, List<Person>> peopleByCity = people.stream()
                .collect(Collectors.groupingBy(Person::city));

        peopleByCity.forEach((city, peopleInCity) -> {
            System.out.println(city + ": " + peopleInCity.stream()
                    .map(Person::name)
                    .collect(Collectors.joining(", ")));
        });
        // Вывод:
        // San Francisco: Edward
        // New York: Alice, Charlie
        // Los Angeles: Bob, David
    }
}

#java #stream #grouping