Stream (Java SE 21 & JDK 21) の使用例まとめです。
だいたいのメソッドを網羅済みです。
API仕様書のおともにどうぞ。
概要
順次および並列の集約操作をサポートする要素のシーケンスです。
Stream は、ストリームAPI の基本となるインタフェースです。
ストリームAPI は慣れるまでは難しく感じるかもしれません。
しかし、使いこなせると、List や Set などのコレクションの操作がとてもすっきりと記述できるようになります。
ストリームの基本的なことは下記の記事で解説していますので、そちらもご参照ください。
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(str -> str.toUpperCase())
.sorted()
.toList();
System.out.println(ret); // [A, B, C, X, Y, Z]
final var stream = Stream.of(1, 2, 2, 3, 3, 3);
final var ret = stream.distinct().toList();
System.out.println(ret); // [1, 2, 3]
メソッド
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
}
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
}
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() {
System.out.println("-- supplier --");
return new ArrayList<>();
}
};
final var accumulator = new BiConsumer<List<String>, String>() {
@Override
public void accept(List<String> list, String value) {
System.out.println("-- accumulator --");
System.out.println(" list = " + list);
System.out.println(" value = " + value);
list.add(value);
}
};
final var combiner = new BiConsumer<List<String>, List<String>>() {
@Override
public void accept(List<String> list1, List<String> list2) {
System.out.println("-- combiner --");
System.out.println(" list1 = " + list1);
System.out.println(" list2 = " + list2);
list1.addAll(list2);
}
};
{
final var stream = Stream.of("aaa", "bbb", "ccc");
final var ret = stream.collect(supplier, accumulator, combiner);
System.out.println("collect = " + ret);
// 結果
// ↓
//-- supplier --
//-- accumulator --
// list = []
// value = aaa
//-- accumulator --
// list = [aaa]
// value = bbb
//-- accumulator --
// list = [aaa, bbb]
// value = ccc
//collect = [aaa, bbb, ccc]
}
{
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("collect = " + ret);
// 結果
// ↓
//-- supplier --
//-- accumulator --
// list = []
// value = bbb
//-- supplier --
//-- accumulator --
// list = []
// value = ccc
//-- supplier --
//-- accumulator --
// list = []
// value = aaa
//-- combiner --
// list1 = [bbb]
// list2 = [ccc]
//-- combiner --
// list1 = [aaa]
// list2 = [bbb, ccc]
//collect = [aaa, bbb, ccc]
}
<R, A> R collect (Collector<? super T,A,R> collector)
Collectorを使ってこのストリームの要素に対する可変リダクション操作を実行します。
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("X", "Y", "Z");
final Map<String, String> map = stream.collect(Collectors.toMap(
s -> s + "-key",
s -> s + "-value"
));
// {X-key=X-value, Z-key=Z-value, Y-key=Y-value}
System.out.println(map);
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)
このストリームが順序付けされている場合は、指定された述語に一致する要素の最長プレフィクスを削除した後に、このストリームの残りの要素で構成されるストリームを返します。
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(v -> v != 3).toList();
System.out.println(ret); // [3, 4, 5]
static <T> Stream<T> empty ()
空の順次Streamを返します。
final var stream = Stream.<String>empty();
System.out.println(stream.count()); // 0
final var stream = Stream.<Integer>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(v -> Character.isUpperCase(v)).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 opt = stream.findAny();
if (opt.isEmpty()) {
throw new IllegalStateException();
}
switch (opt.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 opt = stream.findAny();
System.out.println(opt.isEmpty()); // true
Optional<T> findFirst ()
このストリームの最初の要素を記述するOptionalを返します。ストリームが空の場合は空のOptionalを返します。
final var stream = Stream.of("aaa", "bbb", "ccc");
final var opt = stream.findFirst();
opt.ifPresent(value -> {
System.out.println(value); // aaa
});
// parallel
final var stream = Stream.of("aaa", "bbb", "ccc").parallel();
System.out.println(stream.isParallel()); // true
final var opt = stream.findFirst();
opt.ifPresent(value -> {
System.out.println(value); // aaa
});
int aaa = 0;
int bbb = 0;
int ccc = 0;
for (int i = 0; i < 1000; i++) {
// unordered and parallel
final var stream = Stream.of("aaa", "bbb", "ccc").unordered().parallel();
// "aaa" or "bbb" or "ccc"
final var opt = stream.findFirst();
if (opt.isEmpty()) {
throw new IllegalStateException();
}
switch (opt.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 opt = stream.findFirst();
System.out.println(opt.isEmpty()); // true
<R> Stream<R> flatMap (Function<? super T,? extends Stream<? extends R>> mapper)
このストリームの各要素をマップされたストリーム(指定されたマッピング関数を各要素に適用することで得られる)の内容で置き換えた結果から成るストリームを返します。
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();
// [--, AAA, ++, --, BBB, ++, --, CCC, ++]
System.out.println(ret);
DoubleStream flatMapToDouble (Function<? super T,? extends DoubleStream> mapper)
このストリームの各要素を、その要素に指定されたマッピング関数を適用することによって生成されるマップ先ストリームの内容で置き換えた結果から構成されるDoubleStreamを返します。
final var stream = Stream.of("0x01", "0x02", "0xff");
final var mapper = new Function<String, DoubleStream>() {
@Override
public DoubleStream apply(String s) {
final int num = Integer.decode(s);
return DoubleStream.of(num, num + 0.1, num + 0.2);
}
};
final var ret = stream.flatMapToDouble(mapper).toArray();
// [1.0, 1.1, 1.2, 2.0, 2.1, 2.2, 255.0, 255.1, 255.2]
System.out.println(Arrays.toString(ret));
IntStream flatMapToInt (Function<? super T,? extends IntStream> mapper)
このストリームの各要素をマップされたストリーム(指定されたマッピング関数を各要素に適用することで得られる)の内容で置き換えた結果から成るIntStreamを返します。
final var stream = Stream.of("0x01", "0x02", "0xff");
final var mapper = new Function<String, IntStream>() {
@Override
public IntStream apply(String s) {
final int num = Integer.decode(s);
return IntStream.of(num, num * 10, num * 100);
}
};
final var ret = stream.flatMapToInt(mapper).toArray();
// [1, 10, 100, 2, 20, 200, 255, 2550, 25500]
System.out.println(Arrays.toString(ret));
LongStream flatMapToLong (Function<? super T,? extends LongStream> mapper)
このストリームの各要素をマップされたストリーム(指定されたマッピング関数を各要素に適用することで得られる)の内容で置き換えた結果から成るLongStreamを返します。
final var stream = Stream.of("0x01", "0x02", "0xff");
final var mapper = new Function<String, LongStream>() {
@Override
public LongStream apply(String s) {
final long num = Long.decode(s);
return LongStream.of(num, num * 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)
このストリームの各要素に対してアクションを実行します。
関連 : 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);
}
};
System.out.println("-- forEach --");
stream.forEach(action);
// 結果
// ↓
//-- forEach --
//aaa
//bbb
//ccc
// ラムダ式を使う例です。
final var stream = Stream.of("ZZZ", "YYY", "XXX");
System.out.println("-- forEach --");
stream.forEach(v -> {
System.out.println(v);
});
// 結果
// ↓
//ZZZ
//YYY
//XXX
final var stream = Stream.of(10, 20, 30, 40, 50).parallel();
System.out.println(stream.isParallel()); // true
System.out.println("-- forEach --");
stream.forEach(v -> {
System.out.println(v);
});
// 結果
// ↓
//-- forEach --
//30
//50
//40
//10
//20
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);
}
};
System.out.println("-- forEach --");
stream.forEachOrdered(action);
// 結果
// ↓
//-- forEach --
//aaa
//bbb
//ccc
final var stream = Stream.of(10, 20, 30, 40, 50).parallel();
System.out.println(stream.isParallel()); // true
System.out.println("-- forEach --");
stream.forEachOrdered(v -> {
System.out.println(v);
});
// 結果
// ↓
//-- forEach --
//10
//20
//30
//40
//50
static <T> Stream<T> generate (Supplier<? extends T> s)
指定されたSupplierによって生成される要素を含む、順序付けされていない無限順次ストリームを返します。
final var supplier = new Supplier<Integer>() {
int count = 0;
@Override
public Integer get() {
count += 10;
return count;
}
};
final var stream = Stream.generate(supplier);
final var ret = stream.limit(5).toList();
System.out.println(ret); // [10, 20, 30, 40, 50]
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);
final var ret = stream.limit(10).toList();
// [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
System.out.println(ret);
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(
100, 200, // Integer
3.0, 4.0, // Double
5000000000L, 6000000000L // Long
);
final var mapper = new BiConsumer<Number, Consumer<String>>() {
@Override
public void accept(Number number, Consumer<String> consumer) {
if (number instanceof Integer i) {
consumer.accept("num=" + i);
consumer.accept("num=" + (i + 1));
consumer.accept("num=" + (i + 2));
}
}
};
final var ret = stream.mapMulti(mapper).toList();
// [num=100, num=101, num=102, num=200, num=201, num=202]
System.out.println(ret);
default DoubleStream mapMultiToDouble (BiConsumer<? super T,? super DoubleConsumer> mapper)
このストリームの各要素を複数の要素(特にゼロ個以上の要素)で置き換えた結果で構成されるDoubleStreamを返します。
final var stream = Stream.<Number>of(
100, 200, // Integer
3.0, 4.0, // Double
5000000000L, 6000000000L // Long
);
final var ret = stream.mapMultiToDouble((number, consumer) -> {
if (number instanceof Double d) {
consumer.accept(d);
consumer.accept(d + 0.1);
consumer.accept(d + 0.2);
}
}).toArray();
// [3.0, 3.1, 3.2, 4.0, 4.1, 4.2]
System.out.println(Arrays.toString(ret));
default IntStream mapMultiToInt (BiConsumer<? super T,? super IntConsumer> mapper)
このストリームの各要素を複数の要素(特にゼロ個以上の要素)で置き換えた結果で構成されるIntStreamを返します。
final var stream = Stream.<Number>of(
100, 200, // Integer
3.0, 4.0, // Double
5000000000L, 6000000000L // Long
);
final var ret = stream.mapMultiToInt((number, consumer) -> {
if (number instanceof Integer i) {
consumer.accept(i);
consumer.accept(i + 1);
consumer.accept(i + 2);
}
}).toArray();
// [100, 101, 102, 200, 201, 202]
System.out.println(Arrays.toString(ret));
default LongStream mapMultiToLong (BiConsumer<? super T,? super LongConsumer> mapper)
このストリームの各要素を複数の要素(特にゼロ個以上の要素)で置き換えた結果で構成されるLongStreamを返します。
final var stream = Stream.<Number>of(
100, 200, // Integer
3.0, 4.0, // Double
5000000000L, 6000000000L // Long
);
final var ret = stream.mapMultiToLong((number, consumer) -> {
if (number instanceof Long l) {
consumer.accept(l);
consumer.accept(l + 1);
}
}).toArray();
// [5000000000, 5000000001, 6000000000, 6000000001]
System.out.println(Arrays.toString(ret));
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 opt = stream.max(comparator);
opt.ifPresent(value -> {
System.out.println(value); // 100
});
final var stream = Stream.of("aaa", "ddd", "ccc", "bbb");
final var opt = stream.max(Comparator.naturalOrder());
opt.ifPresent(value -> {
System.out.println(value); // ddd
});
final var stream = Stream.<String>empty();
final var opt = stream.max(String.CASE_INSENSITIVE_ORDER);
System.out.println(opt.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 opt = stream.min(comparator);
opt.ifPresent(value -> {
System.out.println(value); // 5
});
final var stream = Stream.of("ccc", "ddd", "aaa", "bbb");
final var opt = stream.min(Comparator.naturalOrder());
opt.ifPresent(value -> {
System.out.println(value); // aaa
});
final var stream = Stream.<String>empty();
final var opt = stream.min(String.CASE_INSENSITIVE_ORDER);
System.out.println(opt.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
}
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)
このストリームの要素から成るストリームを返すほか、その結果のストリームから消費される各要素に対し、指定されたアクションを実行します。
final var stream = Stream.of("aaa", "bbb", "ccc");
final var action = new Consumer<String>() {
@Override
public void accept(String value) {
System.out.println("peek : value = " + value);
}
};
final var list = stream.peek(action).toList();
System.out.println("list = " + list);
// 結果
// ↓
//peek : value = aaa
//peek : value = bbb
//peek : value = ccc
//list = [aaa, bbb, ccc]
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 opt = stream.reduce(accumulator);
opt.ifPresent(value -> {
System.out.println(value); // 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.isEmpty()); // true
<U> U reduce (U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)
指定された単位元、累積関数、および結合的関数を使用して、このストリームの要素に対してリダクションを実行します。
final var stream = Stream.of(1, 10, 255).parallel();
System.out.println(stream.isParallel()); // true
final var identity = "";
final var accumulator = new BiFunction<String, Integer, String>() {
@Override
public String apply(String s, Integer i) {
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("aaa", "ddd", "ccc", "bbb");
final var ret = stream.sorted(Comparator.reverseOrder()).toList();
System.out.println(ret); // [ddd, ccc, bbb, aaa]
final var stream = Stream.of(1, 3, 2, 5, 4).parallel();
System.out.println(stream.isParallel()); // true
final var ret = stream.sorted(Comparator.reverseOrder()).toList();
System.out.println(ret); // [5, 4, 3, 2, 1]
default Stream<T> takeWhile (Predicate<? super T> predicate)
このストリームが順序付けされている場合、指定された述語に一致するこのストリームから取得された要素の最長プレフィクスからなるストリームを返します。
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(v -> v != 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 list = stream.toList();
System.out.println(list); // [aaa, bbb, ccc]
try {
list.add("ddd");
} catch (UnsupportedOperationException e) {
System.out.println("UnsupportedOperationException!");
}
// 結果
// ↓
//UnsupportedOperationException!
final var stream = Stream.of(1, 3, 100);
final var list = stream.toList();
System.out.println(list); // [1, 3, 100]
BaseStreamで宣言されたメソッド
close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered
「Java API 使用例 : BaseStream」をご参照ください。