Java : LongStream con ejemplos

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

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 de valor largo que soportan operaciones agregadas secuenciales y paralelas. Esta es la larga y primitiva especialización de Stream. (Traducción automática)

Class diagram

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

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

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

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

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

Methods

boolean allMatch (LongPredicate predicate)

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

final var predicate = new LongPredicate() {
    @Override
    public boolean test(long value) {
        // Check if the number is even.
        return value % 2 == 0;
    }
};

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

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

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

boolean anyMatch (LongPredicate predicate)

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

final var predicate = new LongPredicate() {
    @Override
    public boolean test(long value) {
        // Check if the number is even.
        return value % 2 == 0;
    }
};

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

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

    final var ret = stream.anyMatch(predicate);
    System.out.println(ret); // true
}
{
    final var stream = LongStream.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 = LongStream.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]

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 = LongStream.of(1, 2, 3, 4, 5, 6);

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

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

Stream<Long> boxed ()

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

final Stream<Long> stream = LongStream.range(0, 5).boxed();

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

static LongStream.Builder builder ()

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

final var builder = LongStream.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, ObjLongConsumer<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 ObjLongConsumer<List<String>>() {
    @Override
    public void accept(List<String> list, long 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 = LongStream.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 = LongStream.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 LongStream concat (LongStream a, LongStream 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 = LongStream.of(1, 2, 3);
final var stream2 = LongStream.of(100, 200, 300);

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

final var concatStream = LongStream.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 = LongStream.of(1, 2, 3).parallel();
final var stream2 = LongStream.of(100, 200, 300).parallel();

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

final var concatStream = LongStream.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 = LongStream.of(0, 2, 4, 6);
System.out.println(stream.count()); // 4

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

LongStream distinct ()

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

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

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

default LongStream dropWhile (LongPredicate 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 = LongStream.of(1, 2, 3, 4, 5);

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

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

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

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

static LongStream empty ()

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

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

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

LongStream filter (LongPredicate 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 = LongStream.of(0, 1, 2, 3, 4, 5);

final var predicate = new LongPredicate() {
    @Override
    public boolean test(long 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 = LongStream.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]

OptionalLong findAny ()

Devuelve un OptionalLong que describe algún elemento de la secuencia, o un OptionalLong 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 = LongStream.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();
    }

    final var value = opt.orElseThrow();
    if (value == 1) {
        count1++;
    } else if (value == 2) {
        count2++;
    } else if (value == 3) {
        count3++;
    }
}

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

// Result
// ↓
//count1 : 77
//count2 : 918
//count3 : 5

final var stream = LongStream.empty();

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

OptionalLong findFirst ()

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

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

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

// parallel
final var stream = LongStream.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 = LongStream.of(1, 2, 3).unordered().parallel();

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

    final var value = opt.orElseThrow();
    if (value == 1) {
        count1++;
    } else if (value == 2) {
        count2++;
    } else if (value == 3) {
        count3++;
    }
}

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

// Result
// ↓
//count1 : 162
//count2 : 834
//count3 : 4

final var stream = LongStream.empty();

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

LongStream flatMap (LongFunction<? extends LongStream> 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 = LongStream.of(100, 200, 300);

final var mapper = new LongFunction<LongStream>() {
    @Override
    public LongStream apply(long value) {
        return LongStream.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 (LongConsumer action)

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

Please see also : forEachOrdered(LongConsumer action)

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

final var action = new LongConsumer() {
    @Override
    public void accept(long 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 = LongStream.of(-10, -20, -30);

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

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

final var stream = LongStream.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 (LongConsumer 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 = LongStream.of(10, 20, 30);

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

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

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

final var stream = LongStream.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 LongStream generate (LongSupplier s)

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

final var supplier = new LongSupplier() {
    long count = 0;

    @Override
    public long getAsLong() {
        count += 10;
        return count;
    }
};

final var stream = LongStream.generate(supplier);

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

static LongStream iterate (long seed, LongPredicate hasNext, LongUnaryOperator next)

Devuelve un LongStream secuencial ordenado 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 LongPredicate() {
    @Override
    public boolean test(long value) {
        return value <= 100;
    }
};

final var next = new LongUnaryOperator() {
    @Override
    public long applyAsLong(long operand) {
        return operand * 2;
    }
};

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

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

static LongStream iterate (long seed, LongUnaryOperator f)

Devuelve un LongStream 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 LongUnaryOperator() {
    @Override
    public long applyAsLong(long operand) {
        return operand * 2;
    }
};

final var stream = LongStream.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));

LongStream 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 = LongStream.of(10, 20, 30, 40, 50, 60);

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

LongStream map (LongUnaryOperator 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 = LongStream.of(1, 2, 3);

final var mapper = new LongUnaryOperator() {
    @Override
    public long applyAsLong(long operand) {
        return operand * 2;
    }
};

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

final var stream = LongStream.range(0, 4);

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

default LongStream mapMulti (LongStream.LongMapMultiConsumer 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 = LongStream.of(100, 200, 300);

final var mapper = new LongStream.LongMapMultiConsumer() {
    @Override
    public void accept(long value, LongConsumer lc) {
        lc.accept(value);
        lc.accept(value + 1);
        lc.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 (LongToDoubleFunction 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 = LongStream.of(100, 125, 200);

final var mapper = new LongToDoubleFunction() {
    @Override
    public double applyAsDouble(long 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 (LongToIntFunction mapper)

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

final var stream = LongStream.of(10000000000L, 20000000000L, 30000000000L);

final var mapper = new LongToIntFunction() {
    @Override
    public int applyAsInt(long value) {
        return Math.toIntExact(value / 1000000000);
    }
};

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

<U> Stream<U> mapToObj (LongFunction<? 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 = LongStream.of(1, 2, 3);

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

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

OptionalLong max ()

Devuelve un OptionalLong 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 = LongStream.of(10, 5, 100, 30);

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

final var stream = LongStream.empty();

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

OptionalLong min ()

Devuelve un OptionalLong 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 = LongStream.of(10, 5, 100, 30);

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

final var stream = LongStream.empty();

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

boolean noneMatch (LongPredicate predicate)

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

final var predicate = new LongPredicate() {
    @Override
    public boolean test(long value) {
        // Check if the number is even.
        return value % 2 == 0;
    }
};

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

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

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

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

static LongStream of (long t)

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

final var stream = LongStream.of(0);

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

final var stream = LongStream.of(123456789000L);

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

static LongStream of (long... values)

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

final var stream = LongStream.of(10000000000L, 20000000000L, 30000000000L);
final var ret = stream.toArray();

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

LongStream peek (LongConsumer 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 = LongStream.of(10, 20, 30);

final var action = new LongConsumer() {
    @Override
    public void accept(long 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 LongStream range (long startInclusive, long endExclusive)

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

final var stream = LongStream.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 = LongStream.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 LongStream rangeClosed (long startInclusive, long endInclusive)

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

final var stream = LongStream.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 = LongStream.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));

long reduce (long identity, LongBinaryOperator 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 = LongStream.of(1, 2, 3, 4);
final long identity = 0;

final var op = new LongBinaryOperator() {
    @Override
    public long applyAsLong(long left, long 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 = LongStream.empty();
final long identity = 0;

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

    return left + right;
});

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

OptionalLong reduce (LongBinaryOperator op)

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

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

final var op = new LongBinaryOperator() {
    @Override
    public long applyAsLong(long left, long 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 = LongStream.empty();

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

LongStream 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 = LongStream.of(10, 20, 30, 40, 50, 60, 70);

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

LongStream sorted ()

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

final var stream = LongStream.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 = LongStream.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]

long sum ()

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

final var stream = LongStream.of(1, 2, 3, 4, 5);
System.out.println(stream.sum()); // 15

final var stream = LongStream.of(-10, -20, -30);
System.out.println(stream.sum()); // -60

LongSummaryStatistics summaryStatistics ()

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

final var stream = LongStream.of(1, 2, 3, 4, 5);
final var ret = stream.summaryStatistics();

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

default LongStream takeWhile (LongPredicate 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 = LongStream.of(1, 2, 3, 4, 5);

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

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

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

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

long[] toArray ()

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

final var stream = LongStream.of(1, 2, 3, 4, 5);
final long[] 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 : LongStream con ejemplos

Summary

Methods

boolean allMatch (LongPredicate predicate)

boolean anyMatch (LongPredicate predicate)

DoubleStream asDoubleStream ()

OptionalDouble average ()

Stream<Long> boxed ()

static LongStream.Builder builder ()

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

static LongStream concat (LongStream a, LongStream b)

long count ()

LongStream distinct ()

default LongStream dropWhile (LongPredicate predicate)

static LongStream empty ()

LongStream filter (LongPredicate predicate)

OptionalLong findAny ()

OptionalLong findFirst ()

LongStream flatMap (LongFunction<? extends LongStream> mapper)

void forEach (LongConsumer action)

void forEachOrdered (LongConsumer action)

static LongStream generate (LongSupplier s)

static LongStream iterate (long seed, LongPredicate hasNext, LongUnaryOperator next)

static LongStream iterate (long seed, LongUnaryOperator f)

LongStream limit (long maxSize)

LongStream map (LongUnaryOperator mapper)

default LongStream mapMulti (LongStream.LongMapMultiConsumer mapper)

DoubleStream mapToDouble (LongToDoubleFunction mapper)

IntStream mapToInt (LongToIntFunction mapper)

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

OptionalLong max ()

OptionalLong min ()

boolean noneMatch (LongPredicate predicate)

static LongStream of (long t)

static LongStream of (long... values)

LongStream peek (LongConsumer action)

static LongStream range (long startInclusive, long endExclusive)

static LongStream rangeClosed (long startInclusive, long endInclusive)

long reduce (long identity, LongBinaryOperator op)

OptionalLong reduce (LongBinaryOperator op)

LongStream skip (long n)

LongStream sorted ()

long sum ()

LongSummaryStatistics summaryStatistics ()

default LongStream takeWhile (LongPredicate predicate)

long[] toArray ()

Methods declared in BaseStream

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

Related posts