是否存在Python的Java等价物'；s'；枚举'；功能？

在Python中，该函数允许您迭代（索引、值）对序列。例如：

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

---

在Java中有什么方法可以做到这一点吗

对于实现该接口的集合，您可以调用该方法以获取。迭代器（除其他外）有两个方法-，用于获取索引；以及获取值（与其他迭代器一样）

因此，上述Python的Java等价物可能是：

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

---

没有。可能有一些库支持这种功能。但是如果你求助于标准库，你的工作就是计数。

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

int i=0；
for（字符串str:list）{
System.out.println（i+++str）；
}

严格来说，不是，因为Python中的enumerate（）函数返回元组列表，而Java中不存在元组

但是，如果您感兴趣的只是打印出一个索引和一个值，那么您可以遵循Richard Fearn的建议&在迭代器上使用nextIndex（）和next（）

还要注意，可以使用更通用的zip（）函数（使用Python语法）定义enumerate（）：

给出[（0，'a'），（1，'b'），（2，'c'），（3，'d'）]

如果您定义自己的Tuple类（请参见作为起点），那么您当然可以轻松地用Java编写自己的zip（）函数来利用它（使用链接中定义的Tuple类）：

公共静态列表zip（列表a、列表b）{
迭代器xiter=list_a.Iterator（）；
迭代器yiter=list_b.Iterator（）；
列表结果=新建LinkedList（）；
while（xiter.hasNext（）&&yiter.hasNext（））{
添加（新元组（xiter.next（），yiter.next（））；
}
返回结果；
}

一旦有了zip（），实现enumerate（）就很简单了

编辑：放慢一天的工作进度，以便完成它：

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

公共静态列表枚举（列表中）{
List nums=newarraylist（List_in.size（））；
对于（int x=0；x

---

编辑2：正如对这个问题的评论中所指出的，这并不完全等同。虽然它生成的值与Python的enumerate相同，但它的生成方式与Python的enumerate不同。因此，对于大型集合，这种方法可能会非常令人望而却步。

根据Python文档（），这是Java最接近的方法，不再赘述：

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]);
}

---

*注意：如果在遍历列表时需要修改列表，则需要使用迭代器对象，因为它能够在不引发

ConcurrentModificationException的情况下修改列表，我认为这应该是最类似python“enumerate”的java功能，虽然这是相当复杂和低效的。基本上，只需使用ListIterator或Collector将列表的索引映射到其元素：

List<String> list = new LinkedList<>(Arrays.asList("one", "two", "three", "four"));
Map<Integer, String> enumeration = new Map<>();
ListIterator iter = list.listIterator();
while(iter.hasNext){
    map.put(iter.nextIndex(), iter.next());
}

List List=newlinkedlist（Arrays.asList（“一”、“二”、“三”、“四”）；
映射枚举=新映射（）；
ListIterator iter=list.ListIterator（）；
while（iter.hasNext）{
put（iter.nextIndex（），iter.next（））；
}

或使用lambda表达式：

Set<Integer, String> enumeration = IntStream.range(0, list.size()).boxed.collect(Collectors.toMap(index -> index, index -> list.get(index)));

Set enumeration=IntStream.range（0，list.size（））.box.collect（Collectors.toMap（index->index，index->list.get（index））；

然后，您可以将其与增强的for循环一起使用：

for (Map.Entry<Integer, String> entry : enumeration.entrySet){
    System.out.println(entry.getKey() + "\t" + entry.getValue());
}

for（Map.Entry:enumeration.entrySet）{
System.out.println（entry.getKey（）+“\t”+entry.getValue（））；
}
通过将泛型与匿名接口相结合，您基本上可以创建一个处理枚举的工厂方法。枚举器回调隐藏了迭代器的混乱性

import java.util.Arrays;
import java.util.List;
import java.util.ListIterator;

public class ListUtils2 {
    public static interface Enumerator<T> {
        void execute(int index, T value);
    };

    public static final <T> void enumerate(final List<T> list,
            final Enumerator<T> enumerator) {
        for (ListIterator<T> it = list.listIterator(); it.hasNext();) {
            enumerator.execute(it.nextIndex(), it.next());
        }
    }

    public static final void enumerate(final String[] arr,
            final Enumerator<String> enumerator) {
        enumerate(Arrays.asList(arr), enumerator);
    }

    public static void main(String[] args) {
        String[] names = { "John", "Paul", "George", "Ringo" };

        enumerate(names, new Enumerator<String>() {
            @Override
            public void execute(int index, String value) {
                System.out.printf("[%d] %s%n", index, value);
            }
        });
    }
}


延伸的思想
映射、减少、过滤
我更进一步，基于这个概念创建了map、reduce和filter函数

Google和common collections的依赖项都包含类似的功能。你可以随意查看

import java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.ListIterator；
公共类列表{
// =========================================================================
//列举
// =========================================================================
公共静态抽象接口枚举器{
void execute（int索引、T值、列表）；
};
公共静态最终无效枚举（最终列表，
最终枚举器（枚举器）{
for（ListIterator it=list.ListIterator（）；it.hasNext（）；）{
枚举数.execute（it.nextIndex（），it.next（），list）；
}
}
// =========================================================================
//地图
// =========================================================================
公共静态接口变压器{
U执行（int索引、T值、列表）；
};
公共静态最终列表转换（最终列表，
最终变压器（变压器）{
列表结果=新建ArrayList（）；
for（ListIterator it=list.ListIterator（）；it.hasNext（）；）{
添加（transformer.execute（it.nextIndex（），it.next（），list））；
}
返回结果；
}
// =========================================================================
//减少
// =========================================================================
公共静态接口减速机{
U执行（int索引、T值、U结果、列表）；
};
公共静态最终U形缩减（最终列表，
最终减速器枚举器，U结果）{
for（ListIterator it=list.ListIterator（）；it.hasNext（）；）{
结果=枚举数.execute（it.nextIndex（），it.next（），result，list）；
}
返回结果；
}
// =========================================================================
//滤器
// =================
List<String> list = new LinkedList<>(Arrays.asList("one", "two", "three", "four"));
Map<Integer, String> enumeration = new Map<>();
ListIterator iter = list.listIterator();
while(iter.hasNext){
    map.put(iter.nextIndex(), iter.next());
}

Set<Integer, String> enumeration = IntStream.range(0, list.size()).boxed.collect(Collectors.toMap(index -> index, index -> list.get(index)));

for (Map.Entry<Integer, String> entry : enumeration.entrySet){
    System.out.println(entry.getKey() + "\t" + entry.getValue());
}

import java.util.Arrays;
import java.util.List;
import java.util.ListIterator;

public class ListUtils2 {
    public static interface Enumerator<T> {
        void execute(int index, T value);
    };

    public static final <T> void enumerate(final List<T> list,
            final Enumerator<T> enumerator) {
        for (ListIterator<T> it = list.listIterator(); it.hasNext();) {
            enumerator.execute(it.nextIndex(), it.next());
        }
    }

    public static final void enumerate(final String[] arr,
            final Enumerator<String> enumerator) {
        enumerate(Arrays.asList(arr), enumerator);
    }

    public static void main(String[] args) {
        String[] names = { "John", "Paul", "George", "Ringo" };

        enumerate(names, new Enumerator<String>() {
            @Override
            public void execute(int index, String value) {
                System.out.printf("[%d] %s%n", index, value);
            }
        });
    }
}

[0] John
[1] Paul
[2] George
[3] Ringo

public static void main(String [] args) {
    List<String> strings = Arrays.asList("zero", "one", "two");
    for(EnumeratedItem<String> stringItem : ListUtils.enumerate(strings)) {
        System.out.println(stringItem.index + " " + stringItem.item);
    }
    System.out.println();
    for(EnumeratedItem<String> stringItem : ListUtils.enumerate(strings, 3)) {
        System.out.println(stringItem.index + " " + stringItem.item);
    }
}

0 zero
1 one
2 two

3 zero
4 one
5 two

import java.util.Iterator;

public class ListUtils {

    public static class EnumeratedItem<T> {
        public T item;
        public int index;

        private EnumeratedItem(T item, int index) {
            this.item = item;
            this.index = index;
        }
    }

    private static class ListEnumerator<T> implements Iterable<EnumeratedItem<T>> {

        private Iterable<T> target;
        private int start;

        public ListEnumerator(Iterable<T> target, int start) {
            this.target = target;
            this.start = start;
        }

        @Override
        public Iterator<EnumeratedItem<T>> iterator() {
            final Iterator<T> targetIterator = target.iterator();
            return new Iterator<EnumeratedItem<T>>() {

                int index = start;

                @Override
                public boolean hasNext() {
                    return targetIterator.hasNext();
                }

                @Override
                public EnumeratedItem<T> next() {
                    EnumeratedItem<T> nextIndexedItem = new EnumeratedItem<T>(targetIterator.next(), index);
                    index++;
                    return nextIndexedItem;
                }

            };
        }

    }

    public static <T> Iterable<EnumeratedItem<T>> enumerate(Iterable<T> iterable, int start) {
        return new ListEnumerator<T>(iterable, start);
    }

    public static <T> Iterable<EnumeratedItem<T>> enumerate(Iterable<T> iterable) {
        return enumerate(iterable, 0);
    }

}

Stream<String> numbers = Arrays.stream("zero one two".split(" "));
List<Indexed<String>> indexedNumbers = StreamUtils.zipWithIndex(numbers)
                                                  .collect(Collectors.toList());
for (Indexed<String> indexed : indexedNumbers) {
    System.out.println(indexed.getIndex() + " " + indexed.getValue());
}

Stream<String> numbers = Arrays.stream("zero one two".split(" "));
StreamUtils.zipWithIndex(numbers)
        .forEach(n -> System.out.println(n.getIndex() + " " + n.getValue()));

Stream<Integer> infStream = Stream.iterate(0, i -> i++);
StreamUtils.zipWithIndex(infStream)
        .limit(196)
        .forEach(n -> System.out.println(n.getIndex() + " " + n.getValue()));

public static <T> void enumerate(Iterable<T> iterable, java.util.function.ObjIntConsumer<T> consumer) {
    int i = 0;
    for(T object : iterable) {
        consumer.accept(object, i);
        i++;
    }
}

void testEnumerate() {
    List<String> strings = Arrays.asList("foo", "bar", "baz");
    enumerate(strings, (str, i) -> {
        System.out.println(String.format("Index:%d String:%s", i, str));
    });
}

    ArrayList<String> numbers = new ArrayList<String>();
    numbers.add("one");
    numbers.add("two");
    numbers.add("three");

    numbers.stream().forEach(num ->
    {
        System.out.println(numbers.indexOf(num) + " " + num);
    });