Ottieni le dimensioni di un Iterable in Java

Ho bisogno di capire il numero di elementi in un Iterablein Java. So che posso fare questo:

Iterable values = ...
it = values.iterator();
while (it.hasNext()) {
  it.next();
  sum++;
}

Potrei anche fare qualcosa di simile, perché non ho più bisogno degli oggetti in Iterable:

it = values.iterator();
while (it.hasNext()) {
  it.remove();
  sum++;
}

Un benchmark su piccola scala non ha mostrato molta differenza di prestazioni, commenti o altre idee per questo problema?

TL; DR: utilizza il metodo Iterables.size(Iterable)di utilità della grande libreria Guava .

Dei tuoi due frammenti di codice, dovresti usare il primo, perché il secondo rimuoverà tutti gli elementi da values, quindi sarà vuoto in seguito. La modifica di una struttura dati per una query semplice come la sua dimensione è molto inaspettata.

Per le prestazioni, questo dipende dalla struttura dei dati. Se ad esempio è an ArrayList, rimuovere gli elementi dall'inizio (quello che sta facendo il tuo secondo metodo) è molto lento (il calcolo della dimensione diventa O (n * n) invece di O (n) come dovrebbe essere).

In generale, se esiste la possibilità che valuessia effettivamente un Collectione non solo un Iterable, controllare questo e chiamare size()nel caso:

if (values instanceof Collection<?>) {
  return ((Collection<?>)values).size();
}
// use Iterator here...

La chiamata a size()di solito è molto più veloce di contare il numero di elementi, e questo trucco è esattamente quello Iterables.size(Iterable)di Guava fa per voi.

Se stai lavorando con java 8 puoi usare:

Iterable values = ...
long size = values.spliterator().getExactSizeIfKnown();

funzionerà solo se la sorgente iterabile ha una dimensione determinata. La maggior parte degli spliterator per le raccolte lo farà, ma potresti avere problemi se proviene da HashSeto, ResultSetad esempio.

Puoi controllare il javadoc qui.

Se Java 8 non è un'opzione o se non sai da dove proviene l'iterabile, puoi utilizzare lo stesso approccio di guava:

  if (iterable instanceof Collection) {
        return ((Collection<?>) iterable).size();
    } else {
        int count = 0;
        Iterator iterator = iterable.iterator();
        while(iterator.hasNext()) {
            iterator.next();
            count++;
        }
        return count;
    }

Forse è un po 'tardi, ma potrebbe aiutare qualcuno. Mi sono imbattuto in un problema simile Iterablenella mia base di codice e la soluzione era quella di utilizzare for eachsenza chiamare esplicitamente values.iterator();.

int size = 0;
for(T value : values) {
   size++;
}

Puoi trasmettere il tuo iterabile a un elenco quindi usare .size () su di esso.

Lists.newArrayList(iterable).size();

Per motivi di chiarezza, il metodo sopra richiederà la seguente importazione:

import com.google.common.collect.Lists;

A rigor di termini, Iterable non ha dimensioni. Pensa alla struttura dei dati come un ciclo.

E pensa alla seguente istanza Iterable, Nessuna dimensione:

    new Iterable(){

        @Override public Iterator iterator() {
            return new Iterator(){

                @Override
                public boolean hasNext() {
                    return isExternalSystemAvailble();
                }

                @Override
                public Object next() {
                    return fetchDataFromExternalSystem();
                }};
        }};

Vorrei it.next()per il semplice motivo che next()è garantito per essere implementato, mentre remove()è un'operazione opzionale.

E next()

Restituisce l'elemento successivo nell'iterazione.

void remove()

Rimuove dalla raccolta sottostante l'ultimo elemento restituito dall'iteratore (operazione facoltativa) .

java 8 e versioni successive

StreamSupport.stream(data.spliterator(), false).count();

Per quanto mi riguarda, questi sono solo metodi diversi. Il primo lascia l'oggetto su cui stai iterando invariato, mentre i secondi lo lascia vuoto. La domanda è cosa vuoi fare. La complessità della rimozione si basa sull'implementazione del tuo oggetto iterabile. Se stai usando le collezioni, ottieni semplicemente la dimensione come è stata proposta da Kazekage Gaara - di solito è il miglior approccio in termini di prestazioni.

Perché non usi semplicemente il size()metodo sul tuo Collectionper ottenere il numero di elementi?

Iterator è solo pensato per iterare, nient'altro.

Invece di usare i loop e contare ogni elemento o usare una libreria di terze parti, possiamo semplicemente digitare l'iterabile in ArrayList e ottenere la sua dimensione.

((ArrayList) iterable).size();