#IntStream
É claro que tem a discussão de código que performar melhor, que for mais legível. São discussões úteis. Porém se no final o código rodou, não tem certo/errado. Melhorias fazem parte da proposta.

No Java, faça com if/else, com ternário, com IntStream, com Lambda Expression... Deu certo? Ótimo!
September 3, 2024 at 3:59 PM
Streams sind eine der Sachen in Java, die am Anfang ein bisschen ungewohnt aussehen, aber im Alltag extrem praktisch werden. Gerade wenn du noch...

https://magicmarcy.de/streams-in-java

#Streams #Filter #Collect #Java #ForEach #IntStream #Collectors #LongStream #DoubleStream #MapToInt #Programming
August 17, 2026 at 4:14 PM
Streams sind eine der Sachen in Java, die am Anfang ein bisschen ungewohnt aussehen, aber im Alltag extrem praktisch werden. Gerade wenn du noch...

https://magicmarcy.de/streams-in-java

#Streams #Filter #Collect #Java #ForEach #IntStream #Collectors #LongStream #DoubleStream #MapToInt #Programming
April 5, 2026 at 4:11 PM
Streams sind eine der Sachen in Java, die am Anfang ein bisschen ungewohnt aussehen, aber im Alltag extrem praktisch werden. Gerade wenn du noch...

https://magicmarcy.de/streams-in-java

#Streams #Filter #Collect #Java #ForEach #IntStream #Collectors #LongStream #DoubleStream #MapToInt #Programming
January 27, 2026 at 5:46 PM
Se fosse assim desde o início, talvez tivéssemos generics de tipos primitivos em Java. Não teríamos bizarrices como IntStream, nem tratamento especial para os 8 tipos primitivos espalhados por todo lugar na JDK e bibliotecas.
December 11, 2024 at 11:44 PM
8.7 Streams primitivos e infinitos
**Resumo: Streams primitivos e infinitos** **1. Streams Primitivos** * Objetivo: Evitar boxing/unboxing desnecessários, melhorando desempenho. Tipos disponíveis: * IntStream, LongStream, DoubleStream. Iteradores especializados: * Exemplo: PrimitiveIterator.OfInt (retorna int com nextInt(), além de next() para Integer). Métodos úteis: * range(inicio, fim): Gera sequência de números (ex: IntStream.range(0, 10)). * mapToInt, mapToLong, mapToDouble: Convertem Stream para streams primitivos. * boxed(): Converte um stream primitivo para Stream (ex: IntStream.generate(...).boxed()). **2. Streams Infinitos** Criação via Supplier: Stream.generate(Supplier): Gera elementos indefinidamente (ex: números aleatórios). IntStream.generate(() -> random.nextInt()) Stream.iterate(seed, UnaryOperator): Gera sequências com base em um valor inicial (ex: números naturais). IntStream.iterate(0, x -> x + 1) Operações de curto-circuito: * limit(n): Limita o stream a n elementos (ex: .limit(10)). * findFirst(): Retorna o primeiro elemento que atende a uma condição (ex: .filter(f -> f > 100).findFirst()). * anyMatch, allMatch, noneMatch: Interrompem o processamento assim que a condição é resolvida. **4. Cuidados e Observações** Streams infinitos exigem operações de curto-circuito: * Sem limit, findFirst ou anyMatch, operações como sum() ou collect() podem não terminar. * Exemplo perigoso: allMatch(f -> f % 2 == 0) em um stream infinito de Fibonacci (pode rodar indefinidamente). Estado em Suppliers: * Lambdas não permitem variáveis mutáveis. Para manter estado, use classes ou interfaces funcionais com atributos (ex: Fibonacci). * Estado pode limitar paralelização, pois streams paralelos processam elementos de forma não sequencial. APIs existentes: * Random.ints(): Retorna um IntStream infinito de números aleatórios. * Files.lines(), Pattern.splitAsStream(): Fontes alternativas para streams. **5. Vantagens e Aplicações** * Eficiência: Streams primitivos evitam overhead de boxing. * Flexibilidade: Streams infinitos permitem modelar sequências ilimitadas (ex: dados em tempo real, séries matemáticas). * Integração com APIs: Métodos como limit e findFirst facilitam o trabalho com grandes volumes de dados. Ver exemplos práticos: StreamPrimitivosInfinitosTest
forem.com
March 29, 2025 at 3:05 AM
Seems that `IntStream` does not implement the `gather` method (yet), but an stream of autoboxed ints does.
This works for me:

jbang --java 24 -c 'Stream.of(1,2,3,4,5).gather(Gatherers.windowFixed(2)).forEach(System.out::println);'
November 29, 2024 at 8:41 AM
¡Nuevo post en el blog! 👉
#Java #DEVCommunity
Bucle for a IntStream con iterate en Java
Serie: Refactorizando del estilo imperativo al funcional en Java
asjordi.dev
April 28, 2025 at 3:41 PM
¡Nuevo post en el blog! 👉
#Java #DEVCommunity
Cómo refactorizar bucles for a IntStream en Java
Serie: Refactorizando del estilo imperativo al funcional en Java
asjordi.dev
April 21, 2025 at 5:30 PM
In day 2 of #adventofcode you might want to splice an array and then combine it again, in #Java you can use an IntStream to seamlessly remove a single element from an array. #tipoftheday
December 2, 2024 at 1:31 PM
Really surprised that #java nio IntBuffer doesn't offer a naive IntStream stream() method.
May 12, 2026 at 9:04 PM
Interestingly, #EclipseCollections does not have an instance withAll method on MutableIntCollection that takes an IntStream, but there are ofAll/withAll methods on the IntLists factories that take an IntStream. 🤷‍♂️
February 17, 2026 at 3:50 AM
Cómo refactorizar bucles for a IntStream en Java
## Introducción Las versiones anteriores de Java admitían el paradigma orientado a objetos combinado con un estilo imperativo de programación. A partir de Java 8, se introdujo el estilo funcional de programación al código. Ambos estilos de programación tienen sus propias ventajas y desventajas, e incluso se pueden combinar dentro del mismo código. El estilo imperativo es donde decimos qué hacer y también cómo hacerlo. Mientras que el estilo funcional es declarativo por naturaleza, donde decimos qué hacer y delegamos el cómo o los detalles de implementación a la API. El código con un estilo imperativo puede ser más fácil de escribir, ya que la mayoría de nosotros estamos muy familiarizados con él. Sin embargo, el código se vuelve verboso, complejo y en ocasiones difícil de leer y mantener. Por su parte el estilo funcional puede ser difícil al principio, principalmente porque no es tan extenso su uso y enseñanza, pero en general, es más fácil de leer, comprender y modificar. Con la práctica, el estilo funcional se vuelve más fácil de entender y escribir. Este es el primer post de una serie, donde analizaremos una serie de ejemplos de código donde se usa un estilo imperativo, y lo refactorizaremos para usar un estilo funcional equivalente. ## Simple for loop Comencemos con el tradicional bucle `for` en el que realizamos una acción de acuerdo al valor de un índice en un rango determinado. for (int i = 0; i < 5; i++) { System.out.println(i); } En este bucle, la esencia es el rango de valores de `i` que va de 0 a 4. Podemos clasificar como ruido a la propia sintaxis y a la operación de incremento de `i`. Para mantener la esencia o propósito del bucle y eliminar el ruido, podemos usar un estilo funcional con `IntStream`. IntStream.range(0, 5) .forEach(i -> System.out.println(i)); El código anterior es la forma en la que podemos escribir el bucle `for` con bastante facilidad. La clave está en la sentencia **"un índice sobre un rango"**. El método `range` de `IntStream` crea un rango de valores enteros donde el primer argumento es el valor inicial y el segundo argumento es el valor final. Considerar que el valor final no está incluido en el rango. El método `forEach` sirve para iterar sobre cada elemento del rango y realizar una acción, en este caso, imprimir el valor de `i`. Podemos escribir este código de una manera más concisa, eliminando la variable `i` y usando el método `forEach` con una referencia de método. IntStream.range(0, 5) .forEach(System.out::println); De esta manera el estilo funcional se vuelve más conciso, más fácil de leer y la intención es más clara en esta versión. En caso de que el bucle `for` se ejecute hasta incluir el valor final, tal y como se muestra a continuación: for (int i = 0; i <= 5; i++) { System.out.println(i); } Podemos usar el método `rangeClosed` de `IntStream` para crear un rango de valores enteros que incluya el valor final. IntStream.rangeClosed(0, 5) .forEach(System.out::println); Tanto si se utiliza el método `range` como el método `rangeClosed`, se obtiene un flujo de valores `int` (`IntStream`) sobre los cuales podemos iterar usando el método `forEach`. En los ejemplos anteriores donde se usa un estilo funcional, el _iterador interno_ nos quita de encima la carga de la iteración. El propio flujo se encarga de recorrer el rango de valores, uno a la vez, y de esta manera solo tenemos que centrarnos en lo que se debe hacer con cada elemento, a medida que se va obteniendo dentro del método `forEach`. En los ejemplos anteriores solamente se imprime el valor proporcionado, pero se puede realizar cualquier operación, por ejemplo, guardar información en una base de datos, enviar información a un servicio web, etc. A diferencia del iterador externo que nos proporciona el bucle `for`, el código que utiliza el iterador interno es más conciso, tiene menos ruido, evita la necesidad de mutar explícitamente la variable de índice, y es más fácil de leer y modificar. En cualquier lugar que se encuentre un bucle `for` se puede utilizar el método `range` o `rangeClosed` de `IntStream` para iterar desde el valor inicial hasta el valor final, ya sea que el valor final esté incluido o no. De esta manera, se puede refactorizar el código de un estilo imperativo a un estilo funcional, asegurándose de verificar que el código funcione tal y como se espera, y que no haya efectos secundarios no deseados, en el mejor de los casos usando pruebas unitarias.
dev.to
April 21, 2025 at 1:26 PM
8.7 Streams primitivos e infinitos
**Resumo: Streams primitivos e infinitos** **1. Streams Primitivos** * Objetivo: Evitar boxing/unboxing desnecessários, melhorando desempenho. Tipos disponíveis: * IntStream, LongStream, DoubleStream. Iteradores especializados: * Exemplo: PrimitiveIterator.OfInt (retorna int com nextInt(), além de next() para Integer). Métodos úteis: * range(inicio, fim): Gera sequência de números (ex: IntStream.range(0, 10)). * mapToInt, mapToLong, mapToDouble: Convertem Stream para streams primitivos. * boxed(): Converte um stream primitivo para Stream (ex: IntStream.generate(...).boxed()). **2. Streams Infinitos** Criação via Supplier: Stream.generate(Supplier): Gera elementos indefinidamente (ex: números aleatórios). IntStream.generate(() -> random.nextInt()) Stream.iterate(seed, UnaryOperator): Gera sequências com base em um valor inicial (ex: números naturais). IntStream.iterate(0, x -> x + 1) Operações de curto-circuito: * limit(n): Limita o stream a n elementos (ex: .limit(10)). * findFirst(): Retorna o primeiro elemento que atende a uma condição (ex: .filter(f -> f > 100).findFirst()). * anyMatch, allMatch, noneMatch: Interrompem o processamento assim que a condição é resolvida. **4. Cuidados e Observações** Streams infinitos exigem operações de curto-circuito: * Sem limit, findFirst ou anyMatch, operações como sum() ou collect() podem não terminar. * Exemplo perigoso: allMatch(f -> f % 2 == 0) em um stream infinito de Fibonacci (pode rodar indefinidamente). Estado em Suppliers: * Lambdas não permitem variáveis mutáveis. Para manter estado, use classes ou interfaces funcionais com atributos (ex: Fibonacci). * Estado pode limitar paralelização, pois streams paralelos processam elementos de forma não sequencial. APIs existentes: * Random.ints(): Retorna um IntStream infinito de números aleatórios. * Files.lines(), Pattern.splitAsStream(): Fontes alternativas para streams. **5. Vantagens e Aplicações** * Eficiência: Streams primitivos evitam overhead de boxing. * Flexibilidade: Streams infinitos permitem modelar sequências ilimitadas (ex: dados em tempo real, séries matemáticas). * Integração com APIs: Métodos como limit e findFirst facilitam o trabalho com grandes volumes de dados. Ver exemplos práticos: StreamPrimitivosInfinitosTest
dev.to
March 29, 2025 at 3:04 AM