Если к примеру многопоточной обработки дописать вывод результатов, мы увидим, что данные после обработки имеют случайный порядок:
|
1
2
3
4
5
6
7
8
9
10
|
public void printStreamMovies() {
data
.stream()
.map(YEAR_PATTERN::matcher)
.filter(Matcher::matches)
.collect(
Collectors.groupingBy(m -> m.group(1),
Collectors.counting()))
.forEach((k, v) -> System.out.println(k+":"+v));
}
|
|
1
2
3
4
5
6
7
|
2015:145911
2014:199088
2013:205410
1969:15484
1968:15087
1967:16257
1966:15461
|
Что, если нам нужен не просто список количества фильмов в каждом году, а ещё и отсортированный по годам? Можно, конечно, позвать Collections.sort() с какой-то своей реализацией Comparable. Но для Map нет вызова Collections.sort()! Можно использовать какую-нибудь реализацию SortedMap и отсортировать результаты вручную, но это требует лишнего кода и не менее лишнего копирования данных. Правильный ответ: можно использовать сортированные Streams:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
data
.stream()
.map(YEAR_PATTERN::matcher)
.filter(Matcher::matches)
.map(m -> m.group(1))
.map(Integer::parseInt)
.sorted()
.collect(
Collectors.groupingBy(i -> i,
LinkedHashMap::new,
Collectors.counting()))
.forEach((k, v) -> System.out.println(k + ":" + v));
|
|
1
2
3
4
5
6
7
8
9
10
|
2015:145911
2016:11984
2017:1967
2018:422
2019:100
2020:58
2021:22
2022:9
2024:2
2025:1
|
Метод sorted() сортирует поток, используя естественный порядок сравнения его элементов. Для IntStream, из примера выше, другой порядок сортировки задать нельзя. Для обычного потока существует второй метод sorted(), принимающий либо экземпляр Comparable, либо соответствующее ему лямбда-выражение.
Надо отметить, что sorted() является методом с состоянием. Все методы из предыдущих статей о Stream API не имели своего состояния, зависящего от предыдущих вызовов и могли быть вызваны независимо для каждого элемента потока. Метод с состоянием, такой как sorted(), может не иметь возможности вернуть результат до того момента, пока не обработает весь поток. Из этого следует, что такие методы не могут работать с бесконечными потоками. Так же из этого следует, что в ходе (параллельной) обработки могут быть созданы дополнительные копии данных или данные могут быть обработаны в несколько проходов.
Использование сортированных потоков особенно удобно с некоторыми терминальными операциями. Например, чтобы узнать год, в котором было снято наибольшее число фильмов, отсортируем результат по убыванию и возьмём первый элемент:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public Optional<Map.Entry<Integer, Long>> mostProductiveYear() {
Comparator<Map.Entry<Integer, Long>> byValue = (entry1, entry2) -> entry1.getValue().compareTo(
entry2.getValue());
return data
.stream()
.map(YEAR_PATTERN::matcher)
.filter(Matcher::matches)
.map(m -> m.group(1))
.map(Integer::parseInt)
.sorted()
.collect(
Collectors.groupingBy(i -> i,
LinkedHashMap::new,
Collectors.counting()))
.entrySet()
.stream()
.sorted(byValue.reversed())
.findFirst();
}
|
findFirst() возвращает первый элемент потока. Если быть точным, то findFirst() возвращает Optional, который может быть будет содержать первый элемент потока, если такой будет существовать. Использовать findFirst() в основном имеет смысл с сортированными потоками, так как в ином случае гарантировать порядок мы не можем. Для несортированных потоков выгоднее использовать findAny() , вовращающей любой элемент потока. Этот метод может быть более эффективным, так как не всегда первый элемент потока будет первым доступным, а для несортированных потоков разницы, по большому счёту, нет. Так же как findFirst(), findAny() возвращает на самом деле Optional, который может либо содержать данные, либо быть пустым, если поток так же пуст.
Ещё один метод, limit(), позволяет выбрать из потока первые несколько элементов:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public void topFiveYears() {
Comparator<Map.Entry<Integer, Long>> byValue = (entry1, entry2) -> entry1.getValue().compareTo(
entry2.getValue());
data
.stream()
.map(YEAR_PATTERN::matcher)
.filter(Matcher::matches)
.map(m -> m.group(1))
.map(Integer::parseInt)
.sorted()
.collect(
Collectors.groupingBy(i -> i,
LinkedHashMap::new,
Collectors.counting()))
.entrySet()
.stream()
.sorted(byValue.reversed())
.limit(5)
.forEach(e -> System.out.println(e.getKey()+":"+e.getValue()));
}
|
|
1
2
3
4
5
|
2013:205410
2014:199088
2012:197652
2011:182230
2010:158664
|
Метод skip() позволяет пропустить некоторое количество элементов перед дальнейшей обработкой. Вторая пятёрка годов по колиеству фильмов делается с его помощью очень просто:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public void nextFiveYears() {
Comparator<Map.Entry<Integer, Long>> byValue = (entry1, entry2) -> entry1.getValue().compareTo(
entry2.getValue());
data
.stream()
.map(YEAR_PATTERN::matcher)
.filter(Matcher::matches)
.map(m -> m.group(1))
.map(Integer::parseInt)
.sorted()
.collect(
Collectors.groupingBy(i -> i,
LinkedHashMap::new,
Collectors.counting()))
.entrySet()
.stream()
.sorted(byValue.reversed())
.skip(5)
.limit(5)
.forEach(e -> System.out.println(e.getKey()+":"+e.getValue()));
}
|
|
1
2
3
4
5
|
2015:145911
2009:143048
2008:134090
2007:127908
2006:114631
|
Три метода, findFirst(), findAny(), limit() имеют ещё одно свойство — они способны завершить бесконечный поток. Таким же свойством обладает и рассмотренный ранее метод anyMatch().
Код примера доступен на github. Для исполнения требуется скачать IMDB movies.list и положить его в src/resources.