Analisi dettagliata della classe ArrayList [Parte 1]

Questo articolo esaminerà in dettaglio la classe ArrayList del Collections Framework, che è forse la più semplice da comprendere, poiché si basa su un array regolare. Quasi sicuramente ti verrà posta una domanda su questa classe e sulla sua implementazione in Java durante il colloquio. Nella seconda parte analizzeremo i restanti metodi e scriveremo la nostra implementazione di un array dinamico per numeri. La classe ArrayList eredita dalla classe AbstractList e implementa le seguenti interfacce: List, RandomAccess, Cloneable, Serializable. Un'analisi dettagliata della classe ArrayList [Parte 2] La classe ArrayList supporta array dinamici che possono essere espansi secondo necessità. La sua necessità ed efficacia è spiegata dal fatto che un array regolare ha una lunghezza fissa: una volta creato, non può crescere o ridursi, il che impone restrizioni se non si sa quanto sarà grande l'array. Essenzialmente, la classe ArrayList è un array di elenchi di riferimenti a oggetti di lunghezza variabile. È importante comprendere che la dimensione (numero di celle) dell'array interno non diminuisce automaticamente quando gli elementi vengono rimossi da esso. Viene infatti sizediminuito il valore della variabile, che indica il numero di elementi effettivamente presenti nell'array. Diciamo di creare un nuovo oggetto della classe ArrayList e di aggiungervi 5 elementi. Per impostazione predefinita, viene creato un array di 10 elementi. In questo caso la cosiddetta capacità (dimensione/volume) del nostro oggetto sarà pari a 10, ma il valore della variabile sizesarà pari a cinque. E quando eliminiamo elementi, vediamo cambiamenti nel valore della variabile size, poiché .lengthnon possiamo accedere all'array interno della classe ArrayList e scoprirne la lunghezza. La dimensione può essere ridotta utilizzando un metodo aggiuntivo trimToSize(), che verrà discusso di seguito. Diamo un'occhiata ai campi della classe.

• Campo responsabile del volume predefinito dell'array dinamico:

  private static final int DEFAULT_CAPACITY = 10

  Quando si crea un nuovo oggetto new ArrayList<>() (costruttore senza parametri), al suo interno viene creato un array di 10 elementi.

• Un campo in cui vengono archiviati tutti gli elementi della raccolta:

  transient Object[] elementData

  Contrassegnato con una parola chiave transient: il campo non viene scritto nel flusso di byte quando si utilizza l'algoritmo di serializzazione standard. Vale la pena notare che il campo non è contrassegnato con la parola chiave private, ma ciò è stato fatto per facilitare l'accesso a questo campo da classi nidificate (ad esempio, Sottolista).

• Un campo contatore che memorizza il numero di elementi effettivamente presenti nell'array:

  private int size

  Il valore viene incrementato/decrementato durante l'esecuzione di operazioni quali inserimento e cancellazione.

Ci sono altri 3 campi nella classe, ma essenzialmente sono aggiuntivi, quindi non ha senso considerarli. La classe ha tre costruttori:

1. public ArrayList()– crea un array di liste vuote di 10 elementi;
2. public ArrayList(Collection < ? extends E > c)– crea un array di liste inizializzato con elementi dalla collezione passata (se vogliamo creare un nuovo ArrayList basato su qualche collezione);
3. public ArrayList(int initialCapacity)– crea un array di elenchi con una capacità iniziale. Se il parametro passato partialCapacity è maggiore di 0, viene creato un array della dimensione specificata (al campo interno elementData viene assegnato un collegamento a un nuovo array di tipo Object di dimensione partialCapacity). Se il parametro è 0, viene creato un array vuoto. Se il parametro specificato è inferiore a 0, viene generata un'eccezione IllegalArgumentException.

Creare un oggetto

List < String> list = new ArrayList<>();

L'oggetto appena creato listcontiene proprietà (campi) elementDatae file size. Un archivio di valori elementDatanon è altro che un array di un tipo specifico (specificato in generico – <>), nel nostro caso String[]. Se viene chiamato un costruttore senza parametri, per impostazione predefinita verrà creato un array di 10 elementi di tipo Object (con conversione al tipo, ovviamente). Aggiunta di elementi Classicamente l'aggiunta di elementi a un array di elenchi viene eseguita utilizzando varianti sovraccaricate di add().

public boolean add(E элемент)

Bene, aggiungiamo: list.add("0"); All'interno di questo metodo viene chiamata una versione sovraccaricata del metodo add(), contrassegnata come private, che a sua volta accetta tre parametri come input: l'elemento da aggiungere, l'array interno e la sua dimensione. Nel metodo privato avviene un controllo: se il parametro size passato è uguale alla lunghezza dell'array interno (ovvero l'array è pieno), allora all'array viene assegnato il risultato del metodo grow(int minCapacity)(il valore corrente del campo size + 1 viene passato al metodo, poiché è necessario tenere conto dell'elemento da aggiungere), in cui all'interno dell'array viene assegnato un collegamento al nuovo array creato ottenuto copiando gli elementi dell'array originale:

Arrays.copyOf(elementData, newCapacity(minCapacity))

Come secondo parametro del metodo copyOfindichiamo il risultato del metodo newCapacity(int minCapacity), all'interno del quale viene calcolata la nuova dimensione dell'array. Si calcola utilizzando la seguente formula: int newCapacity = oldCapacity + (oldCapacity >> 1) Per un array con la dimensione predefinita, sarà vero quanto segue: >> 1– spostamento bit a destra di uno (un operatore che riduce un numero alla metà). In sostanza, significa dividere per 2 elevato a 1. Risulta che dividiamo 10 per 2 e aggiungiamo 10. In totale, la nuova capacità dell'array è 15, ma poiché stiamo aggiungendo l'undicesimo elemento, allora 15 + 1 = 16. Torniamo alla nostra lista e supponiamo di avervi già aggiunto 10 elementi e proviamo ad aggiungerne 11. Il controllo mostrerà che non c'è spazio nell'array. Di conseguenza, viene creato e chiamato un nuovo array Arrays.copyOf, che utilizza internamente il metodo di sistema System.arraycopy(). Oppure ecco un chiaro esempio da un articolo su JavaRush: dopo tutti questi controlli e aumentando la dimensione dell'array se necessario, in un metodo privato add()viene aggiunto un nuovo elemento alla fine dell'array e il parametro corrente sizeviene aumentato di uno . Il vecchio array verrà successivamente elaborato dal Garbage Collector. Ecco come funziona un array dinamico: quando aggiungiamo elementi, controlliamo se c'è ancora spazio al suo interno. Se c'è spazio, aggiungiamo semplicemente l'elemento alla fine dell'array. La fine non indica l'ultima cella dell'array, ma la cella che corrisponde al valore size. Abbiamo aggiunto il primo elemento all'array; viene inserito nella cella con indice [0]. Il valore del campo sizeè aumentato di uno e = 1. Aggiungiamo l'elemento successivo: vediamo che size = 1, di conseguenza posizioniamo l'elemento nella cella con indice [1] e così via. Esiste una versione sovraccaricata del metodo con due parametri:

public void add(int index, E element)

Possiamo specificare la posizione (indice) della cella in cui vogliamo aggiungere l'elemento. Innanzitutto, viene verificata la correttezza del valore dell'indice specificato, poiché esiste la possibilità che venga specificato un indice errato, che indicherà una cella dove non c'è nulla o che semplicemente non esiste. Controllo degli indici: index > size || index < 0– se l'indice specificato è maggiore della dimensione corrente dell'array o è inferiore a 0, viene lanciata un'eccezione IndexOutOfBoundsException. Quindi, se necessario, la dimensione dell'array viene aumentata, in modo simile all'esempio precedente. Probabilmente hai sentito dire che durante le operazioni di aggiunta/rimozione in un array, qualcosa viene spostato da qualche parte (a destra o a sinistra). Quindi, lo spostamento viene effettuato copiando l'array: System.arraycopy(elementData, index, elementData, index + 1, s - index); tutti gli elementi situati a destra dell'indice specificato verranno spostati di una posizione a destra (indice+1). E solo dopo viene aggiunto un nuovo elemento all'array interno nell'indice specificato. Poiché abbiamo spostato parte dell'array a destra di uno (non viene creato un nuovo array), la cella di cui abbiamo bisogno sarà libera per la scrittura. Il collegamento al vecchio array viene cancellato e in futuro verrà rilevato dal garbage collector. Incolla "maserati" nella cella [3], che è già occupata: Pertanto, quando un elemento viene inserito in indice e non ci sono spazi liberi nell'array, la chiamata System.arraycopy()avverrà due volte: la prima in grow(), la seconda nel metodo stesso add(index, value), il che influirà chiaramente sulla velocità dell'intera operazione di aggiunta. Di conseguenza, quando è necessario scrivere un altro elemento nell'array interno, ma non c'è spazio, ecco cosa succede all'interno di ArrayList:

• Viene creato un nuovo array con una dimensione 1,5 volte maggiore di quella originale, più un elemento.
• Tutti gli elementi del vecchio array vengono copiati nel nuovo array
• Il nuovo array viene archiviato nella variabile interna dell'oggetto ArrayList e il vecchio array viene dichiarato spazzatura.

La capacità degli oggetti di tipo ArrayList può essere aumentata manualmente utilizzando il metodo:

public void ensureCapacity(int minCapacity)

Aumentando in anticipo la capacità dell'array, è possibile evitare un'ulteriore ridistribuzione della RAM in un secondo momento. Il metodo aumenta la dimensione dell'array interno per contenere il numero di elementi passati a minCapacity. Il metodo ensureCapacity()non influisce sul campo size, ma influisce sulla capacity(dimensione) dell'array interno. Ancora una volta sottolineo che sizeentrambe sono capacitycose diverse ed è molto importante non confonderle! Se si desidera ridurre la dimensione dell'array sottostante da cui viene creato ArrayList al numero corrente di elementi effettivamente archiviati, è necessario chiamare trimToSize(). Dopo aver rimosso gli elementi dalla raccolta, size()mostrerà il numero di elementi effettivamente esistenti e capacitynon diminuirà! Supponiamo: abbiamo inserito 100 elementi, cancellati i primi 50, sizediventerà uguale a 50 e quindi capacityrimarrà 100. Per ridurre e capacity, dobbiamo utilizzare il metodo trimToSize(), che adegua tutta la nostra capacità alla dimensione attuale. Come si adatta? Copia il nostro array in modo che non rimangano celle vuote (la lunghezza del nuovo array è semplicemente uguale al campo dimensione). Puoi anche aggiungere elementi alla nostra collezione utilizzando il file addAll.

public boolean addAll(Collection< ? extends E> c)
public boolean addAll(int index, Collection< ? extends E> collection);

La prima opzione consente di aggiungere tutti gli elementi della raccolta specificata nel parametro del metodo (ad esempio, un altro foglio) alla raccolta originale (inserire alla fine) per la quale è stata effettuata la chiamata al metodo. La raccolta passata (può anche essere un set) viene convertita in un array utilizzando l'estensione toArray(). Naturalmente anche l'operazione di aggiunta viene effettuata mediante copiatura. Il secondo è aggiungere tutti gli elementi collectionalla lista, a partire da index index. In questo caso, tutti gli elementi verranno spostati a destra in base al numero di elementi nell'elenco collection. Rimozione di elementi Per prima cosa, diamo un'occhiata alle classiche opzioni per rimuovere elementi da un ArrayList.

public E remove(int index)

Esegue la cancellazione per indice e sposta tutti gli elementi successivi (dopo l'elemento all'indice specificato) a sinistra, chiudendo così i "buchi". Restituisce anche l'elemento cancellato (E), che è stato precedentemente scritto in una variabile aggiuntiva prima della cancellazione, il cui valore otteniamo come risultato della chiamata al metodo. Per capire cos'è E è necessario acquisire familiarità con i cosiddetti tipi generici. La notazione E indica che il metodo restituisce il tipo di dati specificato durante la creazione dell'oggetto ArrayList (ricorda: List <String> list, quindi, in questo caso, E verrà “sostituito” String). Per una comprensione generale, ti consiglio vivamente di familiarizzare con i tipi generici. Viene verificata la correttezza dell'indice inserito, quindi all'interno del metodo l'elemento non viene completamente cancellato, ma viene chiamato un metodo privato fastRemove(Object[] es, int i), in cui avviene già la cancellazione. Passiamo il nostro array e l'indice specificato al metodo come input. Gli elementi vengono copiati utilizzando System.arraycopy(), la dimensione dell'array viene ridotta e quindi assegniamo null all'ultimo elemento. Vale la pena notare che non viene creato un nuovo array: System.arraycopy(es, i + 1, es, i, size - 1 - i); la parte che si trova a destra della posizione sotto l'indice specificato (i+1) viene copiata nel nostro array originale (es) e si trova a partire dalla posizione stessa (i) dove si trovava l'elemento da eliminare. Pertanto, abbiamo eseguito uno spostamento a sinistra e cancellato il nostro elemento. Proviamo a rimuovere l'elemento all'indice 3 dall'array seguente: Consideriamo la seconda versione del metodo:

public boolean remove(Object o)

Il metodo rimuove dall'elenco l'elemento passato oo, più precisamente, l'oggetto al collegamento specificato. Se un elemento è presente nell'elenco, viene rimosso e tutti gli elementi vengono spostati a sinistra. Se l'elemento esiste nell'elenco e viene rimosso con successo, il metodo restituisce true; altrimenti false. Simile all'opzione con l'eliminazione per indice, il metodo si chiama fastRemove(), dove si verificano esattamente le stesse azioni. La differenza è che il metodo remove(Object o)ricerca l'oggetto desiderato anche tramite un metodo equals()della classe Object. Quando si rimuove per valore, il ciclo attraversa tutti gli elementi dell'elenco finché non viene trovata una corrispondenza. Verrà eliminato solo il primo elemento trovato. Riassumiamo: quando si eliminano elementi da un array dinamico, non rimangono buchi come in un array normale (la cella eliminata non sarà vuota). Tutti gli elementi successivi (che erano a destra dell'indice) vengono spostati di una posizione a sinistra. Esistono diversi metodi aggiuntivi che possono essere utilizzati per rimuovere elementi dall'elenco a vari livelli. Osserviamoli brevemente. Ripulire la nostra collezione:

public void clear()

Un semplice ciclo forscorre tutti gli elementi di un array, assegnando null a ciascun elemento. Puoi rimuovere dalla nostra raccolta quegli elementi che sono contenuti in un'altra raccolta trasferita come questa:

public boolean removeAll(Collection< ?> c)

Se devi rimuovere più elementi, probabilmente non dovresti farlo in un ciclo condizionale: è più comodo e sicuro utilizzare il metodo removeAll(). Accetta una raccolta di elementi che verranno rimossi dall'elenco. La raccolta deve contenere elementi dello stesso tipo archiviati nell'elenco di destinazione. Altrimenti verrà buttato via ClassCastException. Il metodo restituirà true se l'elenco è stato modificato in seguito alla chiamata al metodo. Rimuove gli elementi che non appartengono alla raccolta passata:

public boolean retainAll(Collection< ?> c)

Diciamo che abbiamo una collezione:

List< String> listFirst = new ArrayList<>();
listFirst.add("White");
listFirst.add("Black");
listFirst.add("Red");

E il secondo:

List< String> listSecond = new ArrayList<>();
listSecond.add("Green");
listSecond.add("Red");
listSecond.add("White");

Quindi dopo listSecond.retainAll(listFirst)rimarrà listSecond:

"White"
"Red"

Poiché "Verde" è stato rimosso, che non è in formato listFirst. Ma dopo listSecond.removeAll(listFirst)rimarrà listSecond:

"Green"
Удалorсь все элементы, которые есть в listFirst.

Non appartenente alla raccolta passata: significa che se sono presenti elementi che non sono nella raccolta passata, è necessario rimuoverli dal primo (a cui viene applicato il metodo). Appartenente alla raccolta trasferita: di conseguenza, se è presente un elemento sia nella prima che nella seconda raccolta (trasferita), il duplicato della prima viene distrutto.

protected void removeRange(int fromIndex, int toIndex)

Rimuove dall'elenco tutti gli elementi compresi tra l'indice iniziale specificato (incluso) e l'indice finale specificato (non incluso). Vale la pena notare che il metodo non può essere chiamato direttamente su un oggetto ArrayList. Per usarlo è necessario ereditare da AbstractList/ArrayList. Il metodo viene utilizzato anche da un altro metodo (subList, di cui parleremo più avanti).

public boolean removeIf(Predicate< ? super E> filter)

Rimuove gli elementi da una raccolta in base a un determinato predicato. Il predicato stesso è una determinata funzione/algoritmo/condizione in base alla quale verranno rimossi uno o più elementi corrispondenti ad una determinata condizione. Predicate— un'interfaccia funzionale (contiene un solo metodo, quindi può essere utilizzata come lambda), funziona secondo il principio "ricevuto un parametro - restituito booleano". Essenzialmente, il metodo sovrascrive l'implementazione dall'interfaccia Collectione implementa la seguente "strategia": scorre gli elementi e contrassegna quelli che corrispondono al nostro Predicate; viene quindi eseguito una seconda volta per rimuovere (e spostare) gli elementi contrassegnati nella prima iterazione. Implementiamo un'interfaccia Predicateche restituirà true se due oggetti sono uguali:

class SamplePredicate< T> implements Predicate< T>{
  T varc1;
  public boolean test(T varc){
     if(varc1.equals(varc)){
       return true;
  }
  return false;
  }
}

In un'altra classe, creiamo un ArrayList da Stringe un oggetto della nostra classe che implementa Predicate:

ArrayList< String> color_list = new ArrayList<> ();
SamplePredicate< String> filter = new SamplePredicate<> ();

varc1Scriviamo il valore "Bianco" nella variabile :

filter.varc1 = "White";

Aggiungiamo alcune righe all'elenco:

color_list.add("White");
color_list.add("Black");
color_list.add("Red");
color_list.add("White");
color_list.add("Yellow");
color_list.add("White");

Eseguiamo il metodo della lista removeIf, al quale passeremo il nostro oggetto con la condizione:

color_list.removeIf(filter);

Di conseguenza, tutte le righe con il valore "Bianco" verranno rimosse dall'elenco, poiché il nostro "predicato" le confronta per verificarne l'uguaglianza. Elenco finale: [Nero, Rosso, Giallo]. Sostituzione di elementi

public E set(int index, E element)

Sostituisce l'elemento nella posizione specificata indexcon quello passato element. L'indice deve anche essere maggiore di zero e minore dell'indice dell'ultimo elemento, altrimenti verrà lanciata un'eccezione IndexOutOfBoundsException. Non si verificano copie dell'array interno. Semplicemente, al posto dell'elemento all'indice specificato, viene inserito un nuovo elemento, ad es. sovrascrivere il valore.

public void replaceAll(UnaryOperator<e> operator)

Modifica tutti gli elementi della raccolta (possibile con una condizione). Utilizzato prevalentemente in combinazione con lambda o una classe anonima (ma per chiarezza, nell'esempio utilizzeremo semplicemente una classe che implementa l'interfaccia) che implementa l'interfaccia UnaryOperatore ne definisce i metodi. Implementiamo l'interfaccia:

class MyOperator< T> implements UnaryOperator< T>{
   T varc1;
   public T apply(T varc){
     return varc1;
  }
}

In un'altra classe, creiamo un ArrayList da Stringe un oggetto della nostra classe che implementa UnaryOperator:

ArrayList< String> color_list = new ArrayList<> ();
MyOperator< String> operator = new MyOperator<> ();

varc1Scriviamo il valore "Bianco" nella variabile :

operator.varc1 = "White";

Aggiungiamo alcune righe all'elenco:

color_list.add("White");
color_list.add("Black");
color_list.add("Red");
color_list.add("White");
color_list.add("Yellow");
color_list.add("White");

Eseguiamo un metodo della lista replaceAlla cui passeremo il nostro oggetto operator:

color_list.replaceAll(operator);

Di conseguenza, tutti i valori nell'elenco sono stati sostituiti con "Bianco": [Bianco, Bianco, Bianco, Bianco, Bianco, Bianco]. Ed è così che, ad esempio, puoi rimuovere tutti gli spazi dalle stringhe presenti nella raccolta:

ArrayList< String> list = new ArrayList<>(Arrays.asList("A   ", "  B  ", "C"));
list.replaceAll(String::trim);

Altri metodi: puoi convertire l'array dell'elenco ArrayList in un array regolare utilizzando il metodo:

public Object[] toArray()

O

public < T> T[] toArray(T[] a)

- qui il tipo dell'array restituito è determinato in runtime Questo metodo consentirà:

1. velocizzare alcune operazioni;
2. passare un array come parametro a un metodo che non sia sovraccaricato per accettare direttamente la raccolta;
3. Integrazione del nuovo codice basato su raccolte con codice legacy che non riconosce le raccolte.

Restituisce un oggetto copia dell'array:

public Object clone()

Tieni presente che il metodo clone()restituisce il tipo Object, quindi dopo averlo chiamato dovrai eseguire il cast alla classe richiesta. La clonazione crea un nuovo oggetto indipendente. Controlla la collezione per la presenza di un oggetto:

public boolean contains(Object o)

Verifica la presenza di un oggetto nella lista (internamente utilizzando il metodo equals della classe Object, ovvero confronta i riferimenti), restituisce vero/falso a seconda del risultato. Oltre ai soliti cicli, puoi scorrere (accedere a ciascun elemento ed eseguire alcune azioni) una raccolta utilizzando:

public void forEach(Consumer< ? super E> action)

Ecco come possiamo visualizzare la nostra lista:

List< Integer> numbers = new ArrayList<>(Arrays.asList(10, 20, 50, 100, -5));
numbers.forEach((number)-> System.out.println(number));

Senza utilizzare lambda è necessario utilizzare una classe anonima e sovrascrivere il metodo acceptdell'interfaccia Consumer:

numbers.forEach(new Consumer< Integer>() {
  @Override
   public void accept(Integer integer) {
      System.out.println(integer);
          }
});

Ottieni un elemento tramite il suo indice:

public E get(int index)

Utilizzato per l'accesso casuale agli elementi della raccolta. Restituisce l'elemento situato nell'elenco in corrispondenza dell'indice specificato. Se index < 0o è index >=il numero massimo di elementi nell'elenco, verrà generata un'eccezione IndexOutOfBoundsException. Questo è il metodo di base per recuperare un elemento da un elenco e il tempo per recuperare un elemento tramite indice sarà sempre lo stesso, indipendentemente dalla dimensione dell'ArrayList, poiché accede a una cella specifica dell'array. Ricerca degli indici per gli oggetti specificati:

public int indexOf(Object o);
public int lastIndexOf(Object o);

I metodi restituiscono l'indice del primo (quando l'oggetto dato viene incontrato per la prima volta) o dell'ultima occorrenza (quando l'oggetto dato viene incontrato per l'ultima volta) elemento nell'elenco. Se l'elemento non esiste nell'elenco, i metodi restituiranno -1. Controlla la raccolta per gli elementi:

public boolean isEmpty();

Il metodo restituisce true se la lista è vuota (guarda per vedere se il campo è uguale size 0), altrimenti false. Se l'elenco contiene solo elementi null, il metodo restituirà false. In altre parole, con questo metodo vengono presi in considerazione anche gli elementi nulli. Scopri il numero di elementi in un elenco:

public int size();

Restituisce il numero di elementi nell'elenco (valori del campo dimensione). Il numero di elementi può differire dalla capacità dell'elenco (capacità). Ottieni un iteratore per un elenco:

public Iterator< E> iterator();

Restituisce un iteratore per un elenco da utilizzare successivamente in un ciclo o in qualsiasi altra elaborazione. L'iteratore implementa il comportamento fail-fast. Se esegue la raccolta e nota alcune modifiche (che non sono state ottenute utilizzando i metodi iteratori), lancia immediatamente un'eccezione ConcurrentModificationException. L'iteratore ha qualcosa chiamato modification count. Quando l'iteratore scorre la raccolta dopo ciascuno next/hasNext/remove, controlla questo contatore. Se non corrisponde a ciò che l'iteratore si aspettava di vedere, genera un'eccezione. Non prenderò in considerazione gli iteratori in dettaglio qui.

public ListIterator< E> listIterator() и public ListIterator< E> listIterator(int index)

Restituisce un iteratore di elenco per un elenco da utilizzare successivamente in un ciclo o in qualsiasi altra elaborazione. L'interfaccia ListIteratorestende l'interfaccia Iteratorper l'attraversamento bidirezionale dell'elenco e la modifica dei suoi elementi. Nella versione sovraccaricata è possibile passare l'indice da cui inizierà l'“attraversamento”. L'indice in questo caso denota il primo elemento da cui il metodo inizierà il suo lavoro next()e quando viene chiamato il metodo, previous()l'attraversamento inizierà dall'elemento sotto l'indice “indice passato - 1”.

public Spliterator <E> spliterator()

Java 8 introduce un nuovo tipo di iteratore con associazione tardiva e fail-fast chiamato iteratore delimitatore. Gli iteratori separatori consentono di scorrere una sequenza di elementi, ma vengono utilizzati in modo diverso. La caratteristica più importante dell'interfaccia Spliterator è la sua capacità di supportare l'iterazione parallela di singole parti di una sequenza di elementi e quindi la programmazione parallela.