Qual é a melhor maneira de obter a contagem / comprimento / tamanho de um iterador?

Existe uma maneira "computacionalmente" rápida de obter a contagem de um iterador?

int i = 0;
for ( ; some_iterator.hasNext() ; ++i ) some_iterator.next();

... parece um desperdício de ciclos de CPU.

Se você acabou de obter o iterador, isso é o que você terá que fazer - ele não sabe quantos itens faltam para iterar, então você não pode consultá-lo para aquele resultado. Existem métodos utilitários que parecem fazer isso (como Iterators.size()no Guava), mas por baixo eles estão apenas executando aproximadamente a mesma operação.

No entanto, muitos iteradores vêm de coleções, que geralmente você pode consultar por seu tamanho. E se você está obtendo o iterador para uma classe criada pelo usuário, pode fornecer um método size () nessa classe.

Resumindo, na situação em que você tem apenas o iterador, não há maneira melhor, mas muito mais frequentemente do que não, você tem acesso à coleção ou objeto subjacente a partir do qual pode ser capaz de obter o tamanho diretamente.

Usando a biblioteca Guava :

int size = Iterators.size(iterator);

Internamente, ele itera todos os elementos, então é apenas por conveniência.

Seu código apresentará uma exceção quando você chegar ao final do iterador. Você poderia fazer:

int i = 0;
while(iterator.hasNext()) {
    i++;
    iterator.next();
}

Se você tivesse acesso à coleção subjacente, seria capaz de chamar coll.size()...

EDITAR OK, você alterou ...

Você sempre terá que iterar. No entanto, você pode usar Java 8, 9 para fazer a contagem sem repetir explicitamente:

Iterable<Integer> newIterable = () -> iter;
long count = StreamSupport.stream(newIterable.spliterator(), false).count();

Aqui está um teste:

public static void main(String[] args) throws IOException {
    Iterator<Integer> iter = Arrays.asList(1, 2, 3, 4, 5).iterator();
    Iterable<Integer> newIterable = () -> iter;
    long count = StreamSupport.stream(newIterable.spliterator(), false).count();
    System.out.println(count);
}

Isso imprime:

5

Interessante, você pode paralelizar a operação de contagem aqui, alterando o parallelsinalizador nesta chamada:

long count = StreamSupport.stream(newIterable.spliterator(), *true*).count();

Usando a biblioteca Guava , outra opção é converter o Iterablepara um List.

List list = Lists.newArrayList(some_iterator);
int count = list.size();

Use-o se também precisar acessar os elementos do iterador após obter seu tamanho. Ao usar, Iterators.size()você não pode mais acessar os elementos iterados.

Se tudo o que você tem é o iterador, então não, não há maneira "melhor". Se o iterador vier de uma coleção, você poderá definir o tamanho.

Lembre-se de que o Iterator é apenas uma interface para percorrer valores distintos, você muito bem teria um código como este

    new Iterator<Long>() {
        final Random r = new Random();
        @Override
        public boolean hasNext() {
            return true;
        }

        @Override
        public Long next() {
            return r.nextLong();
        }

        @Override
        public void remove() {
            throw new IllegalArgumentException("Not implemented");
        }
    };

ou

    new Iterator<BigInteger>() {
        BigInteger next = BigInteger.ZERO;

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

        @Override
        public BigInteger next() {
            BigInteger current = next;
            next = next.add(BigInteger.ONE);
            return current;
        }

        @Override
        public void remove() {
            throw new IllegalArgumentException("Not implemented");
        }
    }; 

Não há maneira mais eficiente se tudo o que você tem é o iterador. E se o iterador só puder ser usado uma vez, obter a contagem antes de obter o conteúdo do iterador é ... problemático.

A solução é alterar seu aplicativo para que não precise da contagem ou obter a contagem por algum outro meio. (Por exemplo, passe um em Collectionvez de Iterator...)

para Java 8 você pode usar,

public static int getIteratorSize(Iterator iterator){
        AtomicInteger count = new AtomicInteger(0);
        iterator.forEachRemaining(element -> {
            count.incrementAndGet();
        });
        return count.get();
    }

O objeto iterator contém o mesmo número de elementos que sua coleção continha.

List<E> a =...;
Iterator<E> i = a.iterator();
int size = a.size();//Because iterators size is equal to list a's size.

Mas em vez de obter o tamanho do iterador e iterar pelo índice 0 até esse tamanho, é melhor iterar por meio do método next () do iterador.