Я проверял предстоящее Java update
, а именно: Java 8 or JDK 8
. Да, я нетерпелив, есть много нового, но есть кое-что, чего я не понимаю, простой код:
final Stream<Integer>stream = Stream.of(1,2,3,4,5,6,7,8,9,10);
stream.flatMap();
javadocs
public <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
Возвращает поток, состоящий из результатов замены каждого элемента этого потока содержимым сопоставленного потока, созданного путем применения предоставленной функции сопоставления к каждому элементу. Каждый отображаемый поток закрывается после того, как его содержимое было помещено в этот поток. (Если отображаемый поток имеет значение NULL, вместо этого используется пустой поток.) Это промежуточная операция.
Я был бы признателен, если бы кто-нибудь создал несколько простых примеров из реальной жизни о flatMap
том, как вы могли бы кодировать это в предыдущих версиях java Java[6,7]
и как вы можете кодировать те же подпрограммы, используя Java 8
.
источник
Ответы:
Это не имеет смысла
flatMap
в поток , который уже плоский, как иStream<Integer>
вы показали в своем вопросе.Однако, если бы у вас был,
Stream<List<Integer>>
тогда это имело бы смысл, и вы могли бы сделать это:Stream<List<Integer>> integerListStream = Stream.of( Arrays.asList(1, 2), Arrays.asList(3, 4), Arrays.asList(5) ); Stream<Integer> integerStream = integerListStream .flatMap(Collection::stream); integerStream.forEach(System.out::println);
Что напечатает:
1 2 3 4 5
Чтобы сделать это до Java 8, вам просто нужны циклы:
List<List<Integer>> integerLists = Arrays.asList( Arrays.asList(1, 2), Arrays.asList(3, 4), Arrays.asList(5) ) List<Integer> flattened = new ArrayList<>(); for (List<Integer> integerList : integerLists) { flattened.addAll(integerList); } for (Integer i : flattened) { System.out.println(i); }
источник
Выдуманный пример
Представьте, что вы хотите создать следующую последовательность: 1, 2, 2, 3, 3, 3, 4, 4, 4, 4 и т. Д. (Другими словами: 1x1, 2x2, 3x3 и т. Д.)
С
flatMap
его помощью это могло выглядеть так:IntStream sequence = IntStream.rangeClosed(1, 4) .flatMap(i -> IntStream.iterate(i, identity()).limit(i)); sequence.forEach(System.out::println);
где:
IntStream.rangeClosed(1, 4)
создает потокint
от 1 до 4 включительноIntStream.iterate(i, identity()).limit(i)
создает поток длиной i ofint
i, поэтому применительно кi = 4
нему создает поток:4, 4, 4, 4
flatMap
"сглаживает" поток и "объединяет" его с исходным потокомС Java <8 вам понадобятся два вложенных цикла:
List<Integer> list = new ArrayList<>(); for (int i = 1; i <= 4; i++) { for (int j = 0; j < i; j++) { list.add(i); } }
Пример из реального мира
Скажем, у меня есть,
List<TimeSeries>
где каждыйTimeSeries
по сути является файломMap<LocalDate, Double>
. Я хочу получить список всех дат, для которых хотя бы один временной ряд имеет значение.flatMap
на помощь:list.stream().parallel() .flatMap(ts -> ts.dates().stream()) // for each TS, stream dates and flatmap .distinct() // remove duplicates .sorted() // sort ascending .collect(toList());
Он не только читабелен, но и если вам вдруг понадобится обработать 100 тыс. Элементов, простое добавление
parallel()
улучшит производительность без написания какого-либо параллельного кода.источник
Function.identity
.import static java.util.function.Function.identity;
Извлеките уникальные слова, отсортированные по ASC, из списка фраз:
List<String> phrases = Arrays.asList( "sporadic perjury", "confounded skimming", "incumbent jailer", "confounded jailer"); List<String> uniqueWords = phrases .stream() .flatMap(phrase -> Stream.of(phrase.split("\\s+"))) .distinct() .sorted() .collect(Collectors.toList()); System.out.println("Unique words: " + uniqueWords);
... и вывод:
источник
Неужели я единственный, кому скучно раскручивать списки? ;-)
Попробуем с предметами. Между прочим, пример из реального мира.
Дано: объект, представляющий повторяющуюся задачу. О важных полях задач: напоминания начинают звонить
start
и повторяться каждыеrepeatPeriod
repeatUnit
(например, 5 ЧАСОВ), и будутrepeatCount
напоминания всего (включая начальное).Цель: составить список копий задач, по одной для каждого вызова напоминания о задаче.
List<Task> tasks = Arrays.asList( new Task( false,//completed sign "My important task",//task name (text) LocalDateTime.now().plus(2, ChronoUnit.DAYS),//first reminder(start) true,//is task repetitive? 1,//reminder interval ChronoUnit.DAYS,//interval unit 5//total number of reminders ) ); tasks.stream().flatMap( x -> LongStream.iterate( x.getStart().toEpochSecond(ZoneOffset.UTC), p -> (p + x.getRepeatPeriod()*x.getRepeatUnit().getDuration().getSeconds()) ).limit(x.getRepeatCount()).boxed() .map( y -> new Task(x,LocalDateTime.ofEpochSecond(y,0,ZoneOffset.UTC))) ).forEach(System.out::println);
Выход:
Task{completed=false, text='My important task', start=2014-10-01T21:35:24, repeat=false, repeatCount=0, repeatPeriod=0, repeatUnit=null} Task{completed=false, text='My important task', start=2014-10-02T21:35:24, repeat=false, repeatCount=0, repeatPeriod=0, repeatUnit=null} Task{completed=false, text='My important task', start=2014-10-03T21:35:24, repeat=false, repeatCount=0, repeatPeriod=0, repeatUnit=null} Task{completed=false, text='My important task', start=2014-10-04T21:35:24, repeat=false, repeatCount=0, repeatPeriod=0, repeatUnit=null} Task{completed=false, text='My important task', start=2014-10-05T21:35:24, repeat=false, repeatCount=0, repeatPeriod=0, repeatUnit=null}
PS: Буду признателен, если кто-нибудь предложит более простое решение, в конце концов, я не профессионал.
ОБНОВЛЕНИЕ: @RBz попросил подробное объяснение, вот оно. По сути, flatMap помещает все элементы из потоков внутри другого потока в выходной поток. Здесь много стримов :). Итак, для каждой задачи в лямбда-выражении исходного потока
x -> LongStream.iterate...
создается поток длинных значений, представляющих моменты начала задачи. Этот поток ограниченx.getRepeatCount()
экземплярами. Его значения начинаются с,x.getStart().toEpochSecond(ZoneOffset.UTC)
и каждое следующее значение рассчитывается с использованием лямбдаp -> (p + x.getRepeatPeriod()*x.getRepeatUnit().getDuration().getSeconds()
.boxed()
возвращает поток с каждым длинным значением как экземпляр оболочки Long. Затем каждый Long в этом потоке сопоставляется с новым экземпляром Task, который больше не повторяется и содержит точное время выполнения. Этот пример содержит только одну задачу во входном списке. Но представьте, что у вас есть тысяча. У вас будет поток из 1000 потоков объектов Task. И чтоflatMap
здесь помещает все Задачи из всех потоков в один и тот же выходной поток. Вот и все, как я понимаю. Спасибо Вам за Ваш вопрос!источник
Am I the only one who finds unwinding lists boring?
+1Этот метод принимает одну функцию в качестве аргумента, эта функция принимает один параметр T в качестве входного аргумента и возвращает один поток параметра R в качестве возвращаемого значения. Когда эта функция применяется к каждому элементу этого потока, она создает поток новых значений. Все элементы этих новых потоков, сгенерированные каждым элементом, затем копируются в новый поток, который будет возвращаемым значением этого метода.
http://codedestine.com/java-8-stream-flatmap-method/
источник
Очень простой пример: разделите список полных имен, чтобы получить список имен, независимо от имени или фамилии.
List<String> fullNames = Arrays.asList("Barry Allen", "Bruce Wayne", "Clark Kent"); fullNames.stream() .flatMap(fullName -> Pattern.compile(" ").splitAsStream(fullName)) .forEach(System.out::println);
Это распечатывает:
источник
Учитывая это:
public class SalesTerritory { private String territoryName; private Set<String> geographicExtents; public SalesTerritory( String territoryName, Set<String> zipCodes ) { this.territoryName = territoryName; this.geographicExtents = zipCodes; } public String getTerritoryName() { return territoryName; } public void setTerritoryName( String territoryName ) { this.territoryName = territoryName; } public Set<String> getGeographicExtents() { return geographicExtents != null ? Collections.unmodifiableSet( geographicExtents ) : Collections.emptySet(); } public void setGeographicExtents( Set<String> geographicExtents ) { this.geographicExtents = new HashSet<>( geographicExtents ); } @Override public int hashCode() { int hash = 7; hash = 53 * hash + Objects.hashCode( this.territoryName ); return hash; } @Override public boolean equals( Object obj ) { if ( this == obj ) { return true; } if ( obj == null ) { return false; } if ( getClass() != obj.getClass() ) { return false; } final SalesTerritory other = (SalesTerritory) obj; if ( !Objects.equals( this.territoryName, other.territoryName ) ) { return false; } return true; } @Override public String toString() { return "SalesTerritory{" + "territoryName=" + territoryName + ", geographicExtents=" + geographicExtents + '}'; } }
и это:
public class SalesTerritories { private static final Set<SalesTerritory> territories = new HashSet<>( Arrays.asList( new SalesTerritory[]{ new SalesTerritory( "North-East, USA", new HashSet<>( Arrays.asList( new String[]{ "Maine", "New Hampshire", "Vermont", "Rhode Island", "Massachusetts", "Connecticut", "New York", "New Jersey", "Delaware", "Maryland", "Eastern Pennsylvania", "District of Columbia" } ) ) ), new SalesTerritory( "Appalachia, USA", new HashSet<>( Arrays.asList( new String[]{ "West-Virgina", "Kentucky", "Western Pennsylvania" } ) ) ), new SalesTerritory( "South-East, USA", new HashSet<>( Arrays.asList( new String[]{ "Virginia", "North Carolina", "South Carolina", "Georgia", "Florida", "Alabama", "Tennessee", "Mississippi", "Arkansas", "Louisiana" } ) ) ), new SalesTerritory( "Mid-West, USA", new HashSet<>( Arrays.asList( new String[]{ "Ohio", "Michigan", "Wisconsin", "Minnesota", "Iowa", "Missouri", "Illinois", "Indiana" } ) ) ), new SalesTerritory( "Great Plains, USA", new HashSet<>( Arrays.asList( new String[]{ "Oklahoma", "Kansas", "Nebraska", "South Dakota", "North Dakota", "Eastern Montana", "Wyoming", "Colorada" } ) ) ), new SalesTerritory( "Rocky Mountain, USA", new HashSet<>( Arrays.asList( new String[]{ "Western Montana", "Idaho", "Utah", "Nevada" } ) ) ), new SalesTerritory( "South-West, USA", new HashSet<>( Arrays.asList( new String[]{ "Arizona", "New Mexico", "Texas" } ) ) ), new SalesTerritory( "Pacific North-West, USA", new HashSet<>( Arrays.asList( new String[]{ "Washington", "Oregon", "Alaska" } ) ) ), new SalesTerritory( "Pacific South-West, USA", new HashSet<>( Arrays.asList( new String[]{ "California", "Hawaii" } ) ) ) } ) ); public static Set<SalesTerritory> getAllTerritories() { return Collections.unmodifiableSet( territories ); } private SalesTerritories() { } }
Затем мы можем сделать это:
System.out.println(); System.out .println( "We can use 'flatMap' in combination with the 'AbstractMap.SimpleEntry' class to flatten a hierarchical data-structure to a set of Key/Value pairs..." ); SalesTerritories.getAllTerritories() .stream() .flatMap( t -> t.getGeographicExtents() .stream() .map( ge -> new SimpleEntry<>( t.getTerritoryName(), ge ) ) ) .map( e -> String.format( "%-30s : %s", e.getKey(), e.getValue() ) ) .forEach( System.out::println );
источник