Stream

V předchozím příspěvku jsem se věnoval streamům, které jako elementy obsahují primitivní datové typy. Jednalo se o následující streamy: IntSteam, DoubleStream, LongStream. Pomocí metody boxed() je možné stream primitivních datových typů převést na stream objektů odpovídajícího datového typu.

// Převod na stream objektů.
Stream<Integer> si = IntStream.range(1, 10).boxed();
Stream<Long> sl = LongStream.of(1_415, 402_112, 999).boxed();
Stream<Double> ds = DoubleStream.generate(() -> Math.random()).limit(5).boxed();

// Zobrazení elementů streamu.
si.forEach(System.out::println);
sl.forEach(System.out::println);
ds.forEach(System.out::println);

Java kromě Stream<Object> nabízí i streamy primitivních datových typu. Přesněji řečeno má takové streamy tři:

• IntStream
• DoubleStream
• LongStream

Vytvoření streamu primitivních datových typů
K vytvoření streamu primitivních datových typů je možné, tak jako pro stream objektů, použít metody generate() a iterate().

// IntStream obsahující deset sedmiček.
IntStream isg = IntStream.generate(() -> 7).limit(10);
// IntStream s elementy 0, 1, 2, 3, 4.
IntStream isi = IntStream.iterate(0, i -> i + 1).limit(5);

// Nekonečný DoubleStream, který obsahuje náhodná čísla.
DoubleStream dsg = DoubleStream.generate(() -> Math.random());
// DoubleStream s elementy 1.1, 2.2, 4.4, 8.8, 17.6.
DoubleStream dsi = DoubleStream.iterate(1.1, i -> i + i).limit(5);

// Nekonečný LongStream, který obsahuje čísla 9876543210.
LongStream lsg = LongStream.generate(() -> 9876543210L);
// LongStream obsahující čísla (řády) od 1 miliónu po 1 bilión.
LongStream lsi = LongStream.iterate(1_000_000, num -> num * 10).limit(9);

Dalším způsobem je použít statickou metodu of() a do ní uvést výčet hodnot.

IntStream intStream = IntStream.of(1, 3, 5, 7);
DoubleStream doubleStream = DoubleStream.of(0.52, 15.24, 7.879);
LongStream longStream = LongStream.of(14_854, 4_854);

Stream je možné vytvořit taktéž z pole pomocí statické metody java.util.Arrays.stream().

int[] intArray = { 1, 2, 3, 4};
double[] doubleArray = {12.548, 0.99, 103.1};
long[] longArray = {12, 778_755_441_784L, 1_221};

// IntSteam s elementy 1, 2, 3, 4.
IntStream isFromArray = Arrays.stream(intArray);
// DoubleStream s elementy 0.99 a 103.1.
DoubleStream dsFromArray = Arrays.stream(doubleArray, 1, 3);
// LongStream s elementem 1221.
LongStream lsFromArray = Arrays.stream(longArray, 2, 3);

IntStream a LongStream mají navíc k dispozici statické metody range() a rangeClosed().

// IntSteam s elementy 0, 1, 2, 3, 4.
IntStream isFromRange = IntStream.range(0, 5);
// LongStream s elementy 100, 101, 102, 103.
LongStream lsFromRange = LongStream.rangeClosed(100, 103);

Zdroj: HORSTMANN, Cay S. Java SE 8 for the really impatient. Upper Saddle River, NJ: Addison-Wesley, 2014, xv, 215 pages. ISBN 0321927761.

Java 8 představila Stream, což je posloupnost hodnot, nad kterou je možné provádět operace. Je možné vytvořit i nekonečný Stream.

Stream<String> stringStream = Stream.generate(() -> UUID.randomUUID().toString());
Stream<String> constantStream = Stream.generate(() -> "word");
Stream<Double> doubleStream = Stream.generate(Math::random);
Stream<Integer> integerStream = Stream.iterate(0, (i) -> i + 1);
Stream<BigDecimal> bigDecimalStream = Stream.iterate(BigDecimal.ZERO, (bd) -> bd.add(BigDecimal.ONE));

Metoda Stream.generate() požaduje parametr typu Supplier<T>, což je funkční rozhraní obsahující metodu T get(). Metoda Stream.iterate() požaduje parametr typu T seed (počáteční element) a UnaryOperator<T>, což je funkční rozhraní dědící z funkčního rozhraní Function (místo typů <R, T> používá <T, T>, metoda apply(T) tedy nevrací typ R ale T).

Pokud nám stačí jen několik prvků streamu, můžeme použít operaci limit(n), která vezme n prvních prvků streamu.

System.out.println(Arrays.toString(stringStream.limit(5).toArray()));
System.out.println(Arrays.toString(constantStream.limit(5).toArray()));
System.out.println(Arrays.toString(doubleStream.limit(5).toArray()));
System.out.println(Arrays.toString(integerStream.limit(5).toArray()));
System.out.println(Arrays.toString(bigDecimalStream.limit(5).toArray()));

Výstup:

[cb2f9562-e468-4409-bd61-cc7f153adbc9, 45582575-fda8-48a4-9ecd-bd8e9ca87f42, 6338c4d5-7b67-4fff-b1ec-6a86e2bacec8, 9ba3c6b0-700a-4e78-b633-e6a8da9fb946, 04951054-8c43-43a6-a177-aeb2da7c7320]
[word, word, word, word, word]
[0.9250003903085224, 0.912794982359122, 0.8636553602757563, 0.5809828517176208, 0.002178508953346925]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]

Pozor na datový typ (na přetečení rozsahu), který je použit v nekonečném proudu.

Stream<Integer> is = Stream.iterate(1, (i) -> i * 10).limit(15);
Stream<BigDecimal> bds = Stream.iterate(BigDecimal.ONE, (bd) -> bd.multiply(new BigDecimal("10"))).limit(15);

System.out.println(Arrays.toString(is.toArray()));
System.out.println(Arrays.toString(bds.toArray()));

Výstup:

[1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 1410065408, 1215752192, -727379968, 1316134912, 276447232]
[1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000]