Diferencia entre Iterator y Spliterator en Java

La interfaz Java Iterator representa un objeto capaz de iterar a través de una colección de objetos Java, un objeto a la vez. La interfaz Iterator es uno de los mecanismos más antiguos de Java para iterar colecciones de objetos (aunque no es el más antiguo: Enumerator es anterior a Iterator).

Además, un iterador difiere de las enumeraciones de dos maneras:

1. Iterator permite a la persona que llama eliminar los elementos dados de la colección especificada durante la iteración de los elementos.

2. Se han mejorado los nombres de los métodos.

// Java program to illustrate Iterator interface
  
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class JavaIteratorExample1 {
    public static void main(String[] args)
    {
  
        // create a linkedlist
        List<String> list = new LinkedList<>();
  
        // Add elements
        list.add("Welcome");
        list.add("to");
        list.add("our");
        list.add("website");
  
        // print the list to the console
        System.out.println("The list is given as : "
                           + list);
  
        // call iterator on the list
        Iterator<String> itr = list.iterator();
  
        // itr.hasNext() returns true if there
        // is still an element next to the current
        // element pointed by iterator
        while (itr.hasNext()) {
  
            // Returns the next element.
            System.out.println(itr.next());
        }
  
        // Removes the last element.
        itr.remove();
  
        // print the list after removing an
        // element
        System.out.println(
            "After the remove() method is called : "
            + list);
    }
}

The list is given as : [Welcome, to, our, website]
Welcome
to
our
website
After the remove() method is called : [Welcome, to, our]

Al igual que Iterator y ListIterator , Spliterator es un iterador de Java, que se usa para iterar elementos uno por uno desde un objeto List implementado.

Las principales funcionalidades de Spliterator son: 

• Dividir los datos de origen
• Procesamiento de los datos de origen

El Interface Spliterator se incluye en JDK 8 para aprovechar las ventajas del paralelismo además del recorrido secuencial. Está diseñado como un análogo paralelo de un iterador.

// Java program to illustrate a Spliterator
  
import java.util.*;
import java.util.stream.Stream;
  
public class InterfaceSpliteratorExample {
  
    public static void main(String args[])
    {
  
        // Create an object of array list
        ArrayList<Integer> list = new ArrayList<>();
  
        // Add elements to the array list
        list.add(101);
        list.add(201);
        list.add(301);
        list.add(401);
        list.add(501);
  
        // create a stream on the list
        Stream<Integer> str = list.stream();
  
        // Get Spliterator object on stream
        Spliterator<Integer> splitr = str.spliterator();
  
        // Get size of the list
        // encountered by the
        // forEachRemaining method
        System.out.println("Estimate size: "
                           + splitr.estimateSize());
  
        // Print getExactSizeIfKnown
        // returns exact size if finite
        // or return -1
        System.out.println("Exact size: "
                           + splitr.getExactSizeIfKnown());
  
        // Check if the Spliterator has all
        // the characteristics
        System.out.println("Boolean Result: "
                           + splitr.hasCharacteristics(
                                 splitr.characteristics()));
  
        System.out.println("Elements of ArrayList :");
  
        // print elements using forEachRemaining
        splitr.forEachRemaining(
            (n) -> System.out.println(n));
  
        // Obtaining another Stream to the array list.
        Stream<Integer> str1 = list.stream();
  
        splitr = str1.spliterator();
  
        // Obtain spliterator using     trySplit() method
        Spliterator<Integer> splitr2 = splitr.trySplit();
  
        // If splitr can be partitioned 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("Output from splitr1: ");
        splitr.forEachRemaining(
            (n) -> System.out.println(n));
    }
}

Estimate size: 5
Exact size: 5
Boolean Result: true
Elements of ArrayList :
101
201
301
401
501
Output from splitr2: 
101
201
Output from splitr1: 
301
401
501

Diferencia entre Iterator y Spliterator en Java: