Java : IntStream con ejemplos

IntStream (Java SE 21 & JDK 21) en Java con ejemplos.
Encontrará ejemplos de código en la mayoría de los métodos de IntStream.

Nota :

Este artículo puede utilizar software de traducción para su comodidad. Consulte también la versión original en inglés.

Summary

Una secuencia de elementos primitivos con valores int que soportan operaciones agregadas secuenciales y paralelas. Esta es la especialización int primitiva de Stream. (Traducción automática)

Class diagram

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

System.out.println("-- forEach --");
stream.forEach(v -> {
    System.out.println(v);
});

// Result
// ↓
//-- forEach --
//0
//1
//2
//3
//4

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

final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [10, 20, 30]

Methods

boolean allMatch (IntPredicate predicate)

Devuelve si todos los elementos de esta secuencia coinciden con el predicado proporcionado. (Traducción automática)

final var predicate = new IntPredicate() {
    @Override
    public boolean test(int value) {
        // Check if the number is even.
        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)

Devuelve si algún elemento de esta secuencia coincide con el predicado proporcionado. (Traducción automática)

final var predicate = new IntPredicate() {
    @Override
    public boolean test(int value) {
        // Check if the number is even.
        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 ()

Devuelve un DoubleStream que consta de los elementos de este flujo, convertidos a doble. (Traducción automática)

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

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

LongStream asLongStream ()

Devuelve un LongStream que consta de los elementos de este flujo, convertidos a largo. (Traducción automática)

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

final var ret = longStream.toArray();

// [10000000000, 20000000000, 30000000000]
System.out.println(Arrays.toString(ret));

OptionalDouble average ()

Devuelve un OptionalDouble que describe la media aritmética de los elementos de esta secuencia, o un opcional vacío si esta secuencia está vacía. (Traducción automática)

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

final var opt = stream.average();
opt.ifPresent(value -> {
    System.out.println(value); // 3.5
});

final var opt = IntStream.empty().average();
System.out.println(opt.isEmpty()); // true

Stream<Integer> boxed ()

Devuelve una secuencia que consta de los elementos de esta secuencia, cada uno de ellos encuadrado en un número entero. (Traducción automática)

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 ()

Devuelve un constructor para un IntStream. (Traducción automática)

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)

Realiza una operación de reducción mutable sobre los elementos de esta corriente. (Traducción automática)

final var supplier = new Supplier<List<String>>() {
    @Override
    public List<String> get() {
        System.out.println("-- supplier --");
        return new ArrayList<>();
    }
};

final var accumulator = new ObjIntConsumer<List<String>>() {
    @Override
    public void accept(List<String> list, int value) {
        System.out.println("-- accumulator --");
        System.out.println("  list = " + list);
        System.out.println("  value = " + value);

        list.add("%#x".formatted(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 = IntStream.of(1, 100, 255);

    final var ret = stream.collect(supplier, accumulator, combiner);
    System.out.println("collect = " + ret);

    // Result
    // ↓
    //-- supplier --
    //-- accumulator --
    //  list = []
    //  value = 1
    //-- accumulator --
    //  list = [0x1]
    //  value = 100
    //-- accumulator --
    //  list = [0x1, 0x64]
    //  value = 255
    //collect = [0x1, 0x64, 0xff]
}
{
    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("collect = " + ret);

    // Result
    // ↓
    //-- supplier --
    //-- accumulator --
    //  list = []
    //  value = 100
    //-- supplier --
    //-- accumulator --
    //  list = []
    //  value = 255
    //-- supplier --
    //-- accumulator --
    //  list = []
    //  value = 1
    //-- combiner --
    //  list1 = [0x64]
    //  list2 = [0xff]
    //-- combiner --
    //  list1 = [0x1]
    //  list2 = [0x64, 0xff]
    //collect = [0x1, 0x64, 0xff]
}

static IntStream concat (IntStream a, IntStream b)

Crea una secuencia concatenada de forma diferida cuyos elementos son todos los elementos de la primera secuencia seguidos de todos los elementos de la segunda secuencia. (Traducción automática)

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 ()

Devuelve el recuento de elementos de esta secuencia. (Traducción automática)

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 ()

Devuelve una secuencia que consta de los distintos elementos de esta secuencia. (Traducción automática)

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)

Devuelve, si esta secuencia está ordenada, una secuencia que consta de los elementos restantes de esta secuencia después de eliminar el prefijo más largo de elementos que coinciden con el predicado dado. (Traducción automática)

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(v -> v != -4).toArray();
System.out.println(Arrays.toString(ret)); // [-4, -5]

static IntStream empty ()

Devuelve un IntStream secuencial vacío. (Traducción automática)

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)

Devuelve una secuencia que consta de los elementos de esta secuencia que coinciden con el predicado dado. (Traducción automática)

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

final var predicate = new IntPredicate() {
    @Override
    public boolean test(int value) {
        // Check if the number is even.
        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 ()

Devuelve un OptionalInt que describe algún elemento de la secuencia, o un OptionalInt vacío si la secuencia está vacía. (Traducción automática)

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 opt = stream.findAny();
    if (opt.isEmpty()) {
        throw new IllegalStateException();
    }

    switch (opt.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);

// Result
// ↓
//count1 : 183
//count2 : 814
//count3 : 3

final var stream = IntStream.empty();

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

OptionalInt findFirst ()

Devuelve un OptionalInt que describe el primer elemento de esta secuencia, o un OptionalInt vacío si la secuencia está vacía. (Traducción automática)

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

final var opt = stream.findFirst();
opt.ifPresent(value -> {
    System.out.println(value); // 1
});

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

final var opt = stream.findFirst();
opt.ifPresent(value -> {
    System.out.println(value); // 1
});

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

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

    // unordered and parallel
    final var stream = IntStream.of(1, 2, 3).unordered().parallel();

    // 1 or 2 or 3
    final var opt = stream.findFirst();
    if (opt.isEmpty()) {
        throw new IllegalStateException();
    }

    switch (opt.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);

// Result
// ↓
//count1 : 137
//count2 : 856
//count3 : 7

final var stream = IntStream.empty();

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

IntStream flatMap (IntFunction<? extends IntStream> mapper)

Devuelve una secuencia que consta de los resultados de reemplazar cada elemento de esta secuencia con el contenido de una secuencia asignada producida al aplicar la función de asignación proporcionada a cada elemento. (Traducción automática)

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();

// [100, 101, 102, 200, 201, 202, 300, 301, 302]
System.out.println(Arrays.toString(ret));

void forEach (IntConsumer action)

Realiza una acción para cada elemento de esta secuencia. (Traducción automática)

Please see also : forEachOrdered(IntConsumer action)

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

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

System.out.println("-- forEach --");
stream.forEach(action);

// Result
// ↓
//-- forEach --
//10
//20
//30

// An example with a lambda expression.
final var stream = IntStream.of(-10, -20, -30);

System.out.println("-- forEach --");
stream.forEach(v -> {
    System.out.println(v);
});

// Result
// ↓
//-- forEach --
//-10
//-20
//-30

final var stream = IntStream.of(10, 20, 30, 40, 50).parallel();
System.out.println(stream.isParallel()); // true

System.out.println("-- forEach --");
stream.forEach(v -> {
    System.out.println(v);
});

// Result
// ↓
//-- forEach --
//30
//50
//40
//10
//20

void forEachOrdered (IntConsumer action)

Realiza una acción para cada elemento de esta secuencia, garantizando que cada elemento se procese en el orden de encuentro para las secuencias que tienen un orden de encuentro definido. (Traducción automática)

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

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

System.out.println("-- forEach --");
stream.forEachOrdered(action);

// Result
// ↓
//-- forEach --
//10
//20
//30

final var stream = IntStream.of(10, 20, 30, 40, 50).parallel();
System.out.println(stream.isParallel()); // true

System.out.println("-- forEach --");
stream.forEachOrdered(v -> {
    System.out.println(v);
});

// Result
// ↓
//-- forEach --
//10
//20
//30
//40
//50

static IntStream generate (IntSupplier s)

Devuelve un flujo secuencial infinito y desordenado donde cada elemento es generado por el IntSupplier proporcionado. (Traducción automática)

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

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

final var stream = IntStream.generate(supplier);

final var ret = stream.limit(5).toArray();
System.out.println(Arrays.toString(ret)); // [10, 20, 30, 40, 50]

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

Devuelve un IntStream ordenado secuencial producido por la aplicación iterativa de la siguiente función dada a un elemento inicial, condicionado a satisfacer el predicado hasNext dado. (Traducción automática)

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)

Devuelve un IntStream ordenado secuencial infinito producido por la aplicación iterativa de una función f a un elemento inicial semilla, produciendo un Stream que consta de semilla, f(semilla), f(f(semilla)), etc. (Traducción automática)

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

final var stream = IntStream.iterate(1, next);
final var ret = stream.limit(10).toArray();

// [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
System.out.println(Arrays.toString(ret));

IntStream limit (long maxSize)

Devuelve una secuencia que consta de los elementos de esta secuencia, truncada para que no tenga una longitud superior a maxSize. (Traducción automática)

final var stream = IntStream.of(10, 20, 30, 40, 50, 60);

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

IntStream map (IntUnaryOperator mapper)

Devuelve una secuencia que consta de los resultados de aplicar la función dada a los elementos de esta secuencia. (Traducción automática)

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)

Devuelve una secuencia que consta de los resultados de reemplazar cada elemento de esta secuencia con múltiples elementos, específicamente cero o más elementos. (Traducción automática)

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();

// [100, 101, 102, 200, 201, 202, 300, 301, 302]
System.out.println(Arrays.toString(ret));

DoubleStream mapToDouble (IntToDoubleFunction mapper)

Devuelve un DoubleStream que consta de los resultados de aplicar la función dada a los elementos de este flujo. (Traducción automática)

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)

Devuelve un LongStream que consta de los resultados de aplicar la función dada a los elementos de este flujo. (Traducción automática)

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();

// [10000000000, 20000000000, 30000000000]
System.out.println(Arrays.toString(ret));

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

Devuelve un Stream valorado por objeto que consta de los resultados de aplicar la función dada a los elementos de este flujo. (Traducción automática)

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 ()

Devuelve un OptionalInt que describe el elemento máximo de esta secuencia, o un opcional vacío si esta secuencia está vacía. (Traducción automática)

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

final var opt = stream.max();
opt.ifPresent(value -> {
    System.out.println(value); // 100
});

final var stream = IntStream.empty();

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

OptionalInt min ()

Devuelve un OptionalInt que describe el elemento mínimo de esta secuencia, o un opcional vacío si esta secuencia está vacía. (Traducción automática)

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

final var opt = stream.min();
opt.ifPresent(value -> {
    System.out.println(value); // 5
});

final var stream = IntStream.empty();

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

boolean noneMatch (IntPredicate predicate)

Devuelve si ningún elemento de esta secuencia coincide con el predicado proporcionado. (Traducción automática)

final var predicate = new IntPredicate() {
    @Override
    public boolean test(int value) {
        // Check if the number is even.
        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)

Devuelve un IntStream secuencial que contiene un solo elemento. (Traducción automática)

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)

Devuelve una secuencia ordenada secuencial cuyos elementos son los valores especificados. (Traducción automática)

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)

Devuelve una secuencia que consta de los elementos de esta secuencia y, además, realiza la acción proporcionada en cada elemento a medida que los elementos se consumen de la secuencia resultante. (Traducción automática)

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

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

final var array = stream.peek(action).toArray();
System.out.println("array = " + Arrays.toString(array));

// Result
// ↓
//peek : value = 10
//peek : value = 20
//peek : value = 30
//array = [10, 20, 30]

static IntStream range (int startInclusive, int endExclusive)

Devuelve un IntStream ordenado secuencial desde startInclusive (inclusivo) hasta endExclusive (exclusivo) en un paso incremental de 1. (Traducción automática)

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

// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
System.out.println(Arrays.toString(ret));

final var stream = IntStream.range(-5, 5);
final var ret = stream.toArray();

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

static IntStream rangeClosed (int startInclusive, int endInclusive)

Devuelve un IntStream ordenado secuencial desde startInclusive (inclusive) hasta endInclusive (inclusive) en un paso incremental de 1. (Traducción automática)

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

// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
System.out.println(Arrays.toString(ret));

final var stream = IntStream.rangeClosed(-5, 5);
final var ret = stream.toArray();

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

int reduce (int identity, IntBinaryOperator op)

Realiza una reducción de los elementos de esta secuencia, utilizando el valor de identidad proporcionado y una función de acumulación asociativa, y devuelve el valor reducido. (Traducción automática)

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

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

        return left + right;
    }
};

// 1 + 2 + 3 + 4 = 10
final var ret = stream.reduce(identity, op);
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)

Realiza una reducción de los elementos de esta secuencia, utilizando una función de acumulación asociativa, y devuelve un OptionalInt que describe el valor reducido, si lo hubiera. (Traducción automática)

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

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

// 1 + 2 + 3 + 4 = 10
final var opt = stream.reduce(op);
opt.ifPresent(value -> {
    System.out.println(value); // 10
});

final var stream = IntStream.empty();

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

IntStream skip (long n)

Devuelve una secuencia que consta de los elementos restantes de esta secuencia después de descartar los primeros n elementos de la secuencia. (Traducción automática)

final var stream = IntStream.of(10, 20, 30, 40, 50, 60, 70);

final var ret = stream.skip(4).toArray();
System.out.println(Arrays.toString(ret)); // [50, 60, 70]

IntStream sorted ()

Devuelve una secuencia que consta de los elementos de esta secuencia en orden. (Traducción automática)

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 ()

Devuelve la suma de elementos de esta secuencia. (Traducción automática)

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 ()

Devuelve un IntSummaryStatistics que describe varios datos resumidos sobre los elementos de esta secuencia. (Traducción automática)

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)

Devuelve, si esta secuencia está ordenada, una secuencia que consta del prefijo más largo de elementos tomados de esta secuencia que coinciden con el predicado dado. (Traducción automática)

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(v -> v != -3).toArray();
System.out.println(Arrays.toString(ret)); // [-1, -2]

int[] toArray ()

Devuelve una matriz que contiene los elementos de esta secuencia. (Traducción automática)

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]

Methods declared in BaseStream

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

Consulte el siguiente enlace.

BaseStream con ejemplos

Ejemplos de API

Java : IntStream con ejemplos

Summary

Methods

boolean allMatch (IntPredicate predicate)

boolean anyMatch (IntPredicate predicate)

DoubleStream asDoubleStream ()

LongStream asLongStream ()

OptionalDouble average ()

Stream<Integer> boxed ()

static IntStream.Builder builder ()

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

static IntStream concat (IntStream a, IntStream b)

long count ()

IntStream distinct ()

default IntStream dropWhile (IntPredicate predicate)

static IntStream empty ()

IntStream filter (IntPredicate predicate)

OptionalInt findAny ()

OptionalInt findFirst ()

IntStream flatMap (IntFunction<? extends IntStream> mapper)

void forEach (IntConsumer action)

void forEachOrdered (IntConsumer action)

static IntStream generate (IntSupplier s)

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

static IntStream iterate (int seed, IntUnaryOperator f)

IntStream limit (long maxSize)

IntStream map (IntUnaryOperator mapper)

default IntStream mapMulti (IntStream.IntMapMultiConsumer mapper)

DoubleStream mapToDouble (IntToDoubleFunction mapper)

LongStream mapToLong (IntToLongFunction mapper)

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

OptionalInt max ()

OptionalInt min ()

boolean noneMatch (IntPredicate predicate)

static IntStream of (int t)

static IntStream of (int... values)

IntStream peek (IntConsumer action)

static IntStream range (int startInclusive, int endExclusive)

static IntStream rangeClosed (int startInclusive, int endInclusive)

int reduce (int identity, IntBinaryOperator op)

OptionalInt reduce (IntBinaryOperator op)

IntStream skip (long n)

IntStream sorted ()

int sum ()

IntSummaryStatistics summaryStatistics ()

default IntStream takeWhile (IntPredicate predicate)

int[] toArray ()

Methods declared in BaseStream

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

Related posts