Java : Stream(ストリーム) - API使用例

final var list = List.of("y", "z", "b", "x", "a", "c");
System.out.println(list); // [y, z, b, x, a, c]

// 大文字に変換してからソートします。
final var ret = list.stream()
        .map(String::toUpperCase)
        .sorted()
        .toList();

System.out.println(ret); // [A, B, C, X, Y, Z]

boolean allMatch (Predicate<? super T> predicate)

このストリームのすべての要素が指定された述語に一致するかどうかを返します。

final var predicate = new Predicate<Character>() {
    @Override
    public boolean test(Character c) {
        // 小文字かどうか判定します。
        return Character.isLowerCase(c);
    }
};

{
    final var stream = Stream.of('a', 'b', 'c', 'd');

    final var ret = stream.allMatch(predicate);
    System.out.println(ret); // true
}
{
    final var stream = Stream.of('a', 'B', 'c', 'D');

    final var ret = stream.allMatch(predicate);
    System.out.println(ret); // false
}

{
    final var stream = Stream.of("aaa", "bbb", "ccc");

    final var ret = stream.allMatch(s -> {
        // 小文字のみが含まれているかどうかチェック。
        return s.matches("[a-z]*");
    });
    System.out.println(ret); // true
}

{
    final var stream = Stream.of("aaa", "bbB", "cCC");

    final var ret = stream.allMatch(s -> s.matches("[a-z]*"));
    System.out.println(ret); // false
}

boolean anyMatch (Predicate<? super T> predicate)

このストリームのいずれかの要素が指定された述語に一致するかどうかを返します。

final var predicate = new Predicate<Character>() {
    @Override
    public boolean test(Character c) {
        // 小文字かどうか判定します。
        return Character.isLowerCase(c);
    }
};

{
    final var stream = Stream.of('a', 'b', 'c');

    final var ret = stream.anyMatch(predicate);
    System.out.println(ret); // true
}
{
    final var stream = Stream.of('A', 'b', 'c');

    final var ret = stream.anyMatch(predicate);
    System.out.println(ret); // true
}
{
    final var stream = Stream.of('A', 'B', 'C');

    final var ret = stream.anyMatch(predicate);
    System.out.println(ret); // false
}

{
    final var stream = Stream.of("aaa", "bbB", "CCC");

    final var ret = stream.anyMatch(s -> {
        // 小文字のみが含まれているかどうかチェック。
        return s.matches("[a-z]*");
    });
    System.out.println(ret); // true
}
{
    final var stream = Stream.of("aaA", "bBB", "CCC");

    final var ret = stream.anyMatch(s -> s.matches("[a-z]*"));
    System.out.println(ret); // false
}

static <T> Stream.Builder<T> builder ()

Streamのビルダーを返します。

final var builder = Stream.<String>builder();
builder.add("aaa").add("bbb").add("ccc");

final var stream = builder.build();

System.out.println(stream.toList()); // [aaa, bbb, ccc]

<R> R collect (Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)

このストリームの要素に対して可変リダクション操作を実行します。

final var supplier = new Supplier<List<String>>() {
    @Override
    public List<String> get() {
        return new ArrayList<>();
    }
};

final var accumulator = new BiConsumer<List<String>, String>() {
    @Override
    public void accept(List<String> list, String s) {
        list.add(s);
    }
};

final var combiner = new BiConsumer<List<String>, List<String>>() {
    @Override
    public void accept(List<String> list1, List<String> list2) {
        list1.addAll(list2);
    }
};

{
    final var stream = Stream.of("aaa", "bbb", "ccc");

    final var ret = stream.collect(supplier, accumulator, combiner);
    System.out.println(ret); // [aaa, bbb, ccc]
}
{
    // combinerは並列ストリームで使われます。
    final var parallelStream = Stream.of("aaa", "bbb", "ccc").parallel();
    System.out.println(parallelStream.isParallel()); // true

    final var ret = parallelStream.collect(supplier, accumulator, combiner);
    System.out.println(ret); // [aaa, bbb, ccc]
}

<R, A> R collect (Collector<? super T,A,R> collector)

Collectorを使ってこのストリームの要素に対する可変リダクション操作を実行します。

final var stream = Stream.of("aaa", "bbb", "ccc");

final List<String> list = stream.collect(Collectors.toList());
System.out.println(list); // [aaa, bbb, ccc]

final var stream = Stream.of("aaa", "bbb", "ccc");

final Set<String> set = stream.collect(Collectors.toSet());
System.out.println(set); // [aaa, ccc, bbb]

final var stream = Stream.of("a", "b", "c");

final Map<String, String> map = stream.collect(Collectors.toMap(
        s -> s + "-key",
        s -> s + "-value"
));
System.out.println(map); // {c-key=c-value, a-key=a-value, b-key=b-value}

final var stream = Stream.of("a", "b", "c");

final String str = stream.collect(Collectors.joining(" : "));
System.out.println(str); // "a : b : c"

static <T> Stream<T> concat (Stream<? extends T> a, Stream<? extends T> b)

最初のストリームの全要素と2番目のストリームの全要素を連結したものを要素に持つ、遅延連結ストリームを作成します。

final var stream1 = Stream.of("aaa", "bbb", "ccc");
final var stream2 = Stream.of("XX", "YY", "ZZ");

System.out.println(stream1.isParallel()); // false
System.out.println(stream2.isParallel()); // false

final var concatStream = Stream.concat(stream1, stream2);
System.out.println(concatStream.isParallel()); // false
System.out.println(concatStream.toList()); // [aaa, bbb, ccc, XX, YY, ZZ]

final var stream1 = Stream.of("aaa", "bbb", "ccc").parallel();
final var stream2 = Stream.of("XX", "YY", "ZZ").parallel();

System.out.println(stream1.isParallel()); // true
System.out.println(stream2.isParallel()); // true

final var concatStream = Stream.concat(stream1, stream2);
System.out.println(concatStream.isParallel()); // true
System.out.println(concatStream.toList()); // [aaa, bbb, ccc, XX, YY, ZZ]

long count ()

このストリームの要素の個数を返します。

final var stream = Stream.of("a", "b", "c", "d");
System.out.println(stream.count()); // 4

final var stream = Stream.empty();
System.out.println(stream.count()); // 0

Stream<T> distinct ()

このストリームの重複を除いた要素(Object.equals(Object)による)から構成されるストリームを返します。

final var stream = Stream.of("aaa", "bbb", "ccc", "bbb", "ccc");

final var ret = stream.distinct().toList();
System.out.println(ret); // [aaa, bbb, ccc]

final var stream = Stream.of(1, 2, 2, 3, 3, 3);

final var ret = stream.distinct().toList();
System.out.println(ret); // [1, 2, 3]

default Stream<T> dropWhile (Predicate<? super T> predicate)

このストリームが順序付けされている場合は、指定された述語に一致する要素の最長プレフィクスを削除した後に、このストリームの残りの要素で構成されるストリームを返します。

関連メソッド : takeWhile

final var stream = Stream.of("aa", "bb", "cc", "dd", "ee", "ff");

final var predicate = new Predicate<String>() {
    @Override
    public boolean test(String s) {
        return !s.equals("dd");
    }
};

final var ret = stream.dropWhile(predicate).toList();
System.out.println(ret); // [dd, ee, ff]

final var stream = Stream.of(1, 2, 3, 4, 5);

final var ret = stream.dropWhile(i -> i != 3).toList();
System.out.println(ret); // [3, 4, 5]

static <T> Stream<T> empty ()

空の順次Streamを返します。

final var stream = Stream.empty();
System.out.println(stream.count()); // 0

final var stream = Stream.empty();
final var list = stream.toList();
System.out.println(list); // []

Stream<T> filter (Predicate<? super T> predicate)

このストリームの要素のうち、指定された述語に一致するものから構成されるストリームを返します。

final var stream = Stream.of('a', 'b', 'C', 'D', 'e');

// 小文字であるかチェック。
final var predicate = new Predicate<Character>() {
    @Override
    public boolean test(Character c) {
        return Character.isLowerCase(c);
    }
};

final var ret = stream.filter(predicate).toList();
System.out.println(ret); // [a, b, e]

final var stream = Stream.of('a', 'b', 'C', 'D', 'e');

final var ret = stream.filter(Character::isUpperCase).toList();
System.out.println(ret); // [C, D]

Optional<T> findAny ()

ストリームの一部の要素を記述するOptionalを返します。ストリームが空の場合は空のOptionalを返します。

int aaa = 0;
int bbb = 0;
int ccc = 0;

for (int i = 0; i < 1000; i++) {

    final var stream = Stream.of("aaa", "bbb", "ccc").parallel();
    System.out.println(stream.isParallel()); // true

    // "aaa" or "bbb" or "ccc"
    final var ret = stream.findAny();

    switch (ret.orElseThrow()) {
        case "aaa" -> aaa++;
        case "bbb" -> bbb++;
        case "ccc" -> ccc++;
    }
}

System.out.println("aaa count : " + aaa);
System.out.println("bbb count : " + bbb);
System.out.println("ccc count : " + ccc);

// 結果
// ↓
//aaa count : 131
//bbb count : 866
//ccc count : 3

final var stream = Stream.empty();

final var ret = stream.findAny();
System.out.println(ret.isEmpty()); // true

Optional<T> findFirst ()

このストリームの最初の要素を記述するOptionalを返します。ストリームが空の場合は空のOptionalを返します。

final var stream = Stream.of("aaa", "bbb", "ccc");

final var ret = stream.findFirst();
System.out.println(ret.orElseThrow()); // "aaa"

// findAny と違い、parallelでも最初の要素を返します。
final var stream = Stream.of("aaa", "bbb", "ccc").parallel();
System.out.println(stream.isParallel()); // true

final var ret = stream.findFirst();
System.out.println(ret.orElseThrow()); // "aaa"

int aaa = 0;
int bbb = 0;
int ccc = 0;

for (int i = 0; i < 1000; i++) {

    // ただし、unordered かつ parallel の場合は、どの値が返されるかは決まりません。
    final var stream = Stream.of("aaa", "bbb", "ccc").unordered().parallel();
    System.out.println(stream.isParallel()); // true

    // "aaa" or "bbb" or "ccc"
    final var ret = stream.findFirst();
    switch (ret.orElseThrow()) {
        case "aaa" -> aaa++;
        case "bbb" -> bbb++;
        case "ccc" -> ccc++;
    }
}

System.out.println("aaa count : " + aaa);
System.out.println("bbb count : " + bbb);
System.out.println("ccc count : " + ccc);

// 結果
// ↓
//aaa count : 209
//bbb count : 788
//ccc count : 3

final var stream = Stream.empty();

final var ret = stream.findFirst();
System.out.println(ret.isEmpty()); // true

<R> Stream<R> flatMap (Function<? super T,? extends Stream<? extends R>> mapper)

このストリームの各要素をマップされたストリーム(指定されたマッピング関数を各要素に適用することで得られる)の内容で置き換えた結果から成るストリームを返します。

1つの要素を、複数の要素からなるストリームへと変換します。

final var stream = Stream.of("aaa", "bbb", "ccc");

final var mapper = new Function<String, Stream<String>>() {
    @Override
    public Stream<String> apply(String s) {
        return Stream.of("--", s.toUpperCase(), "++");
    }
};

final var ret = stream.flatMap(mapper).toList();
System.out.println(ret); // [--, AAA, ++, --, BBB, ++, --, CCC, ++]

DoubleStream flatMapToDouble (Function<? super T,? extends DoubleStream> mapper)

このストリームの各要素を、その要素に指定されたマッピング関数を適用することによって生成されるマップ先ストリームの内容で置き換えた結果から構成されるDoubleStreamを返します。

final var stream = Stream.of(100, 125, 150);

// Integerの値と、2で割ったdoubleへ変換。
final var mapper = new Function<Integer, DoubleStream>() {
    @Override
    public DoubleStream apply(Integer i) {
        return DoubleStream.of(i, i / 2.0);
    }
};

final var ret = stream.flatMapToDouble(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [100.0, 50.0, 125.0, 62.5, 150.0, 75.0]

IntStream flatMapToInt (Function<? super T,? extends IntStream> mapper)

このストリームの各要素をマップされたストリーム(指定されたマッピング関数を各要素に適用することで得られる)の内容で置き換えた結果から成るIntStreamを返します。

final var stream = Stream.of("0x01", "0x02", "0xff");

// 16進数表記の文字列をintに変換して、その値と100倍の値のストリームへ変換。
final var mapper = new Function<String, IntStream>() {
    @Override
    public IntStream apply(String s) {
        final var i = Integer.decode(s);
        return IntStream.of(i, i * 100);
    }
};

final var ret = stream.flatMapToInt(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [1, 100, 2, 200, 255, 25500]

LongStream flatMapToLong (Function<? super T,? extends LongStream> mapper)

このストリームの各要素をマップされたストリーム(指定されたマッピング関数を各要素に適用することで得られる)の内容で置き換えた結果から成るLongStreamを返します。

final var stream = Stream.of("0x01", "0x02", "0xff");

// 16進数表記の文字列をlongに変換して、その値と10000000000倍の値のストリームへ変換。
final var mapper = new Function<String, LongStream>() {
    @Override
    public LongStream apply(String s) {
        final var l = Long.decode(s);
        return LongStream.of(l, l * 10000000000L);
    }
};

final var ret = stream.flatMapToLong(mapper).toArray();

// [1, 10000000000, 2, 20000000000, 255, 2550000000000]
System.out.println(Arrays.toString(ret));

void forEach (Consumer<? super T> action)

このストリームの各要素に対してアクションを実行します。

関連メソッド : peek

final var stream = Stream.of("aaa", "bbb", "ccc");

final var action = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};

// "aaa"
// "bbb"
// "ccc"
stream.forEach(action);

// ラムダ式を使う例
final var stream = Stream.of("aaa", "bbb", "ccc");

stream.forEach(s -> {
    // "aaa"
    // "bbb"
    // "ccc"
    System.out.println(s);
});

// メソッド参照を使う例
final var stream = Stream.of("aaa", "bbb", "ccc");

// "aaa"
// "bbb"
// "ccc"
stream.forEach(System.out::println);

final var stream = Stream.of("aaa", "bbb", "ccc").parallel();
System.out.println(stream.isParallel()); // true

// 並列ストリームは呼び出し順は保証されません。

// "bbb"
// "ccc"
// "aaa"
stream.forEach(System.out::println);

void forEachOrdered (Consumer<? super T> action)

このストリームの各要素に対してアクションを実行します。その実行順は、ストリームの検出順が定義されている場合はその順番になります。

final var stream = Stream.of("aaa", "bbb", "ccc");

final var action = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};

// "aaa"
// "bbb"
// "ccc"
stream.forEachOrdered(action);

final var stream = Stream.of("aaa", "bbb", "ccc").parallel();
System.out.println(stream.isParallel()); // true

// 並列ストリームでも呼び出し順が保証されます。

// "aaa"
// "bbb"
// "ccc"
stream.forEachOrdered(System.out::println);

static <T> Stream<T> generate (Supplier<? extends T> s)

指定されたSupplierによって生成される要素を含む、順序付けされていない無限順次ストリームを返します。

final var supplier = new Supplier<Integer>() {
    int count = 0;

    @Override
    public Integer get() {
        count++;
        return count;
    }
};

final var stream = Stream.generate(supplier);

// limitをつけないと無限に続くのでご注意ください。
final var ret = stream.limit(10).toList();
System.out.println(ret); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

static <T> Stream<T> iterate (T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)

指定されたnext関数を初期要素に反復適用することによって生成され、与えられたhasNext述語を満たすことを条件とする、順次順序付けされたStreamを返します。

final var hasNext = new Predicate<Integer>() {
    @Override
    public boolean test(Integer i) {
        return i <= 100;
    }
};

final var next = new UnaryOperator<Integer>() {
    @Override
    public Integer apply(Integer i) {
        return i * 2;
    }
};

final var stream = Stream.iterate(1, hasNext, next);

final var ret = stream.toList();
System.out.println(ret); // [1, 2, 4, 8, 16, 32, 64]

static <T> Stream<T> iterate (T seed, UnaryOperator<T> f)

初期要素seedに関数fを繰り返し適用することで生成される、順序付けされた無限順次Streamを返します(seed、f(seed)、f(f(seed))、といった要素から成るStreamが生成される)。

final var next = new UnaryOperator<Integer>() {
    @Override
    public Integer apply(Integer i) {
        return i * 2;
    }
};

final var stream = Stream.iterate(1, next);

// limitをつけないと無限に続くのでご注意ください。
final var ret = stream.limit(10).toList();
System.out.println(ret); // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

Stream<T> limit (long maxSize)

このストリームの要素をmaxSize以内の長さに切り詰めた結果から成るストリームを返します。

final var stream = Stream.of("a", "b", "c", "d", "e", "f", "g");

final var ret = stream.limit(3).toList();
System.out.println(ret); // [a, b, c]

<R> Stream<R> map (Function<? super T,? extends R> mapper)

このストリームの要素に指定された関数を適用した結果から構成されるストリームを返します。

final var stream = Stream.of("aaa", "bbb", "ccc");

final var mapper = new Function<String, String>() {
    @Override
    public String apply(String s) {
        return s.toUpperCase();
    }
};

final var ret = stream.map(mapper).toList();
System.out.println(ret); // [AAA, BBB, CCC]

final var stream = Stream.of("AAA", "BBB", "CCC");

final var ret = stream.map(String::toLowerCase).toList();
System.out.println(ret); // [aaa, bbb, ccc]

final var stream = Stream.of("0x01", "0x0a", "0xff");

// 別の型への変換。
final var ret = stream.map(s -> Integer.decode(s) * 10).toList();
System.out.println(ret); // [10, 100, 2550]

default <R> Stream<R> mapMulti (BiConsumer<? super T,? super Consumer<R>> mapper)

このストリームの各要素を複数の要素(特にゼロ個以上の要素)で置き換えた結果で構成されるストリームを返します。

final var stream = Stream.<Number>of(
        111, 222, // Integer
        0.333, 0.444, // Double
        5555555555L, 9999999999L // Long
);

final var ret = stream.mapMulti((number, consumer) -> {
    if (number instanceof Integer i) {
        consumer.accept(i);
    }
}).toList();

System.out.println(ret); // [111, 222]

default DoubleStream mapMultiToDouble (BiConsumer<? super T,? super DoubleConsumer> mapper)

このストリームの各要素を複数の要素(特にゼロ個以上の要素)で置き換えた結果で構成されるDoubleStreamを返します。

final var stream = Stream.<Number>of(
        111, 222, // Integer
        0.333, 0.444, // Double
        5555555555L, 9999999999L // Long
);

final var ret = stream.mapMultiToDouble((number, consumer) -> {
    if (number instanceof Double d) {
        consumer.accept(d);
    }
}).toArray();

System.out.println(Arrays.toString(ret)); // [0.333, 0.444]

default IntStream mapMultiToInt (BiConsumer<? super T,? super IntConsumer> mapper)

このストリームの各要素を複数の要素(特にゼロ個以上の要素)で置き換えた結果で構成されるIntStreamを返します。

final var stream = Stream.<Number>of(
        111, 222, // Integer
        0.333, 0.444, // Double
        5555555555L, 9999999999L // Long
);

final var ret = stream.mapMultiToInt((number, consumer) -> {
    if (number instanceof Integer i) {
        consumer.accept(i);
    }
}).toArray();

System.out.println(Arrays.toString(ret)); // [111, 222]

default LongStream mapMultiToLong (BiConsumer<? super T,? super LongConsumer> mapper)

このストリームの各要素を複数の要素(特にゼロ個以上の要素)で置き換えた結果で構成されるLongStreamを返します。

final var stream = Stream.<Number>of(
        111, 222, // Integer
        0.333, 0.444, // Double
        5555555555L, 9999999999L // Long
);

final var ret = stream.mapMultiToLong((number, consumer) -> {
    if (number instanceof Long l) {
        consumer.accept(l);
    }
}).toArray();

System.out.println(Arrays.toString(ret)); // [5555555555, 9999999999]

DoubleStream mapToDouble (ToDoubleFunction<? super T> mapper)

このストリームの要素に指定された関数を適用した結果から構成されるDoubleStreamを返します。

final var stream = Stream.of(100, 125, 200);

final var mapper = new ToDoubleFunction<Integer>() {
    @Override
    public double applyAsDouble(Integer value) {
        return value / 2.0;
    }
};

final var ret = stream.mapToDouble(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [50.0, 62.5, 100.0]

IntStream mapToInt (ToIntFunction<? super T> mapper)

このストリームの要素に指定された関数を適用した結果から構成されるIntStreamを返します。

final var stream = Stream.of("0x01", "0x0a", "0xff");

final var mapper = new ToIntFunction<String>() {
    @Override
    public int applyAsInt(String value) {
        return Integer.decode(value);
    }
};

final var ret = stream.mapToInt(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [1, 10, 255]

LongStream mapToLong (ToLongFunction<? super T> mapper)

このストリームの要素に指定された関数を適用した結果から構成されるLongStreamを返します。

final var stream = Stream.of("0x01", "0x0a", "0xffffffffffffff");

final var mapper = new ToLongFunction<String>() {
    @Override
    public long applyAsLong(String value) {
        return Long.decode(value);
    }
};

final var ret = stream.mapToLong(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [1, 10, 72057594037927935]

Optional<T> max (Comparator<? super T> comparator)

指定されたComparatorに従ってこのストリームの最大要素を返します。

final var stream = Stream.of(10, 5, 100, 30);

final var comparator = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return Integer.compare(o1, o2);
    }
};

final var max = stream.max(comparator);
System.out.println(max.orElseThrow()); // 100

final var stream = Stream.of(10, 5, 100, 30);

final var max = stream.max(Comparator.naturalOrder());
System.out.println(max.orElseThrow()); // 100

final var stream = Stream.of("AAA", "ddd", "CCC", "bbb");

final var max = stream.max(String.CASE_INSENSITIVE_ORDER);
System.out.println(max.orElseThrow()); // "ddd"

final var stream = Stream.<String>empty();

final var max = stream.max(String.CASE_INSENSITIVE_ORDER);
System.out.println(max.isEmpty()); // true

Optional<T> min (Comparator<? super T> comparator)

指定されたComparatorに従ってこのストリームの最小要素を返します。

final var stream = Stream.of(10, 5, 100, 30);

final var comparator = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return Integer.compare(o1, o2);
    }
};

final var min = stream.min(comparator);
System.out.println(min.orElseThrow()); // 5

final var stream = Stream.of(10, 5, 100, 30);

final var min = stream.min(Comparator.naturalOrder());
System.out.println(min.orElseThrow()); // 5

final var stream = Stream.of("CCC", "ddd", "AAA", "bbb");

final var min = stream.min(String.CASE_INSENSITIVE_ORDER);
System.out.println(min.orElseThrow()); // "AAA"

final var stream = Stream.<String>empty();

final var min = stream.min(String.CASE_INSENSITIVE_ORDER);
System.out.println(min.isEmpty()); // true

boolean noneMatch (Predicate<? super T> predicate)

指定された述語に一致する要素がこのストリーム内に存在しないかどうかを返します。

final var predicate = new Predicate<Character>() {
    @Override
    public boolean test(Character c) {
        // 小文字かどうか判定します。
        return Character.isLowerCase(c);
    }
};

{
    final var stream = Stream.of('a', 'b', 'c');

    final var ret = stream.noneMatch(predicate);
    System.out.println(ret); // false
}
{
    final var stream = Stream.of('A', 'b', 'c');

    final var ret = stream.noneMatch(predicate);
    System.out.println(ret); // false
}
{
    final var stream = Stream.of('A', 'B', 'C');

    final var ret = stream.noneMatch(predicate);
    System.out.println(ret); // true
}

{
    final var stream = Stream.of("aaa", "bbB", "CCC");

    final var ret = stream.noneMatch(s -> {
        // 小文字のみが含まれているかどうかチェック。
        return s.matches("[a-z]*");
    });
    System.out.println(ret); // false
}
{
    final var stream = Stream.of("aaA", "bBB", "CCC");

    final var ret = stream.noneMatch(s -> s.matches("[a-z]*"));
    System.out.println(ret); // true
}

static <T> Stream<T> of (T t)

単一要素を含む順次Streamを返します。

final var stream = Stream.of("aaa");

final var ret = stream.toList();
System.out.println(ret); // [aaa]

final var stream = Stream.of(123);

final var ret = stream.toList();
System.out.println(ret); // [123]

static <T> Stream<T> of (T... values)

指定された値を要素に持つ、順序付けされた順次ストリームを返します。

final var stream = Stream.of("aaa", "bbb");

final var ret = stream.toList();
System.out.println(ret); // [aaa, bbb]

final var stream = Stream.of("aaa", "bbb", "ccc");

final var ret = stream.toList();
System.out.println(ret); // [aaa, bbb, ccc]

final var stream = Stream.of(1, 3, 5, 7, 9);

final var ret = stream.toList();
System.out.println(ret); // [1, 3, 5, 7, 9]

static <T> Stream<T> ofNullable (T t)

非nullならば、単一の要素を含むシーケンシャルなStreamを返します。それ以外の場合は空のStreamを返します。

final var stream = Stream.ofNullable("aaa");

final var ret = stream.toList();
System.out.println(ret); // [aaa]

final var stream = Stream.ofNullable(123);

final var ret = stream.toList();
System.out.println(ret); // [123]

final var stream = Stream.ofNullable(null);

final var ret = stream.count();
System.out.println(ret); // 0

Stream<T> peek (Consumer<? super T> action)

このストリームの要素から成るストリームを返すほか、その結果のストリームから消費される各要素に対し、指定されたアクションを実行します。

forEachと違い、このメソッドは中間操作です。

関連メソッド : forEach

final var stream = Stream.of("aaa", "bbb", "ccc");

final var action = new Consumer<String>() {
    @Override
    public void accept(String s) {
        final var upper = s.toUpperCase();
        System.out.println(upper);
    }
};

// "AAA"
// "BBB"
// "CCC"
final var list = stream.peek(action).toList();

// [aaa, bbb, ccc]
System.out.println(list);

Optional<T> reduce (BinaryOperator<T> accumulator)

結合的累積関数を使用して、このストリームの要素に対してリダクションを実行し、リダクションされた値を記述するOptionalを返します(ある場合)。

final var stream = Stream.of("a", "b", "c");

final var accumulator = new BinaryOperator<String>() {
    @Override
    public String apply(String s1, String s2) {
        return s1 + " : " + s2;
    }
};

final var ret = stream.reduce(accumulator);
System.out.println(ret.orElseThrow()); // "a : b : c"

final var stream = Stream.<String>empty();

final var ret = stream.reduce((s1, s2) -> s1 + " : " + s2);
System.out.println(ret.isEmpty()); // true

T reduce (T identity, BinaryOperator<T> accumulator)

指定された単位元の値と結合的な累積関数を使ってこのストリームの要素に対してリダクションを実行し、リデュースされた値を返します。

final var stream = Stream.of("a", "b", "c");

final var identity = "";

final var accumulator = new BinaryOperator<String>() {
    @Override
    public String apply(String s1, String s2) {
        if (s1.isEmpty()) {
            return s2;
        }

        return s1 + " : " + s2;
    }
};

final var ret = stream.reduce(identity, accumulator);
System.out.println(ret); // "a : b : c"

final var stream = Stream.<String>empty();

final var identity = "";

final var ret = stream.reduce(identity, (s1, s2) -> {
    if (s1.isEmpty()) {
        return s2;
    }
    return s1 + " : " + s2;
});

System.out.println(ret); // ""

<U> U reduce (U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)

指定された単位元、累積関数、および結合的関数を使用して、このストリームの要素に対してリダクションを実行します。

final var stream = Stream.of(1, 10, 255);

final var identity = "";

final var accumulator = new BiFunction<String, Integer, String>() {
    @Override
    public String apply(String s, Integer i) {
        // 16進数表記に変換して結合していきます。
        final var hex = "0x" + Integer.toHexString(i);

        if (s.isEmpty()) {
            return hex;
        }

        return s + " : " + hex;
    }
};

final var combiner = new BinaryOperator<String>() {
    @Override
    public String apply(String s1, String s2) {
        if (s1.isEmpty()) {
            return s2;
        }

        return s1 + " : " + s2;
    }
};

final var ret = stream.reduce(identity, accumulator, combiner);
System.out.println(ret); // "0x1 : 0xa : 0xff"

Stream<T> skip (long n)

このストリームの最初のn個の要素を破棄した残りの要素で構成されるストリームを返します。

final var stream = Stream.of("a", "b", "c", "d", "e", "f", "g");

final var ret = stream.skip(4).toList();
System.out.println(ret); // [e, f, g]

Stream<T> sorted ()

このストリームの要素を自然順序に従ってソートした結果から構成されるストリームを返します。

final var stream = Stream.of("aaa", "ddd", "ccc", "bbb");

final var ret = stream.sorted().toList();
System.out.println(ret); // [aaa, bbb, ccc, ddd]

final var stream = Stream.of(5, 3, 2, 4, 1).parallel();
System.out.println(stream.isParallel()); // true

final var ret = stream.sorted().toList();
System.out.println(ret); // [1, 2, 3, 4, 5]

Stream<T> sorted (Comparator<? super T> comparator)

このストリームの要素で構成されるストリームを、指定されたComparatorに従ってソートして返します。

final var stream = Stream.of("a", "A", "c", "C", "b", "B");

final var ret = stream.sorted().toList();
System.out.println(ret); // [A, B, C, a, b, c]

final var stream = Stream.of("a", "A", "c", "C", "b", "B");

final var ret = stream.sorted(String.CASE_INSENSITIVE_ORDER).toList();
System.out.println(ret); // [a, A, b, B, c, C]

default Stream<T> takeWhile (Predicate<? super T> predicate)

このストリームが順序付けされている場合、指定された述語に一致するこのストリームから取得された要素の最長プレフィクスからなるストリームを返します。

関連メソッド : dropWhile

final var stream = Stream.of("aa", "bb", "cc", "dd", "ee", "ff");

final var predicate = new Predicate<String>() {
    @Override
    public boolean test(String s) {
        return !s.equals("dd");
    }
};

final var ret = stream.takeWhile(predicate).toList();
System.out.println(ret); // [aa, bb, cc]

final var stream = Stream.of(1, 2, 3, 4, 5);

final var ret = stream.takeWhile(i -> i != 4).toList();
System.out.println(ret); // [1, 2, 3]

Object[] toArray ()

このストリームの要素を含む配列を返します。

final var stream = Stream.of("aaa", "bbb", "ccc");

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [aaa, bbb, ccc]

final var stream = Stream.of(1, 3, 100);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [1, 3, 100]

<A> A[] toArray (IntFunction<A[]> generator)

指定されたgenerator関数を使用して、このストリームの要素を含む配列を返し、返された配列と、パーティション化された実行またはサイズ変更に必要となる可能性のある追加の配列を割り当てます。

final var stream = Stream.of("aaa", "bbb", "ccc");

final var generator = new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
};

final String[] ret = stream.toArray(generator);
System.out.println(Arrays.toString(ret)); // [aaa, bbb, ccc]

final var stream = Stream.of("aaa", "bbb", "ccc");

// メソッド参照を使うと簡潔に書けます。
final String[] ret = stream.toArray(String[]::new);
System.out.println(Arrays.toString(ret)); // [aaa, bbb, ccc]

default List<T> toList ()

このストリームの要素をListに蓄積します。

final var stream = Stream.of("aaa", "bbb", "ccc");

final var ret = stream.toList();
System.out.println(ret); // [aaa, bbb, ccc]

final var stream = Stream.of(1, 3, 100);

final var ret = stream.toList();
System.out.println(ret); // [1, 3, 100]

final var stream = Stream.of("aaa", "bbb", "ccc");

// 返されるリストは変更不可です。
final var list = stream.toList();
//list.add("ddd"); // UnsupportedOperationException

close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered

「Java API 使用例 : BaseStream」をご参照ください。