DoubleStream (Java SE 21 & JDK 21) en Java con ejemplos.
Encontrará ejemplos de código en la mayoría de los métodos de DoubleStream.
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 doble valor que soportan operaciones agregadas secuenciales y paralelas. Esta es la doble especialización primitiva de Stream. (Traducción automática)
final var stream = DoubleStream.of(0.1, 0.2, 0.3);
System.out.println("-- forEach --");
stream.forEach(v -> {
System.out.println(v);
});
// Result
// ↓
//-- forEach --
//0.1
//0.2
//0.3
final var stream = DoubleStream.of(0.1, 0.2, 0.3);
final var ret = stream.map(v -> v * 2.0).toArray();
System.out.println(Arrays.toString(ret)); // [0.2, 0.4, 0.6]
Methods
boolean allMatch (DoublePredicate predicate)
Devuelve si todos los elementos de esta secuencia coinciden con el predicado proporcionado. (Traducción automática)
final var predicate = new DoublePredicate() {
@Override
public boolean test(double value) {
// Check if the number is negative.
return value < 0.0;
}
};
{
final var stream = DoubleStream.of(-0.1, -0.2, -0.3);
final var ret = stream.allMatch(predicate);
System.out.println(ret); // true
}
{
final var stream = DoubleStream.of(1.0, -2.0, 3.0, -4.0);
final var ret = stream.allMatch(predicate);
System.out.println(ret); // false
}
boolean anyMatch (DoublePredicate predicate)
Devuelve si algún elemento de esta secuencia coincide con el predicado proporcionado. (Traducción automática)
final var predicate = new DoublePredicate() {
@Override
public boolean test(double value) {
// Check if the number is negative.
return value < 0.0;
}
};
{
final var stream = DoubleStream.of(-0.1, -0.2, -0.3);
final var ret = stream.anyMatch(predicate);
System.out.println(ret); // true
}
{
final var stream = DoubleStream.of(0.1, -0.2, 0.3);
final var ret = stream.anyMatch(predicate);
System.out.println(ret); // true
}
{
final var stream = DoubleStream.of(0.1, 0.2, 0.3);
final var ret = stream.anyMatch(predicate);
System.out.println(ret); // false
}
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 = DoubleStream.of(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);
final var opt = stream.average();
opt.ifPresent(value -> {
System.out.println(value); // 3.5
});
final var opt = DoubleStream.empty().average();
System.out.println(opt.isEmpty()); // true
Stream<Double> boxed ()
Devuelve una secuencia que consta de los elementos de esta secuencia, encuadrados en Doble. (Traducción automática)
final Stream<Double> stream = DoubleStream.of(0.1, 0.2, 0.3).boxed();
final var ret = stream.toList();
System.out.println(ret); // [0.1, 0.2, 0.3]
static DoubleStream.Builder builder ()
Devuelve un constructor para DoubleStream. (Traducción automática)
final var builder = DoubleStream.builder();
builder.add(0.1).add(0.2).add(0.3);
final var stream = builder.build();
final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0.1, 0.2, 0.3]
<R> R collect (Supplier<R> supplier, ObjDoubleConsumer<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 ObjDoubleConsumer<List<String>>() {
@Override
public void accept(List<String> list, double value) {
System.out.println("-- accumulator --");
System.out.println(" list = " + list);
System.out.println(" value = " + value);
list.add("%.2e".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 = DoubleStream.of(0.1, 0.2, 0.3);
final var ret = stream.collect(supplier, accumulator, combiner);
System.out.println("collect = " + ret);
// Result
// ↓
//-- supplier --
//-- accumulator --
// list = []
// value = 0.1
//-- accumulator --
// list = [1.00e-01]
// value = 0.2
//-- accumulator --
// list = [1.00e-01, 2.00e-01]
// value = 0.3
//collect = [1.00e-01, 2.00e-01, 3.00e-01]
}
{
final var parallelStream = DoubleStream.of(0.1, 0.2, 0.3).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 = 0.2
//-- supplier --
//-- accumulator --
// list = []
// value = 0.3
//-- supplier --
//-- accumulator --
// list = []
// value = 0.1
//-- combiner --
// list1 = [2.00e-01]
// list2 = [3.00e-01]
//-- combiner --
// list1 = [1.00e-01]
// list2 = [2.00e-01, 3.00e-01]
//collect = [1.00e-01, 2.00e-01, 3.00e-01]
}
static DoubleStream concat (DoubleStream a, DoubleStream 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 = DoubleStream.of(0.1, 0.2, 0.3);
final var stream2 = DoubleStream.of(7.0, 8.0, 9.0);
System.out.println(stream1.isParallel()); // false
System.out.println(stream2.isParallel()); // false
final var concatStream = DoubleStream.concat(stream1, stream2);
System.out.println(concatStream.isParallel()); // false
final var ret = concatStream.toArray();
System.out.println(Arrays.toString(ret)); // [0.1, 0.2, 0.3, 7.0, 8.0, 9.0]
final var stream1 = DoubleStream.of(0.1, 0.2, 0.3).parallel();
final var stream2 = DoubleStream.of(7.0, 8.0, 9.0).parallel();
System.out.println(stream1.isParallel()); // true
System.out.println(stream2.isParallel()); // true
final var concatStream = DoubleStream.concat(stream1, stream2);
System.out.println(concatStream.isParallel()); // true
final var ret = concatStream.toArray();
System.out.println(Arrays.toString(ret)); // [0.1, 0.2, 0.3, 7.0, 8.0, 9.0]
long count ()
Devuelve el recuento de elementos de esta secuencia. (Traducción automática)
final var stream = DoubleStream.of(0.1, 0.2, 0.3, 0.4);
System.out.println(stream.count()); // 4
final var stream = DoubleStream.empty();
System.out.println(stream.count()); // 0
DoubleStream distinct ()
Devuelve una secuencia que consta de los distintos elementos de esta secuencia. (Traducción automática)
final var stream = DoubleStream.of(1.0, 2.0, 2.0, 3.0, 3.0, 3.0);
final var ret = stream.distinct().toArray();
System.out.println(Arrays.toString(ret)); // [1.0, 2.0, 3.0]
default DoubleStream dropWhile (DoublePredicate 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 = DoubleStream.of(1.0, 2.0, Double.NaN, 4.0, 5.0);
final var predicate = new DoublePredicate() {
@Override
public boolean test(double value) {
return !Double.isNaN(value);
}
};
final var ret = stream.dropWhile(predicate).toArray();
System.out.println(Arrays.toString(ret)); // [NaN, 4.0, 5.0]
final var stream = DoubleStream.of(-1.0, -2.0, -3.0, Double.NaN, -5.0);
final var ret = stream.dropWhile(v -> !Double.isNaN(v)).toArray();
System.out.println(Arrays.toString(ret)); // [NaN, -5.0]
static DoubleStream empty ()
Devuelve un DoubleStream secuencial vacío. (Traducción automática)
final var stream = DoubleStream.empty();
System.out.println(stream.count()); // 0
final var stream = DoubleStream.empty();
final var array = stream.toArray();
System.out.println(Arrays.toString(array)); // []
DoubleStream filter (DoublePredicate 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 = DoubleStream.of(0.1, -0.2, 0.3, -0.4);
final var predicate = new DoublePredicate() {
@Override
public boolean test(double value) {
// Check if the number is negative.
return value < 0.0;
}
};
final var ret = stream.filter(predicate).toArray();
System.out.println(Arrays.toString(ret)); // [-0.2, -0.4]
final var stream = DoubleStream.of(0.1, -0.2, 0.3, -0.4);
final var ret = stream.filter(v -> v > 0.0).toArray();
System.out.println(Arrays.toString(ret)); // [0.1, 0.3]
OptionalDouble findAny ()
Devuelve un OptionalDouble que describe algún elemento de la secuencia, o un OptionalDouble 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 = DoubleStream.of(1.0, 2.0, 3.0).parallel();
System.out.println(stream.isParallel()); // true
// 1.0 or 2.0 or 3.0
final var opt = stream.findAny();
if (opt.isEmpty()) {
throw new IllegalStateException();
}
final var value = Math.round(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 : 35
//count2 : 963
//count3 : 2
final var stream = DoubleStream.empty();
final var opt = stream.findAny();
System.out.println(opt.isEmpty()); // true
OptionalDouble findFirst ()
Devuelve un OptionalDouble que describe el primer elemento de esta secuencia, o un OptionalDouble vacío si la secuencia está vacía. (Traducción automática)
final var stream = DoubleStream.of(1.0, 2.0, 3.0);
final var opt = stream.findFirst();
opt.ifPresent(value -> {
System.out.println(value); // 1.0
});
// parallel
final var stream = DoubleStream.of(1.0, 2.0, 3.0).parallel();
System.out.println(stream.isParallel()); // true
final var opt = stream.findFirst();
opt.ifPresent(value -> {
System.out.println(value); // 1.0
});
int count1 = 0;
int count2 = 0;
int count3 = 0;
for (int i = 0; i < 1000; i++) {
// unordered and parallel
final var stream = DoubleStream.of(1.0, 2.0, 3.0).unordered().parallel();
// 1 or 2 or 3
final var opt = stream.findFirst();
if (opt.isEmpty()) {
throw new IllegalStateException();
}
final var value = Math.round(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 : 79
//count2 : 919
//count3 : 2
final var stream = DoubleStream.empty();
final var opt = stream.findFirst();
System.out.println(opt.isEmpty()); // true
DoubleStream flatMap (DoubleFunction<? extends DoubleStream> 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 = DoubleStream.of(1.0, 2.0, 3.0);
final var mapper = new DoubleFunction<DoubleStream>() {
@Override
public DoubleStream apply(double value) {
return DoubleStream.of(value, value + 0.1, value + 0.2);
}
};
final var ret = stream.flatMap(mapper).toArray();
// [1.0, 1.1, 1.2, 2.0, 2.1, 2.2, 3.0, 3.1, 3.2]
System.out.println(Arrays.toString(ret));
void forEach (DoubleConsumer action)
Realiza una acción para cada elemento de esta secuencia. (Traducción automática)
Please see also : forEachOrdered(DoubleConsumer action)
final var stream = DoubleStream.of(0.1, 0.2, 0.3);
final var action = new DoubleConsumer() {
@Override
public void accept(double value) {
System.out.println(value);
}
};
System.out.println("-- forEach --");
stream.forEach(action);
// Result
// ↓
//-- forEach --
//0.1
//0.2
//0.3
// An example with a lambda expression.
final var stream = DoubleStream.of(-0.1, -0.2, -0.3);
System.out.println("-- forEach --");
stream.forEach(v -> {
System.out.println(v);
});
// Result
// ↓
//-- forEach --
//-0.1
//-0.2
//-0.3
final var stream = DoubleStream.of(0.1, 0.2, 0.3, 0.4, 0.5).parallel();
System.out.println(stream.isParallel()); // true
System.out.println("-- forEach --");
stream.forEach(v -> {
System.out.println(v);
});
// Result
// ↓
//-- forEach --
//0.3
//0.2
//0.1
//0.5
//0.4
void forEachOrdered (DoubleConsumer 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 = DoubleStream.of(0.1, 0.2, 0.3);
final var action = new DoubleConsumer() {
@Override
public void accept(double value) {
System.out.println(value);
}
};
System.out.println("-- forEach --");
stream.forEachOrdered(action);
// Result
// ↓
//-- forEach --
//0.1
//0.2
//0.3
final var stream = DoubleStream.of(0.1, 0.2, 0.3, 0.4, 0.5).parallel();
System.out.println(stream.isParallel()); // true
System.out.println("-- forEach --");
stream.forEachOrdered(v -> {
System.out.println(v);
});
// Result
// ↓
//-- forEach --
//0.1
//0.2
//0.3
//0.4
//0.5
static DoubleStream generate (DoubleSupplier s)
Devuelve un flujo secuencial infinito y desordenado donde cada elemento es generado por el DoubleSupplier proporcionado. (Traducción automática)
final var supplier = new DoubleSupplier() {
double count;
@Override
public double getAsDouble() {
count += 10.0;
return count;
}
};
final var stream = DoubleStream.generate(supplier);
final var ret = stream.limit(5).toArray();
System.out.println(Arrays.toString(ret)); // [10.0, 20.0, 30.0, 40.0, 50.0]
static DoubleStream iterate (double seed, DoublePredicate hasNext, DoubleUnaryOperator next)
Devuelve un DoubleStream 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 DoublePredicate() {
@Override
public boolean test(double value) {
return value <= 100.0;
}
};
final var next = new DoubleUnaryOperator() {
@Override
public double applyAsDouble(double operand) {
return operand * 2.0;
}
};
final var stream = DoubleStream.iterate(1.0, hasNext, next);
final var ret = stream.toArray();
// [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0]
System.out.println(Arrays.toString(ret));
static DoubleStream iterate (double seed, DoubleUnaryOperator f)
Devuelve un DoubleStream 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 DoubleUnaryOperator() {
@Override
public double applyAsDouble(double operand) {
return operand * 2.0;
}
};
final var stream = DoubleStream.iterate(1.0, next);
final var ret = stream.limit(10).toArray();
// [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0, 512.0]
System.out.println(Arrays.toString(ret));
DoubleStream 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 = DoubleStream.of(0.1, 0.2, 0.3, 0.4, 0.5);
final var ret = stream.limit(3).toArray();
System.out.println(Arrays.toString(ret)); // [0.1, 0.2, 0.3]
DoubleStream map (DoubleUnaryOperator 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 = DoubleStream.of(0.1, 0.2, 0.3);
final var mapper = new DoubleUnaryOperator() {
@Override
public double applyAsDouble(double operand) {
return operand * 2.0;
}
};
final var ret = stream.map(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [0.2, 0.4, 0.6]
final var stream = DoubleStream.of(1.0, 2.0, 3.0);
final var ret = stream.map(v -> v * 1.5).toArray();
System.out.println(Arrays.toString(ret)); // [1.5, 3.0, 4.5]
default DoubleStream mapMulti (DoubleStream.DoubleMapMultiConsumer 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 = DoubleStream.of(1.0, 2.0, 3.0);
final var mapper = new DoubleStream.DoubleMapMultiConsumer() {
@Override
public void accept(double value, DoubleConsumer dc) {
dc.accept(value);
dc.accept(value + 0.1);
dc.accept(value + 0.2);
}
};
final var ret = stream.mapMulti(mapper).toArray();
// [1.0, 1.1, 1.2, 2.0, 2.1, 2.2, 3.0, 3.1, 3.2]
System.out.println(Arrays.toString(ret));
IntStream mapToInt (DoubleToIntFunction 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 = DoubleStream.of(1.1, 2.2, 3.3);
final var mapper = new DoubleToIntFunction() {
@Override
public int applyAsInt(double value) {
final var rounded = Math.round(value);
return Math.toIntExact(rounded);
}
};
final var ret = stream.mapToInt(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [1, 2, 3]
LongStream mapToLong (DoubleToLongFunction 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 = DoubleStream.of(1.0e10, 2.0e10);
final var mapper = new DoubleToLongFunction() {
@Override
public long applyAsLong(double value) {
return Math.round(value);
}
};
final var ret = stream.mapToLong(mapper).toArray();
System.out.println(Arrays.toString(ret)); // [10000000000, 20000000000]
<U> Stream<U> mapToObj (DoubleFunction<? 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 = DoubleStream.of(0.1, 0.2, 0.3);
final var mapper = new DoubleFunction<String>() {
@Override
public String apply(double value) {
return "num=" + value;
}
};
final var ret = stream.mapToObj(mapper).toList();
System.out.println(ret); // [num=0.1, num=0.2, num=0.3]
OptionalDouble max ()
Devuelve un OptionalDouble que describe el elemento máximo de esta secuencia, o un OptionalDouble vacío si esta secuencia está vacía. (Traducción automática)
final var stream = DoubleStream.of(7.0, 99.0, 0.1, 5.0);
final var opt = stream.max();
opt.ifPresent(value -> {
System.out.println(value); // 99.0
});
final var stream = DoubleStream.empty();
final var opt = stream.max();
System.out.println(opt.isEmpty()); // true
OptionalDouble min ()
Devuelve un OptionalDouble que describe el elemento mínimo de esta secuencia, o un OptionalDouble vacío si esta secuencia está vacía. (Traducción automática)
final var stream = DoubleStream.of(7.0, 99.0, 0.1, 5.0);
final var opt = stream.min();
opt.ifPresent(value -> {
System.out.println(value); // 0.1
});
final var stream = DoubleStream.empty();
final var opt = stream.min();
System.out.println(opt.isEmpty()); // true
boolean noneMatch (DoublePredicate predicate)
Devuelve si ningún elemento de esta secuencia coincide con el predicado proporcionado. (Traducción automática)
final var predicate = new DoublePredicate() {
@Override
public boolean test(double value) {
// Check if the number is negative.
return value < 0.0;
}
};
{
final var stream = DoubleStream.of(-0.1, -0.2, -0.3);
final var ret = stream.noneMatch(predicate);
System.out.println(ret); // false
}
{
final var stream = DoubleStream.of(0.1, -0.2, 0.3);
final var ret = stream.noneMatch(predicate);
System.out.println(ret); // false
}
{
final var stream = DoubleStream.of(0.1, 0.2, 0.3);
final var ret = stream.noneMatch(predicate);
System.out.println(ret); // true
}
static DoubleStream of (double t)
Devuelve un DoubleStream secuencial que contiene un solo elemento. (Traducción automática)
final var stream = DoubleStream.of(0.0);
final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0.0]
final var stream = DoubleStream.of(1.23);
final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [1.23]
static DoubleStream of (double... values)
Devuelve una secuencia ordenada secuencial cuyos elementos son los valores especificados. (Traducción automática)
final var stream = DoubleStream.of(0.1, 0.2, 0.3);
final var ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0.1, 0.2, 0.3]
DoubleStream peek (DoubleConsumer 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 = DoubleStream.of(0.1, 0.2, 0.3);
final var action = new DoubleConsumer() {
@Override
public void accept(double value) {
System.out.println("peek : value = " + value);
}
};
final var array = stream.peek(action).toArray();
System.out.println("array = " + Arrays.toString(array));
// Result
// ↓
//peek : value = 0.1
//peek : value = 0.2
//peek : value = 0.3
//array = [0.1, 0.2, 0.3]
double reduce (double identity, DoubleBinaryOperator 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 = DoubleStream.of(1.0, 2.0, 3.0, 4.0);
final var identity = 0.0;
final var op = new DoubleBinaryOperator() {
@Override
public double applyAsDouble(double left, double right) {
if (identity == left) {
return right;
}
return left + right;
}
};
// 1.0 + 2.0 + 3.0 + 4.0 = 10.0
final var ret = stream.reduce(identity, op);
System.out.println(ret); // 10.0
final var stream = DoubleStream.empty();
final var identity = 0.0;
final var ret = stream.reduce(identity, (left, right) -> {
if (identity == left) {
return right;
}
return left + right;
});
System.out.println(ret); // 0.0
OptionalDouble reduce (DoubleBinaryOperator op)
Realiza una reducción de los elementos de esta secuencia, utilizando una función de acumulación asociativa, y devuelve un OptionalDouble que describe el valor reducido, si lo hay. (Traducción automática)
final var stream = DoubleStream.of(1.0, 2.0, 3.0, 4.0);
final var op = new DoubleBinaryOperator() {
@Override
public double applyAsDouble(double left, double right) {
return left + right;
}
};
// 1.0 + 2.0 + 3.0 + 4.0 = 10.0
final var opt = stream.reduce(op);
opt.ifPresent(value -> {
System.out.println(value); // 10.0
});
final var stream = DoubleStream.empty();
final var opt = stream.reduce((left, right) -> left + right);
System.out.println(opt.isEmpty()); // true
DoubleStream 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 = DoubleStream.of(0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7);
final var ret = stream.skip(4).toArray();
System.out.println(Arrays.toString(ret)); // [0.5, 0.6, 0.7]
DoubleStream sorted ()
Devuelve una secuencia que consta de los elementos de esta secuencia en orden. (Traducción automática)
final var stream = DoubleStream.of(0.2, 0.5, 0.4, 0.1, 0.3);
final var ret = stream.sorted().toArray();
System.out.println(Arrays.toString(ret)); // [0.1, 0.2, 0.3, 0.4, 0.5]
final var stream = DoubleStream.of(0.2, 0.5, 0.4, 0.1, 0.3).parallel();
System.out.println(stream.isParallel()); // true
final var ret = stream.sorted().toArray();
System.out.println(Arrays.toString(ret)); // [0.1, 0.2, 0.3, 0.4, 0.5]
double sum ()
Devuelve la suma de elementos de esta secuencia. (Traducción automática)
final var stream = DoubleStream.of(1.0, 2.0, 3.0, 4.0, 5.0);
System.out.println(stream.sum()); // 15.0
final var stream = DoubleStream.of(-0.1, -0.2, -0.3);
System.out.println(stream.sum()); // -0.6
DoubleSummaryStatistics summaryStatistics ()
Devuelve DoubleSummaryStatistics que describe varios datos resumidos sobre los elementos de esta secuencia. (Traducción automática)
final var stream = DoubleStream.of(0.1, 0.2, 0.3, 0.4, 0.5);
final var ret = stream.summaryStatistics();
// DoubleSummaryStatistics{count=5, sum=1.500000, min=0.100000, average=0.300000, max=0.500000}
System.out.println(ret);
default DoubleStream takeWhile (DoublePredicate 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 = DoubleStream.of(1.0, 2.0, 3.0, Double.NaN, 5.0);
final var predicate = new DoublePredicate() {
@Override
public boolean test(double value) {
return !Double.isNaN(value);
}
};
final var ret = stream.takeWhile(predicate).toArray();
System.out.println(Arrays.toString(ret)); // [1.0, 2.0, 3.0]
final var stream = DoubleStream.of(-1.0, -2.0, Double.NaN, -4.0, -5.0);
final var ret = stream.takeWhile(v -> !Double.isNaN(v)).toArray();
System.out.println(Arrays.toString(ret)); // [-1.0, -2.0]
double[] toArray ()
Devuelve una matriz que contiene los elementos de esta secuencia. (Traducción automática)
final var stream = DoubleStream.of(0.1, 0.2, 0.3);
final double[] ret = stream.toArray();
System.out.println(Arrays.toString(ret)); // [0.1, 0.2, 0.3]
Methods declared in BaseStream
close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered
Consulte el siguiente enlace.
Related posts
- Ejemplos de API