Conversão Java Array para Iterable

Eu tenho uma matriz de primitivas, por exemplo, para int, int [] foo. Pode ser de tamanho pequeno ou não.

int foo[] = {1,2,3,4,5,6,7,8,9,0};

Qual é a melhor maneira de criar um a Iterable<Integer>partir dele?

Iterable<Integer> fooBar = convert(foo);

Notas:

Por favor, não responda usando loops (a menos que você possa dar uma boa explicação sobre como o compilador faz algo inteligente sobre eles?)

Observe também que

int a[] = {1,2,3};
List<Integer> l = Arrays.asList(a);

Não vai nem compilar

Type mismatch: cannot convert from List<int[]> to List<Integer>

Verifique também Por que uma matriz não é atribuível à Iterable? antes de responder.

Além disso, se você usa alguma biblioteca (por exemplo, Goiaba), explique por que esse é o melhor. (Como é do Google não é uma resposta completa: P)

Por fim, como parece haver um dever de casa sobre isso, evite postar código de dever de casa.

Integer foo[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };

List<Integer> list = Arrays.asList(foo);
// or
Iterable<Integer> iterable = Arrays.asList(foo);

Embora você precise usar uma Integermatriz (não uma intmatriz) para que isso funcione.

Para primitivos, você pode usar goiaba:

Iterable<Integer> fooBar = Ints.asList(foo);

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>15.0</version>
    <type>jar</type>
</dependency>

Para Java8: (da resposta de Jin Kwon)

final int[] arr = {1, 2, 3};
final PrimitiveIterator.OfInt i1 = Arrays.stream(arr).iterator();
final PrimitiveIterator.OfInt i2 = IntStream.of(arr).iterator();
final Iterator<Integer> i3 = IntStream.of(arr).boxed().iterator();

apenas meus 2 centavos:

final int a[] = {1,2,3};

java.lang.Iterable<Integer> aIterable=new Iterable<Integer>() {

    public Iterator<Integer> iterator() {
       return new Iterator<Integer>() {
            private int pos=0;

            public boolean hasNext() {
               return a.length>pos;
            }

            public Integer next() {
               return a[pos++];
            }

            public void remove() {
                throw new UnsupportedOperationException("Cannot remove an element of an array.");
            }
        };
    }
};

Com o Java 8, você pode fazer isso.

final int[] arr = {1, 2, 3};
final PrimitiveIterator.OfInt i1 = Arrays.stream(arr).iterator();
final PrimitiveIterator.OfInt i2 = IntStream.of(arr).iterator();
final Iterator<Integer> i3 = IntStream.of(arr).boxed().iterator();

A goiaba fornece o adaptador que você deseja como Int.asList () . Existe um equivalente para cada tipo primitivo na classe associada, por exemplo, Booleanspara boolean, etc.

int foo[] = {1,2,3,4,5,6,7,8,9,0};
Iterable<Integer> fooBar = Ints.asList(foo);
for(Integer i : fooBar) {
    System.out.println(i);
}

As sugestões acima a serem usadas Arrays.asListnão funcionarão, mesmo que elas sejam compiladas porque você recebe um Iterator<int[]>e não Iterator<Integer>. O que acontece é que, em vez de criar uma lista apoiada por sua matriz, você criou uma lista de matrizes com 1 elemento, contendo sua matriz.

Eu tive o mesmo problema e resolvi-o assim:

final YourType[] yourArray = ...;
return new Iterable<YourType>() {
  public Iterator<YourType> iterator() {
     return Iterators.forArray(yourArray);   // Iterators is a Google guava utility
  }
}

O iterador em si é um preguiçoso, UnmodifiableIteratormas é exatamente isso que eu precisava.

No Java 8 ou posterior, Iterableé retornada uma interface funcional Iterator. Então você pode fazer isso.

int[] array = {1, 2, 3};
Iterable<Integer> iterable = () -> Arrays.stream(array).iterator();
for (int i : iterable)
    System.out.println(i);

->

1
2
3

Antes de tudo, só posso concordar que essa Arrays.asList(T...)é claramente a melhor solução para tipos ou matrizes de wrapper com tipos de dados não primitivos. Esse método chama um construtor de uma AbstractListimplementação estática privada simples na Arraysclasse que basicamente salva a referência da matriz especificada como campo e simula uma lista substituindo os métodos necessários.

Se você pode escolher entre um tipo primitivo ou um tipo de invólucro para sua matriz, eu usaria o tipo de invólucro para essas situações, mas é claro que nem sempre é útil ou necessário. Existem apenas duas possibilidades que você pode fazer:

1) Você pode criar uma classe com um método estático para cada matriz de tipo de dados primitiva ( boolean, byte, short, int, long, char, float, doubleretornando um Iterable<WrapperType >. Esses métodos usariam classes anônimas de Iterator(além deIterable) que têm permissão para conter a referência do argumento do método compreensivo (por exemplo, um int[]) como campo para implementar os métodos.

-> Essa abordagem é de bom desempenho e economiza memória (exceto para a memória dos métodos recém-criados, embora o uso Arrays.asList()levaria memória da mesma maneira)

2) Como as matrizes não têm métodos (como lidas na lateral) você vinculou) eles também não podem fornecer uma Iteratorinstância. Se você realmente tem preguiça de escrever novas classes, deve usar uma instância de uma classe já existente que implemente Iterableporque não há outra maneira de instanciar Iterableou um subtipo.
A ÚNICA maneira de criar um derivado de coleção existente implementandoIterableé usar um loop (exceto se você usar classes anônimas como descrito acima) ou instanciar uma Iterableclasse de implementação cujo construtor permita uma matriz de tipos primitivos (porque Object[]não permite matrizes com elementos de tipos primitivos), mas até onde eu sei, a API Java não apresenta uma classe como essa.

O motivo do loop pode ser explicado facilmente:
para cada coleção, você precisa de objetos e tipos de dados primitivos não são objetos. Os objetos são muito maiores que os tipos primitivos, de modo que requerem dados adicionais que devem ser gerados para cada elemento da matriz de tipos primitivos. Isso significa que, se duas maneiras de três (usar Arrays.asList(T...)ou usar uma coleção existente) exigirem um agregado de objetos, você precisará criar para cada valor primitivo do seuint[]matriz o objeto wrapper. A terceira maneira usaria a matriz como está e a utilizaria em uma classe anônima, pois acho que é preferível devido ao desempenho rápido.

Há também uma terceira estratégia usando um Objectargumento as para o método em que você deseja usar a matriz ou Iterablee isso exigiria verificações de tipo para descobrir qual o tipo de argumento, no entanto, eu não o recomendaria, pois você geralmente precisa considere que o objeto nem sempre tem o tipo necessário e que você precisa de código separado para determinados casos.

Concluindo, a culpa é do sistema problemático de tipo genérico do Java, que não permite usar tipos primitivos como tipo genérico, o que economizaria muito código usando simplesmenteArrays.asList(T...). Portanto, você precisa programar para cada matriz de tipos primitivos, um método desse tipo (que basicamente não faz diferença para a memória usada por um programa C ++ que criaria para cada argumento de tipo usado um método separado.

Você pode usar IterableOfdo Cactoos :

Iterable<String> names = new IterableOf<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

Em seguida, você pode transformá-lo em uma lista usando ListOf:

List<String> names = new ListOf<>(
  new IterableOf<>(
    "Scott Fitzgerald", "Fyodor Dostoyevsky"
  )
);

Ou simplesmente isso:

List<String> names = new ListOf<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

Embora uma resposta semelhante já tenha sido publicada, acho que o motivo para usar o novo PrimitiveIterator.OfInt não estava claro. Uma boa solução é usar o Java 8 PrimitiveIterator, pois é especializado em tipos int primitivos (e evita a penalidade extra de boxe / unboxing):

    int[] arr = {1,2,3};
    // If you use Iterator<Integer> here as type then you can't get the actual benefit of being able to use nextInt() later
    PrimitiveIterator.OfInt iterator = Arrays.stream(arr).iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.nextInt());
        // Use nextInt() instead of next() here to avoid extra boxing penalty
    }

Ref: https://doc.bccnsoft.com/docs/jdk8u12-docs/api/java/util/PrimitiveIterator.OfInt.html

No java8, o fluxo do IntSteam pode ser encaixotado no fluxo de inteiros.

public static Iterable<Integer> toIterable(int[] ints) {
    return IntStream.of(ints).boxed().collect(Collectors.toList());
}

Eu acho que o desempenho é importante com base no tamanho da matriz.