Existe-t-il un équivalent Java de la fonction 'énumération' de Python?

Question

En Python, la fonction enumerate vous permet de parcourir une séquence de paires (index, valeur). Par exemple:

 >>> numbers = ["zero", "one", "two"]
>>> for i, s in enumerate(numbers):
...     print i, s
... 
0 zero
1 one
2 two
 

Y a-t-il un moyen de faire cela en Java?

Answer 1

Pour les collections qui mettent en œuvre l' List interface, vous pouvez appeler l' listIterator() méthode pour obtenir un ListIterator. L'itérateur a (entre autres) deux méthodes - nextIndex(), pour obtenir l'index; et next(), pour obtenir la valeur (comme les autres itérateurs).

Ainsi, un Java équivalent de l'Python ci-dessus pourrait être:

List<String> numbers = Arrays.asList("zero", "one", "two");
ListIterator<String> it = numbers.listIterator();
while (it.hasNext()) {
    System.out.println(it.nextIndex() + " " + it.next());
}

qui, comme le Python, sorties:

0 zero
1 one
2 two

Answer 2

À proprement parler, non, comme les énumérer fonction de() en Python renvoie une liste de tuples, et les tuples n'existent pas en Java.

Si toutefois, vous êtes intéressé par impression d'un index et d'une valeur, vous pouvez suivre la suggestion de Richard Fearn et d'utilisation nextIndex() et next() sur un itérateur.

Note que bien que d'énumérer() peut être défini à l'aide de la plus générale zip() fonction (en utilisant la syntaxe de Python):

mylist = list("abcd")
zip(range(len(mylist)), mylist)

donne [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

Si vous définissez vos propres Tuple de la classe (voir l' Aide de n-Uplets en Java comme un point de départ), alors vous pouvez certainement facilement rédiger votre propre zip() fonction en Java pour l'utiliser (en utilisant le n-uplet classe définie dans le lien):

public static <X,Y> List<Tuple<X,Y>> zip(List<X> list_a, List<Y> list_b) {
    Iterator<X> xiter = list_a.iterator();
    Iterator<Y> yiter = list_b.iterator();

    List<Tuple<X,Y>> result = new LinkedList<Tuple<X,Y>>();

    while (xiter.hasNext() && yiter.hasNext()) {
        result.add(new Tuple<X,Y>(xiter.next(), yiter.next()));
    }

    return result;
}

Et une fois que vous avez zip(), la mise en œuvre d'énumérer() est trivial.

Edit: journée lente au travail, donc, pour finir:

public static <X> List<Tuple<Integer,X>> enumerate (List<X> list_in) {
    List<Integer> nums = new ArrayList<Integer>(list_in.size());
    for (int x = 0; x < list_in.size(); x++) { 
        nums.add(Integer.valueOf(x));
    }

    return zip (nums, list_in);
}

Edit 2: comme l'a souligné dans les commentaires à cette question, ce n'est pas totalement équivalent. Bien qu'il produise les mêmes valeurs que Python énumérer, il ne le fait pas dans le même générative de la mode que Python énumérer ne. Ainsi, pour les grandes collections de cette approche pourrait être tout à fait prohibitif.

Answer 3

Selon le Python docs (ici), c'est le plus proche que vous pouvez obtenir avec Java, et c'est pas plus détaillé:

String[] numbers = {"zero", "one", "two"}
for (int i = 0; i < numbers.length; i++) // Note that length is a property of an array, not a function (hence the lack of () )
    System.out.println(i + " " + numbers[i]);
}

Si vous avez besoin d'utiliser l' List classe...

List<String> numbers = Arrays.asList("zero", "one", "two");
for (int i = 0; i < numbers.size(); i++) {
    System.out.println(i + " " + numbers.get(i));
}

*REMARQUE: si vous avez besoin de modifier la liste que vous êtes traversant, vous aurez besoin d'utiliser l'Itérateur de l'objet, car il a la capacité de modifier la liste sans soulever un ConcurrentModificationException.

Answer 4

List<String> list = { "foo", "bar", "foobar"};
int i = 0;
for (String str : list){
     System.out.println(i++ + str );
}

Answer 5

Non. Il existe peut-être des bibliothèques pour prendre en charge une telle fonctionnalité. Mais si vous avez recours aux bibliothèques standard, il vous appartient de compter.