IntStream de() en Java

IntStream de (int t)

IntStream of(int t) devuelve un IntStream secuencial que contiene un solo elemento. 
Sintaxis: 
 

static IntStream of(int t)

Parámetros: 
 

1. IntStream: una secuencia de elementos primitivos de valor int.
2. t : Representa el elemento único en IntStream.

Valor devuelto: IntStream of(int t) devuelve un IntStream secuencial que contiene el único elemento especificado.
Ejemplo : 
 

// Java code for IntStream of(int t)
// to get a sequential IntStream
// containing a single element.
import java.util.*;
import java.util.stream.IntStream;
 
class GFG {
 
    // Driver code
    public static void main(String[] args)
    {
        // Creating an IntStream having single element only
        IntStream stream = IntStream.of(-7);
 
        // Displaying the IntStream having single element
        stream.forEach(System.out::println);
    }
}

Producción : 
 

-7

IntStream de (int… valores)

IntStream of(int… valores) devuelve un flujo ordenado secuencial cuyos elementos son los valores especificados. 
Sintaxis: 
 

static IntStream of(int... values)

Parámetros: 
 

1. IntStream: una secuencia de elementos primitivos de valor int.
2. valores : representa los elementos de la nueva secuencia.

Valor devuelto: IntStream of(int… valores) devuelve un flujo ordenado secuencial cuyos elementos son los valores especificados.
Ejemplo 1 : 
 

// Java code for IntStream of(int... values)
// to get a sequential ordered stream whose
// elements are the specified values.
import java.util.*;
import java.util.stream.IntStream;
 
class GFG {
 
    // Driver code
    public static void main(String[] args)
    {
        // Creating an IntStream
        IntStream stream = IntStream.of(-7, -9, -11);
 
        // Displaying the sequential ordered stream
        stream.forEach(System.out::println);
    }
}

Producción : 
 

-7
-9
-11

Ejemplo 2: 
 

// Java code for IntStream of(int... values)
// to get a sequential ordered stream whose
// elements are the specified values.
import java.util.*;
import java.util.stream.IntStream;
 
class GFG {
 
    // Driver code
    public static void main(String[] args)
    {
        // Creating an IntStream
        IntStream stream = IntStream.of(-7, -9, -11);
 
        // Storing the count of elements in IntStream
        long total = stream.count();
 
        // Displaying the count of elements
        System.out.println(total);
    }
}

Producción : 
 

3

 Ejemplo 3

Las secuencias no son reutilizables si hemos realizado una operación de terminal en la secuencia e intentamos reutilizarlas nuevamente. Se generará  IllegalStateExeception

import java.util.stream.IntStream;
import java.io.PrintStream;
class GFG{
    static final PrintStream out=System.out;
    public static void main(String $[]){
        IntStream intStream=IntStream.of(10,20,30);
        out.println(intStream.min());
        try{
            out.println(intStream.min());//Trying to use a stream that has been closed previously
        }catch(IllegalStateException e){
            out.println(e);
        }
    }
}

Producción :

OptionalInt[10]

java.lang.IllegalStateException: stream has already been operated upon or closed

Para reutilizar una transmisión, necesitamos la clase Proveedor cuando se llama al método get() del Proveedor cada vez que generará una nueva instancia y la devolverá.

import java.util.stream.IntStream;
import java.io.PrintStream;
import java.util.function.Supplier;
import java.util.List;
import java.util.stream.Collectors;
public class IntStreamClass{
    static final PrintStream out=System.out;
    public static void main(String $[]){
        //Reusing a stream
        Supplier<IntStream>supplier=()->IntStream.of(343,434,61,1,512,
                                                     5234,613434,561);
        //supplier.get() will return an instance of IntStream
        //sorting -> printing each value
        supplier.get()
            .sorted()
            .forEach(System.out::println);
        out.println();
       
        //filtering even numbers -> sorting -> printing each value
        supplier.get()
            .filter(x->x%2==0)
            .sorted()
            .forEach(System.out::println);
        out.println();
         
      //filtering odd numbers -> boxing(converting to Integer) -> converted to List<Integer> -> streaming -> sorting in reverse order
        //-> printing each value
        supplier.get()
            .filter(x->(x&1)==0)
            .boxed()
            .collect(Collectors.toList())
            .stream()
            .sorted((a,b)->b-a)
            .forEach(System.out::println);
    }
}

Producción :

1
61
343
434
512
561
5234
613434

434
512
5234
613434

613434
5234
512
434

Ejemplo 4

Encontrar min , max , suma y promedio de un IntStream

import java.util.stream.IntStream;
import java.io.PrintStream;
import java.util.function.Supplier;
import java.util.OptionalInt;
import java.util.OptionalDouble;
public class IntStreamClass{
    static final PrintStream out=System.out;
    public static void main(String $[]){
        Supplier<IntStream>supplier=()->IntStream.of(343,434,61,1,512,
                                                     5234,613434,561);
         
        //Average
        OptionalDouble avg=supplier.get().average();
        out.println("Average : "+avg.orElse(0));
        // Sum
        int sum=supplier.get().sum();
        out.println("Sum : "+sum);
        // Min
        OptionalInt min=supplier.get().min();
        out.println("min : "+min.orElse(0));
        // Max
        OptionalInt max=supplier.get().max();
        out.println("max : "+max.orElse(0));
    }
}

Producción :

Average : 77572.5
Sum : 620580
min : 1
max : 613434

Ejemplo 5

Operación basada en rango

import java.util.stream.IntStream;
import java.io.PrintStream;
import java.util.function.Supplier;
import java.util.OptionalInt;
import java.util.OptionalDouble;
public class IntStreamClass{
     
    static final PrintStream out=System.out;
     
    public static void main(String $[]){
 
        //Range
         
        //Will iterate from 0 to 5
        IntStream.range(0,6)
            .forEach(System.out::println);
        out.println();
 
        //Will iterate from 0 to 6
        IntStream.rangeClosed(0,6)
            .forEach(System.out::println);
        out.println();
         
        //rangeSum=0+1+2+3+...+99=4950
        int rangeSum=IntStream.range(0,100).sum();
        out.println("sum[0,100) : "+rangeSum);
         
        //rangeClosedSum=0+1+2+3+...+100=5050
        int rangeClosedSum=IntStream.rangeClosed(0,100).sum();
        out.println("sum[0,100] : "+rangeClosedSum);
    }
}