Java : IntStream - API使用例

IntStream (Java SE 17 & JDK 17)の使用例まとめです。
だいたいのメソッドを網羅済みです。
API仕様のおともにどうぞ。


概要

クラス構成

Stream のプリミティブ int 型版です。

IntStream には、生成に便利な range、rangeClosed メソッドがあります。
for文の代わりにも使えます。

final var stream = IntStream.range(0, 5);
stream.forEach(i -> {
    //0
    //1
    //2
    //3
    //4
    System.out.println(i);
});
final var stream = IntStream.rangeClosed(0, 5);

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

ストリームの基本的なことは下記の記事で解説していますので、そちらもご参照ください。

メソッド

boolean allMatch (IntPredicate predicate)

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

final var predicate = new IntPredicate() {
    @Override
    public boolean test(int value) {
        // 偶数か判定します。
        return value % 2 == 0;
    }
};

{
    final var stream = IntStream.of(0, 2, 4);

    final var ret = stream.allMatch(predicate);
    System.out.println(ret); // true
}
{
    final var stream = IntStream.of(0, 1, 2, 3, 4);

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

boolean anyMatch (IntPredicate predicate)

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

final var predicate = new IntPredicate() {
    @Override
    public boolean test(int value) {
        // 偶数か判定します。
        return value % 2 == 0;
    }
};

{
    final var stream = IntStream.of(0, 2, 4);

    final var ret = stream.anyMatch(predicate);
    System.out.println(ret); // true
}
{
    final var stream = IntStream.of(1, 2, 3);

    final var ret = stream.anyMatch(predicate);
    System.out.println(ret); // true
}
{
    final var stream = IntStream.of(1, 3, 5);

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

DoubleStream asDoubleStream ()

このストリームの要素をdoubleに変換した結果から構成されるDoubleStreamを返します。

final var stream = IntStream.of(1, 2, 3);
final var doubleStream = stream.asDoubleStream().map(v -> v / 2);

final var ret = doubleStream.toArray();
System.out.println(Arrays.toString(ret)); // [0.5, 1.0, 1.5]

LongStream asLongStream ()

このストリームの要素をlongに変換した結果から構成されるLongStreamを返します。

final var stream = IntStream.of(1, 2, 3);
final var longStream = stream.asLongStream().map(v -> v * 10000000000L);

final var ret = longStream.toArray();
System.out.println(Arrays.toString(ret)); // [10000000000, 20000000000, 30000000000]

OptionalDouble average ()

このストリームの要素の算術平均を記述するOptionalDoubleを返します。このストリームが空の場合は空のOptionalを返します。

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

final var ret = stream.average();
System.out.println(ret.orElseThrow()); // 3.5
final var ret = IntStream.empty().average();
System.out.println(ret.isEmpty()); // true

Stream<Integer> boxed ()

ストリームの各要素をIntegerにボクシングした結果から構成されるStreamを返します。

final Stream<Integer> stream = IntStream.range(0, 5).boxed();

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

static IntStream.Builder builder ()

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

final var builder = IntStream.builder();
builder.add(0).add(2).add(4);

final var stream = builder.build();

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0, 2, 4]

<R> R collect (Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R,R> combiner)

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

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

final var accumulator = new ObjIntConsumer<List<String>>() {
    @Override
    public void accept(List<String> list, int value) {
        // 16進数表記の文字列に変換。
        list.add("0x%x".formatted(value));
    }
};

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 = IntStream.of(1, 100, 255);

    final var ret = stream.collect(supplier, accumulator, combiner);
    System.out.println(ret); // [0x1, 0x64, 0xff]
}
{
    // combinerは並列ストリームで使われます。
    final var parallelStream = IntStream.of(1, 100, 255).parallel();
    System.out.println(parallelStream.isParallel()); // true

    final var ret = parallelStream.collect(supplier, accumulator, combiner);
    System.out.println(ret); // [0x1, 0x64, 0xff]
}

static IntStream concat (IntStream a, IntStream b)

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

final var stream1 = IntStream.of(1, 2, 3);
final var stream2 = IntStream.of(100, 200, 300);

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

final var concatStream = IntStream.concat(stream1, stream2);

System.out.println(concatStream.isParallel()); // false

final var ret = concatStream.toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 3, 100, 200, 300]
final var stream1 = IntStream.of(1, 2, 3).parallel();
final var stream2 = IntStream.of(100, 200, 300).parallel();

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

final var concatStream = IntStream.concat(stream1, stream2);

System.out.println(concatStream.isParallel()); // true

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

long count ()

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

final var stream = IntStream.of(0, 2, 4, 6);
System.out.println(stream.count()); // 4
final var stream = IntStream.empty();
System.out.println(stream.count()); // 0

IntStream distinct ()

このストリームの重複を除いた要素から構成されるストリームを返します。

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

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

default IntStream dropWhile (IntPredicate predicate)

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

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

final var predicate = new IntPredicate() {
    @Override
    public boolean test(int value) {
        return value != 3;
    }
};

final var ret = stream.dropWhile(predicate).toArray();
System.out.println(Arrays.toString(ret)); // [3, 4, 5]
final var stream = IntStream.of(-1, -2, -3, -4, -5);

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

static IntStream empty ()

空の順次IntStreamを返します。

final var stream = IntStream.empty();
System.out.println(stream.count()); // 0
final var stream = IntStream.empty();
final var array = stream.toArray();
System.out.println(Arrays.toString(array)); // []

IntStream filter (IntPredicate predicate)

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

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

final var predicate = new IntPredicate() {
    @Override
    public boolean test(int value) {
        // 偶数か判定します。
        return value % 2 == 0;
    }
};

final var ret = stream.filter(predicate).toArray();
System.out.println(Arrays.toString(ret)); // [0, 2, 4]
final var stream = IntStream.of(0, 1, 2, 3, 4, 5);

final var ret = stream.filter(v -> v % 2 == 1).toArray();
System.out.println(Arrays.toString(ret)); // [1, 3, 5]

OptionalInt findAny ()

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

int count1 = 0;
int count2 = 0;
int count3 = 0;

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

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

    // 1 or 2 or 3
    final var ret = stream.findAny();
    switch (ret.orElseThrow()) {
        case 1 -> count1++;
        case 2 -> count2++;
        case 3 -> count3++;
    }
}

System.out.println("count1 : " + count1);
System.out.println("count2 : " + count2);
System.out.println("count3 : " + count3);

// 結果
// ↓
//count1 : 183
//count2 : 814
//count3 : 3
final var stream = IntStream.empty();

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

OptionalInt findFirst ()

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

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

final var ret = stream.findFirst();
System.out.println(ret.orElseThrow()); // 1
// findAny と違い、parallelでも最初の要素を返します。
final var stream = IntStream.of(1, 2, 3).parallel();
System.out.println(stream.isParallel()); // true

final var ret = stream.findFirst();
System.out.println(ret.orElseThrow()); // 1
int count1 = 0;
int count2 = 0;
int count3 = 0;

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

    // ただし、unordered かつ parallel の場合は、どの値が返されるかは決まりません。
    final var stream = IntStream.of(1, 2, 3).unordered().parallel();

    // 1 or 2 or 3
    final var ret = stream.findFirst();
    switch (ret.orElseThrow()) {
        case 1 -> count1++;
        case 2 -> count2++;
        case 3 -> count3++;
    }
}

System.out.println("count1 : " + count1);
System.out.println("count2 : " + count2);
System.out.println("count3 : " + count3);

// 結果
// ↓
//count1 : 137
//count2 : 856
//count3 : 7
final var stream = IntStream.empty();

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

IntStream flatMap (IntFunction<? extends IntStream> mapper)

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

final var stream = IntStream.of(100, 200, 300);

final var mapper = new IntFunction<IntStream>() {
    @Override
    public IntStream apply(int value) {
        return IntStream.of(value, value + 1, value + 2);
    }
};

final var ret = stream.flatMap(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [100, 101, 102, 200, 201, 202, 300, 301, 302]

void forEach (IntConsumer action)

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

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

final var action = new IntConsumer() {
    @Override
    public void accept(int value) {
        System.out.println(value);
    }
};

//1
//2
//3
stream.forEach(action);
// ラムダ式を使う例
final var stream = IntStream.of(1, 2, 3);

stream.forEach(v -> {
    //1
    //2
    //3
    System.out.println(v);
});
// メソッド参照を使う例
final var stream = IntStream.of(1, 2, 3);

//1
//2
//3
stream.forEach(System.out::println);
final var stream = IntStream.of(1, 2, 3).parallel();
System.out.println(stream.isParallel()); // true

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

//2
//3
//1
stream.forEach(System.out::println);

void forEachOrdered (IntConsumer action)

このストリームの各要素に対してアクションを実行します。検出順が定義されたストリームでは、各要素が検出順に処理されることが保証されます。

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

final var action = new IntConsumer() {
    @Override
    public void accept(int value) {
        System.out.println(value);
    }
};

//1
//2
//3
stream.forEachOrdered(action);
final var stream = IntStream.of(1, 2, 3).parallel();
System.out.println(stream.isParallel()); // true

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

//1
//2
//3
stream.forEachOrdered(System.out::println);

static IntStream generate (IntSupplier s)

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

final var supplier = new IntSupplier() {
    int count = 0;

    @Override
    public int getAsInt() {
        count++;
        return count;
    }
};

final var stream = IntStream.generate(supplier);

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

static IntStream iterate (int seed, IntPredicate hasNext, IntUnaryOperator next)

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

final var hasNext = new IntPredicate() {
    @Override
    public boolean test(int value) {
        return value <= 100;
    }
};

final var next = new IntUnaryOperator() {
    @Override
    public int applyAsInt(int operand) {
        return operand * 2;
    }
};

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

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

static IntStream iterate (int seed, IntUnaryOperator f)

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

final var next = new IntUnaryOperator() {
    @Override
    public int applyAsInt(int operand) {
        return operand * 2;
    }
};

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

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

IntStream limit (long maxSize)

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

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

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

IntStream map (IntUnaryOperator mapper)

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

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

final var mapper = new IntUnaryOperator() {
    @Override
    public int applyAsInt(int operand) {
        return operand * 2;
    }
};

final var ret = stream.map(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [2, 4, 6]
final var stream = IntStream.range(0, 4);

final var ret = stream.map(v -> v * 100).toArray();
System.out.println(Arrays.toString(ret)); // [0, 100, 200, 300]

default IntStream mapMulti (IntStream.IntMapMultiConsumer mapper)

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

final var stream = IntStream.of(100, 200, 300);

final var mapper = new IntStream.IntMapMultiConsumer() {
    @Override
    public void accept(int value, IntConsumer ic) {
        ic.accept(value);
        ic.accept(value + 1);
        ic.accept(value + 2);
    }
};

final var ret = stream.mapMulti(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [100, 101, 102, 200, 201, 202, 300, 301, 302]

DoubleStream mapToDouble (IntToDoubleFunction mapper)

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

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

final var mapper = new IntToDoubleFunction() {
    @Override
    public double applyAsDouble(int value) {
        return value / 2.0;
    }
};

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

LongStream mapToLong (IntToLongFunction mapper)

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

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

final var mapper = new IntToLongFunction() {
    @Override
    public long applyAsLong(int value) {
        return value * 10000000000L;
    }
};

final var ret = stream.mapToLong(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [10000000000, 20000000000, 30000000000]

<U> Stream<U> mapToObj (IntFunction<? extends U> mapper)

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

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

final var mapper = new IntFunction<String>() {
    @Override
    public String apply(int value) {
        return "num=" + value;
    }
};

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

OptionalInt max ()

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

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

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

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

OptionalInt min ()

このストリームの最小要素を記述するOptionalIntまたは空のオプション(このストリームが空の場合)を返します。

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

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

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

boolean noneMatch (IntPredicate predicate)

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

final var predicate = new IntPredicate() {
    @Override
    public boolean test(int value) {
        // 偶数かどうか判定します。
        return value % 2 == 0;
    }
};

{
    final var stream = IntStream.of(0, 2, 4);

    final var ret = stream.noneMatch(predicate);
    System.out.println(ret); // false
}
{
    final var stream = IntStream.of(1, 2, 3);

    final var ret = stream.noneMatch(predicate);
    System.out.println(ret); // false
}
{
    final var stream = IntStream.of(1, 3, 5);

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

static IntStream of (int t)

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

final var stream = IntStream.of(0);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0]
final var stream = IntStream.of(123);

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

static IntStream of (int... values)

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

final var stream = IntStream.of(0, 2, 4, 6, 8, 10);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0, 2, 4, 6, 8, 10]

IntStream peek (IntConsumer action)

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

peek は中間操作です。
よって、peek のあとに toArray などの終端操作を実行できます。

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

final var action = new IntConsumer() {
    @Override
    public void accept(int value) {
        System.out.println(value * 100);
    }
};

//100
//200
//300
final var array = stream.peek(action).toArray();

System.out.println(Arrays.toString(array)); // [1, 2, 3]

static IntStream range (int startInclusive, int endExclusive)

startInclusive(含む)からendExclusive(含まない)の範囲でステップ1でインクリメントした値を含む、順序付けされた順次IntStreamを返します。

final var stream = IntStream.range(0, 10);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
final var stream = IntStream.range(-5, 5);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

static IntStream rangeClosed (int startInclusive, int endInclusive)

startInclusive(含む)からendInclusive(含む)の範囲でステップ1でインクリメントした値を含む、順序付けされた順次IntStreamを返します。

final var stream = IntStream.rangeClosed(0, 10);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
final var stream = IntStream.rangeClosed(-5, 5);

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

int reduce (int identity, IntBinaryOperator op)

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

final var stream = IntStream.of(1, 2, 3, 4);
final var identity = 0;

final var accumulator = new IntBinaryOperator() {
    @Override
    public int applyAsInt(int left, int right) {
        if (identity == left) {
            return right;
        }

        return left + right;
    }
};

// 結果として、要素の合計となります。
final var ret = stream.reduce(identity, accumulator);
System.out.println(ret); // 10
final var stream = IntStream.empty();
final var identity = 0;

final var ret = stream.reduce(identity, (left, right) -> {
    if (identity == left) {
        return right;
    }

    return left + right;
});

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

OptionalInt reduce (IntBinaryOperator op)

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

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

final var accumulator = new IntBinaryOperator() {
    @Override
    public int applyAsInt(int left, int right) {
        return left + right;
    }
};

// 結果として、要素の合計となります。
final var ret = stream.reduce(accumulator);
System.out.println(ret.orElseThrow()); // 10
final var stream = IntStream.empty();

final var ret = stream.reduce((left, right) -> left + right);
System.out.println(ret.isEmpty()); // true

IntStream skip (long n)

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

final var stream = IntStream.of(1, 2, 3, 4, 5, 6, 7);

final var ret = stream.skip(4).toArray();
System.out.println(Arrays.toString(ret)); // [5, 6, 7]

IntStream sorted ()

このストリームの要素で構成されるストリームをソートされた順序で返します。

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

final var ret = stream.sorted().toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 3, 4, 5]
final var stream = IntStream.of(5, 3, 2, 4, 1).parallel();
System.out.println(stream.isParallel()); // true

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

int sum ()

このストリーム内の要素の合計を返します。

final var stream = IntStream.of(1, 2, 3, 4, 5);
System.out.println(stream.sum()); // 15
final var stream = IntStream.of(-10, -20, -30);
System.out.println(stream.sum()); // -60

IntSummaryStatistics summaryStatistics ()

このストリームの要素に関する各種のサマリー・データを記述するIntSummaryStatisticsを返します。

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

final var ret = stream.summaryStatistics();

// IntSummaryStatistics{count=5, sum=15, min=1, average=3.000000, max=5}
System.out.println(ret);

default IntStream takeWhile (IntPredicate predicate)

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

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

final var predicate = new IntPredicate() {
    @Override
    public boolean test(int value) {
        return value != 4;
    }
};

final var ret = stream.takeWhile(predicate).toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 3]
final var stream = IntStream.of(-1, -2, -3, -4, -5);

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

int[] toArray ()

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

final var stream = IntStream.of(1, 2, 3, 4, 5);
final int[] ret = stream.toArray();

System.out.println(Arrays.toString(ret)); // [1, 2, 3, 4, 5]

BaseStreamで宣言されたメソッド

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

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


関連記事

ページの先頭へ