Convertir Java Tableau pour objet iterable

juste mes 2 cents:

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.");
            }
        };
    }
};

Goyave fournit la carte que vous voulez que Int.asList(). Il y a un équivalent pour chaque type primitif dans la classe associée, par exemple, Booleans pour 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);
}

Les suggestions ci-dessus à utiliser Arrays.asList ne fonctionne pas, même si la compilation est parce que vous obtenez un Iterator<int[]> plutôt que Iterator<Integer>. Ce qui se passe, c'est que plutôt que de créer une liste soutenue par votre tableau, vous avez créé un 1-liste d'éléments de tableaux, contenant votre tableau.

Tout d'abord, je ne peux qu'approuver que Arrays.asList(T...) est clairement la meilleure solution pour les types Wrapper ou des tableaux avec des non-primtive les types de données. Cette méthode appelle un constructeur d'une simple private static AbstractList mise en œuvre dans le Arrays classe qui, fondamentalement, enregistre la donnée de référence tableau de champ et simule une liste en surchargeant les méthodes nécessaires.

Si vous pouvez choisir entre un primtive type ou d'un type Wrapper pour votre tableau, je voudrais utiliser le Wrapper type pour de telles situations, mais bien sûr, il n'est pas toujours utile ou nécessaire.
Il n'y aurait que deux possibilités, vous pouvez:

1) Vous pouvez créer une classe avec une méthode statique pour chaque primitive de type de données array (boolean, byte, short, int, long, char, float, double retour d'un Iterable<WrapperType>. Ces méthodes anonymes classes de Iterator (en plus de Iterable) qui sont autorisés à contenir la référence de la méthode comprenant l'argumentation (par exemple un int[]) sur le terrain afin de mettre en œuvre les méthodes.

-> Cette approche est performant et vous permet d'économiser de la mémoire (sauf pour la mémoire de la création de méthodes, même si, à l'aide de Arrays.asList() prendrait la mémoire de la même façon)

2) comme les tableaux n'ont pas de méthodes (comme la lecture, sur le côté est lié) ils ne peuvent pas fournir une Iterator instance. Si vraiment vous êtes trop paresseux pour écrire de nouvelles classes, vous devez utiliser une instance d'une classe qui implémente Iterable car il n'y a pas d'autre moyen que l'instanciation de Iterable ou un sous-type.

La SEULE façon de créer une Collection existante dérivé de la mise en œuvre de Iterable est d'utiliser une boucle (sauf si vous utilisez anonyme classes comme décrit ci-dessus) ou vous instanciez un Iterable la mise en œuvre de la classe dont le constructeur permet une primtive de type array (parce que Object[] n'autorise pas les matrices de type primitif éléments), mais pour autant que je sache, l'API Java n'est pas une classe comme ça.

La raison pour que la boucle s'explique aisément:
pour chaque Collection vous avez besoin d'Objets et primtive les types de données ne sont pas des objets. Les objets sont beaucoup plus gros que le type primitif de sorte qu'ils ont besoin de données supplémentaires qui doivent être créés pour chaque élément de la primitive de type tableau. Cela signifie que si deux façons de trois (à l'aide de Arrays.asList(T...) ou à l'aide d'une Collection existante) nécessitent un agrégat d'objets, vous devez créer pour chaque primitive de la valeur de votre int[] de la matrice de l'objet wrapper. La troisième voie serait d'utiliser le tableau comme est et de l'utiliser dans une classe anonyme que je pense qu'il est préférable en raison de la rapidité de la performance.

Il y a aussi une troisième stratégie à l'aide d'un Object comme argument de la méthode où vous souhaitez utiliser le tableau ou Iterable et on aurait besoin de vérifications de type de comprendre à quel type de l'argument a, cependant je ne le recommande pas du tout comme vous avez généralement besoin à considérer que l'Objet n'a pas toujours le type et que vous avez besoin de séparer le code pour certains cas.

En conclusion, c'est la faute de Java problématique Générique Type de système qui ne permet pas d'utiliser les types primitifs comme le type générique qui permettrait d'économiser beaucoup de code en utilisant simplement Arrays.asList(T...). Si vous avez besoin de programme pour chaque type primitif tableau, vous avez besoin d', une telle méthode (qui, fondamentalement, ne fait aucune différence à la mémoire utilisée par un programme C++ qui permettrait de créer pour chaque type d'argument d'une autre méthode.

Dans Java 8 ou version ultérieure, Iterable est une interface fonctionnelle renvoie Iterator.
De sorte que vous pouvez le faire.

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

->

1
2
3

Dans java8 IntSteam cours d'eau peut être mis en boîte à flux d'Entiers.

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

Je pense que des questions de rendement en fonction de la taille de la matrice.