10 formas de crear una secuencia en Java

Posted on by Rudeus Greyrat

La API Stream , introducida en Java 8, se utiliza para procesar colecciones de objetos. Stream es una secuencia de objetos que admite muchos métodos diferentes que se pueden canalizar para producir el resultado deseado.

Las características de Java stream son:

  • Una secuencia no es una estructura de datos, sino que recibe información de las colecciones, arrays o canales de E/S.
  • A Streams no cambia la estructura de datos original, solo proporcionan el resultado como métodos canalizados.
  • Cada operación intermedia se ejecuta con pereza y devuelve una secuencia como resultado, por lo tanto, se pueden canalizar varias operaciones intermedias. La operación de terminal marca el final de la secuencia y devuelve el resultado.

Diferente forma de crear Streams:

  1. Uso de la colección

    Acercarse:

    1. Consigue la colección
    2. Construya un flujo secuencial de la colección usando el método Collection.stream()
    3. Imprimir la transmisión

    A continuación se muestra la implementación del enfoque anterior:

    Programa:

    // Java program to create Stream from Collections
      
    import java.util.*;
    import java.util.stream.Stream;
      
    class GFG {
      
        // Function convert a List into Stream
        private static <T> void getStream(List<T> list)
        {
      
            // Create stream object with the List
            Stream<T> stream = list.stream();
      
            // Iterate list first to last element
            Iterator<T> it = stream.iterator();
      
            // Iterate stream object
            while (it.hasNext()) {
                System.out.print(it.next() + " ");
            }
        }
      
        public static void main(String[] args)
        {
      
            // Create ArrayList of String
            List<String> list = new ArrayList<>();
      
            // Add element in list
            list.add("Geeks");
            list.add("for");
            list.add("Geeks");
      
            // Get the Stream from the List
            getStream(list);
        }
    }
    Producción:

    Geeks for Geeks
  2. Crear una secuencia a partir de valores especificados

    El método Stream.of(T…t) se puede usar para crear una secuencia con los valores t especificados, donde t son los elementos. Este método devuelve un Stream secuencial que contiene los elementos t.

    A continuación se muestra la implementación del enfoque anterior:

    Programa:

    // Java program to create Stream from values
      
    import java.util.*;
    import java.util.stream.Stream;
      
    class GFG {
      
        // Function convert a List into Stream
        private static void getStream()
        {
      
            // Create a stream from specified values
            Stream<Integer> stream
                = Stream.of(1, 2,
                            3, 4,
                            5, 6,
                            7, 8,
                            9);
      
            // Displaying the sequential ordered stream
            stream.forEach(p -> System.out.print(p + " "));
        }
      
        public static void main(String[] args)
        {
      
            // Get the Stream from the values
            getStream();
        }
    }
    Producción:

    1 2 3 4 5 6 7 8 9
  3. Crear secuencia a partir de una array:

    Stream.of () y Arrays.stream() son dos métodos comúnmente utilizados para crear un flujo secuencial a partir de una array específica. Ambos métodos devuelven un Stream cuando se les llama con un tipo T no primitivo.
    Array de enteros

    • Crear flujo usando Arrays.stream()

      Programa:

      // Java program to create Stream from Collections
        
      import java.util.*;
      import java.util.stream.Stream;
        
      class GFG {
        
          // Function convert a List into Stream
          private static <T> void getStream(T[] arr)
          {
        
              // Create stream from an array
              // using Arrays.stream()
              Stream<T> streamOfArray
                  = Arrays.stream(arr);
        
              // Iterate list first to last element
              Iterator<T> it
                  = streamOfArray.iterator();
        
              // Iterate stream object
              while (it.hasNext()) {
                  System.out.print(it.next() + " ");
              }
          }
        
          public static void main(String[] args)
          {
        
              // Get the array
              String[] arr
                  = new String[] { "a", "b", "c" };
        
              // Get the Stream from the Array
              getStream(arr);
          }
      }
      Producción:

      a b c
    • Crear transmisión usando Stream.of()
      Una acción que no interfiere que se realiza en los elementos a medida que se consumen de la transmisión y también devuelve una nueva transmisión.

      Programa:

      // Java program to create Stream from Collections
        
      import java.util.*;
      import java.util.stream.Stream;
        
      class GFG {
        
          // Function convert a List into Stream
          private static <T> void getStream(T[] arr)
          {
        
              // Create stream from an array
              // using Stream.of()
              Stream<T> streamOfArray = Stream.of(arr);
        
              // Iterate list first to last element
              Iterator<T> it = streamOfArray.iterator();
        
              // Iterate stream object
              while (it.hasNext()) {
                  System.out.print(it.next() + " ");
              }
          }
        
          public static void main(String[] args)
          {
        
              // Get the array
              String[] arr
                  = new String[] { "a", "b", "c" };
        
              // Get the Stream from the Array
              getStream(arr);
          }
      }
      Producción:

      a b c
  4. Crea una transmisión vacía usando Stream.empty()

    El método vacío() se usa en la creación para evitar devolver un valor nulo para flujos sin elementos.

    Programa:

    // Java program to create empty Stream
      
    import java.util.*;
    import java.util.stream.Stream;
      
    class GFG {
      
        // Function convert a List into Stream
        private static void getStream()
        {
      
            // Create stream from an array using Stream.empty()
            Stream<String> streamOfArray
                = Stream.empty();
      
            // Iterate list first to last element
            Iterator<String> it
                = streamOfArray.iterator();
      
            // Iterate stream object
            while (it.hasNext()) {
                System.out.print(it.next() + " ");
            }
        }
      
        public static void main(String[] args)
        {
      
            // Get the empty Stream
            getStream();
        }
    }
    Producción:
  5. Crear una secuencia usando Stream.builder()

    El método builder() se usa cuando el tipo deseado debe especificarse adicionalmente en la parte derecha de la declaración; de lo contrario, el método build() creará una instancia de Stream.

    Programa:

    // Java program to create Stream from Collections
      
    import java.util.*;
    import java.util.stream.Stream;
      
    class GFG {
      
        // Function convert a List into Stream
        private static <T> void getStream()
        {
      
            // Create stream using Stream builder()
            Stream.Builder<String> builder
                = Stream.builder();
      
            // Adding elements in the stream of Strings
            Stream<String> stream = builder.add("a")
                                        .add("b")
                                        .add("c")
                                        .build();
      
            // Iterate list first to last element
            Iterator<String> it = stream.iterator();
      
            // Iterate stream object
            while (it.hasNext()) {
                System.out.print(it.next() + " ");
            }
        }
      
        public static void main(String[] args)
        {
      
            // Get the Stream using Builder
            getStream();
        }
    }
    Producción:

    a b c
  6. Crea un Stream infinito usando Stream.iterate()

    El método iterar() devuelve un Stream ordenado secuencial infinito producido por la aplicación iterativa de una función f a un elemento semilla inicial. En el siguiente ejemplo, el primer elemento del flujo resultante es un primer parámetro del método de iteración. Para crear cada elemento siguiente, la función se aplica al elemento anterior. En el siguiente ejemplo, el segundo elemento será 4.

    Programa:

    // Java program to create infinite Stream
    // using Stream.iterate() method
      
    import java.util.*;
    import java.util.stream.Stream;
      
    class GFG {
      
        // Function convert a List into Stream
        private static <T> void
        getStream(int seedValue, int limitTerms)
        {
      
            // Create infinite stream
            // using Stream.iterate() method
            Stream.iterate(seedValue,
                           (Integer n) -> n * n)
                .limit(limitTerms)
                .forEach(System.out::println);
        }
      
        public static void main(String[] args)
        {
      
            // Get the seed value
            int seedValue = 2;
      
            // Get the limit for number of terms
            int limitTerms = 5;
      
            // Get the Stream from the function
            getStream(seedValue, limitTerms);
        }
    }
    Producción:

    2
4
16
256
65536
  7. Crea un Stream infinito usando el método Stream.generate()

    El método generar() acepta un proveedor para generar elementos y el flujo resultante es infinito. Entonces, para restringirlo, especifique el tamaño deseado o el método generar() funcionará hasta que alcance el límite de memoria.

    Programa:

    // Java program to create infinite Stream
    // using Stream.generate() method
      
    import java.util.*;
    import java.util.stream.*;
      
    class GFG {
      
        // Function convert a List into Stream
        private static <T> void getStream(int limitTerms)
        {
      
            // Create infinite stream
            // using Stream.generate() method
            Stream.generate(Math::random)
                .limit(limitTerms)
                .forEach(System.out::println);
        }
      
        public static void main(String[] args)
        {
      
            // Get the limit for number of terms
            int limitTerms = 5;
      
            // Get the Stream from the function
            getStream(limitTerms);
        }
    }
    Producción:

    0.2293502475696314
0.5650334795948209
0.3418138293253522
0.36831074763500116
0.4864408670097241
  8. Crear transmisión a partir de un patrón usando predicado

    En java 8, el método Predicate asPredicate() de Pattern crea una función predicada de valor booleano que se utiliza para la coincidencia de patrones.

    Programa:

    // Java program to create Stream from Collections
      
    import java.util.*;
    import java.util.stream.*;
    import java.util.regex.Pattern;
      
    class GFG {
      
        // Function convert a List into Stream
        private static void
        getStream(List<String> list, Pattern p)
        {
      
            list.stream()
                .filter(p.asPredicate())
                .forEach(System.out::println);
        }
      
        public static void main(String[] args)
        {
      
            // Create ArrayList of String
            // that is backed by the specified array
            List<String> list
                = Arrays
                      .asList("Geeks",
                              "For",
                              "Geek",
                              "GeeksForGeeks",
                              "A Computer Portal");
      
            // Get the pattern
            Pattern p = Pattern.compile("^G");
      
            // Get the Stream from the List matching Pattern
            getStream(list, p);
        }
    }
    Producción:

    Geeks
Geek
GeeksForGeeks
  9. Crear flujo desde iterador

    Los iteradores, en Java, se utilizan en Collection Framework para recuperar elementos uno por uno. Spliterator es la clave para crear el flujo secuencial. Por lo tanto, en este método también se utiliza Spliterator. Pero en este método, la fuente de Spliterator se establece en un Iterable creado a partir del Iterator. Entonces, primero se crea el iterable a partir del iterador. Luego, el Spliterator se pasa al método stream() directamente como Iterable.spliterator().

    Programa:

    // Java program to create Stream from Collections
      
    import java.util.*;
    import java.util.stream.*;
      
    class GFG {
      
        // Function convert a List into Stream
        private static <T> void getStream(Iterator<T> itr)
        {
      
            // Convert the iterator into a Spliterator
            Spliterator<T> spitr
                = Spliterators
                      .spliteratorUnknownSize(itr,
                                              Spliterator.NONNULL);
      
            // Convert spliterator into a sequential stream
            Stream<T> stream
                = StreamSupport.stream(spitr, false);
      
            // Iterate list first to last element
            Iterator<T> it = stream.iterator();
      
            // Iterate stream object
            while (it.hasNext()) {
                System.out.print(it.next() + " ");
            }
        }
      
        public static void main(String[] args)
        {
      
            // Get the Iterator
            Iterator<String> iterator = Arrays
                                            .asList("a", "b", "c")
                                            .iterator();
      
            // Get the Stream from the Iterator
            getStream(iterator);
        }
    }
    Producción:

    a b c
  10. Crear flujo desde Iterable

    La interfaz iterable está diseñada teniendo en cuenta y no proporciona ningún método stream() por sí solo. Simplemente se puede pasar al método StreamSupport.stream() y obtener un Stream del objeto Iterable dado. Es más fácil convertir un Iterable en un Stream. Iterable tiene un método predeterminado spliterator(), que se puede usar para obtener una instancia de Spliterator, que a su vez se puede convertir en Stream.

    Nota: Iterable no es una instancia de Collection, este método llama internamente a StreamSupport.stream() para obtener un Stream secuencial de Spliterator; de lo contrario, simplemente llama al método Collection.stream().

    Programa:

    // Java program to create Stream from Collections
      
    import java.util.*;
    import java.util.stream.*;
      
    class GFG {
      
        // Function convert a List into Stream
        private static <T> void getStream(Iterable<T> iterable)
        {
      
            // Convert the iterator into a Stream
            Stream<T> stream
                = StreamSupport
                      .stream(iterable.spliterator(),
                              false);
      
            // Iterate list first to last element
            Iterator<T> it = stream.iterator();
      
            // Iterate stream object
            while (it.hasNext()) {
                System.out.print(it.next() + " ");
            }
        }
      
        public static void main(String[] args)
        {
      
            // Get the Iterable
            Iterable<String> iterable
                = Arrays.asList("a", "b", "c");
      
            // Get the Stream from the Iterable
            getStream(iterable);
        }
    }
    Producción:

    a b c

Publicación traducida automáticamente

Artículo escrito por 29AjayKumar y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *