Separador de interfaz Java.util en Java8

Posted on by Rudeus Greyrat

Requisito previo: Iteradores en Java

Los divisores, como otros iteradores, son para atravesar los elementos de una fuente. Una fuente puede ser una colección , un canal de E/S o una función de generador .

  • Se incluye en JDK 8 para admitir un recorrido paralelo eficiente (programación paralela) además del recorrido secuencial.
  • Sin embargo, puede usar Spliterator incluso si no va a usar la ejecución en paralelo. Una razón por la que podría querer hacerlo es porque combina las operaciones hasNext y next en un solo método.

Para las colecciones, el objeto Spliterator se puede crear llamando al método spliterator() presente en la interfaz de la colección.

// Here "c" is any Collection object. splitr is of
// type Spliterator interface and refers to "c"
Spliterator splitr = c.spliterator();

La interfaz Spliterator define 8 métodos:

  1. int características() : Devuelve un conjunto de características de este Spliterator y sus elementos. El resultado es ORDENADO (0x00000010), DISTINTO (0x00000001), ORDENADO (0x00000004), TAMAÑO (0x00000040), NO NULL (0x00000100), INMUTABLE (0x00000400), CONCURRENT (0x00001000), SUBSIZED (0x00004000). 
    Syntax : 
int characteristics()
Parameters : 
NA
Returns :
Returns the characteristics of the invoking spliterator,
encoded into an integer.
  2. longestimateSize( ) : devuelve una estimación del número de elementos que quedan por iterar o devuelve Long.MAX_VALUE si es infinito, desconocido o demasiado caro de calcular. 
    Syntax : 
long estimateSize( )
Parameters : 
NA
Returns :
Estimates the number of elements left to iterate and
returns the result. Returns Long.MAX_VALUE if the
count cannot be obtained for any reason.
  3. predeterminado largo getExactSizeIfKnown( ) : método de conveniencia que devuelve el tamaño estimado() si este Spliterator tiene TAMAÑO, de lo contrario -1. 
    Syntax : 
default long getExactSizeIfKnown( )
Parameters : 
NA
Returns :
If the invoking spliterator is SIZED, returns the number of
elements left to iterate. Returns –1 otherwise.
  4. Comparador por defecto<? super T> getComparator( ) : Si la fuente de este Spliterator está ORDENADA por un Comparador, devuelve ese Comparador. Si la fuente está ORDENADA en orden natural, devuelve nulo. De lo contrario, si la fuente no está ORDENADA, lanza IllegalStateException. 
    Syntax : 
default Comparator<? super T> getComparator( )
Parameters : 
NA
Returns :
Returns the comparator used by the invoking spliterator
or null if natural ordering is used. 
Throws:
IllegalStateException - If the sequence is unordered, 
IllegalStateException is thrown.
  5. default boolean hasCharacteristics(int val) : Devuelve verdadero si las características de este Spliterator() contienen todas las características dadas. 
    Syntax : 
default boolean hasCharacteristics(int val)
Parameters : 
characteristics - the characteristics to check for
Returns :
Returns true if the invoking spliterator has the
characteristics passed in val. Returns false otherwise.
  6. boolean tryAdvance(Consumer<? super T> action) : si existe un elemento restante, realiza la acción dada en él, devolviendo verdadero; de lo contrario devuelve falso. Si se ORDENA este Spliterator, la acción se realiza en el siguiente elemento en el orden de encuentro. Las excepciones lanzadas por la acción se transmiten a la persona que llama. 
    Syntax : 
boolean tryAdvance(Consumer<? super T> action) 
Parameters : 
action - The action
Returns :
Returns true if there is a next element. Returns false if no
elements remain.
Throws :
NullPointerException - if the specified action is null
  7. default void forEachRemaining(Consumer<? super T>action) : Realiza la acción dada para cada elemento restante, secuencialmente en el subproceso actual, hasta que todos los elementos se hayan procesado o la acción genere una excepción. Si se ORDENA este Spliterator, las acciones se realizan en orden de encuentro. Las excepciones lanzadas por la acción se transmiten a la persona que llama. 
    Syntax : 
default void forEachRemaining(Consumer<? super T>action)
Parameters : 
action - The action
Returns :
NA
Throws :
NullPointerException - if the specified action is null
  8. Spliterator<T> trySplit( ) : si es posible, divide el spliterator que invoca y devuelve una referencia a un nuevo spliterator para la partición. De lo contrario, devuelve nulo. Por lo tanto, si tiene éxito, el spliterator original itera sobre una parte de la secuencia y el spliterator devuelto itera sobre la otra parte. 
    Syntax : 
Spliterator<T> trySplit( )
Parameters : 
NA
Returns :
a Spliterator covering some portion of the elements, 
or null if this spliterator cannot be split

    9. El siguiente ejemplo demuestra los métodos de Spliterator.

    // Java program to demonstrate
    // methods of Spliterator
      
    import java.util.ArrayList;
    import java.util.Spliterator;
    import java.util.stream.Stream;
          
    public class SpliteratorDemo 
    {
        public static void main(String[] args) 
        {
            // Create an array list for doubles.
            ArrayList<Integer> al = new ArrayList<>();
                  
            // Add values to the array list.
            al.add(1);
            al.add(2);
            al.add(-3);
            al.add(-4);
            al.add(5);
                  
            // Obtain a Stream to the array list.
            Stream<Integer> str = al.stream();
                  
            // getting Spliterator object on al
            Spliterator<Integer> splitr1 = str.spliterator();
              
            // estimateSize method
            System.out.println("estimate size : " + splitr1.estimateSize());
                      
            // getExactSizeIfKnown method
            System.out.println("exact size : " + splitr1.getExactSizeIfKnown());
              
            // hasCharacteristics and characteristics method
            System.out.println(splitr1.hasCharacteristics(splitr1.characteristics()));
              
            System.out.println("Content of arraylist :");
            // forEachRemaining method    
            splitr1.forEachRemaining((n) -> System.out.println(n));
              
            // Obtaining another  Stream to the array list.
            Stream<Integer> str1 = al.stream();
            splitr1 = str1.spliterator();
              
            // trySplit() method
            Spliterator<Integer> splitr2 = splitr1.trySplit();
              
            // If splitr1 could be split, use splitr2 first.
            if(splitr2 != null) {
            System.out.println("Output from splitr2: ");
            splitr2.forEachRemaining((n) -> System.out.println(n));
            }
      
            // Now, use the splitr
            System.out.println("\nOutput from splitr1: ");
            splitr1.forEachRemaining((n) -> System.out.println(n));
                  
        }
    }

    Producción:

    estimate size : 5
exact size : 5
true
Content of arraylist :
1
2
-3
-4
5
Output from splitr2: 
1
2

Output from splitr1: 
-3
-4
5

programa Java para el método tryadvance

Eche un vistazo al método tryAdvance() . Realiza una acción en el siguiente elemento y luego avanza el iterador. Se muestra aquí:

boolean tryAdvance(Consumer<? super T> action)

Aquí, action especifica la acción que se ejecuta en el siguiente elemento de la iteración y Consumer es una interfaz funcional que aplica una acción a un objeto. Es una interfaz funcional genérica declarada en java.util.function . Solo tiene un método abstracto, accept() , que se
muestra aquí:

void accept(T objRef)

aquí T es el tipo de referencia de objeto.

Para implementar nuestra acción , debemos implementar el método de aceptación. Para implementar el método de aceptación, aquí usamos la expresión lambda . Esto quedará más claro en el siguiente ejemplo.

Cómo usar Spliterator con Colecciones : Usar Spliterator para tareas básicas de iteración es bastante fácil, simplemente llame a tryAdvance( ) hasta que devuelva falso.

// Java program to demonstrate simple Spliterator
// using tryAdvance method
  
import java.util.ArrayList;
import java.util.Spliterator;
      
public class SpliteratorDemo 
{
    public static void main(String[] args) 
    {
        // Create an array list for doubles.
        ArrayList<Integer> al1 = new ArrayList<>();
              
        // Add values to the array list.
        al1.add(1);
        al1.add(2);
        al1.add(-3);
        al1.add(-4);
        al1.add(5);
              
              
        // Use tryAdvance() to display(action) contents of arraylist.
              
        System.out.print("Contents of arraylist:\n");
              
        // getting Spliterator object on al1
        Spliterator<Integer> splitr = al1.spliterator();
              
        // Use tryAdvance() to display(action) contents of arraylist.
        // Notice how lambda expression is used to implement accept method
        // of Consumer interface
              
        while(splitr.tryAdvance((n) -> System.out.println(n)));
              
        // Use tryAdvance() for getting absolute values(action) of contents of arraylist.
              
              
        // Create new list that contains absolute values.
        ArrayList<Integer> al2 = new ArrayList<>();
              
              
              
        splitr = al1.spliterator();
              
        // Here our action is to get absolute values
        // Notice how lambda expression is used to implement accept method
        // of Consumer interface
        while(splitr.tryAdvance((n) -> al2.add(Math.abs(n))));
              
        System.out.print("Absolute values of contents of arraylist:\n");
              
        // getting Spliterator object on al2
        splitr = al2.spliterator();
              
              
        while(splitr.tryAdvance((n) -> System.out.println(n)));
              
    }
}

Producción:

Contents of arraylist:
1
2
-3
-4
5
Absolute values of contents of arraylist:
1
2
3
4
5

Observe cómo tryAdvance() consolida los propósitos de hasNext() y next() proporcionados por Iterator en un solo método en el ejemplo anterior. Esto mejora la eficiencia del proceso de iteración.

En algunos casos, es posible que desee realizar alguna acción en cada elemento de forma colectiva, en lugar de uno a la vez. Para manejar este tipo de situaciones, Spliterator proporciona el método forEachRemaining(), generalmente se usa en casos que involucran flujos . Este método aplica una acción a cada elemento sin procesar y luego regresa.

Este artículo es una contribución de Gaurav Miglani . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 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 *