使用Java为每个循环查找元素

我想循环通过一个LinkedList，使用For each访问我现在所在的元素之后的元素。如果我使用数组和通常的

for（inti=0；I<…；I++）

，我将查找元素I+1。是否有可能在我现在所在的元素之后到达该元素？

如果对每个样式循环使用自动迭代器，例如：

for (T elem: myList) {
    // ...
}

那么，在查看当前元素时，如果不保存对上次看到的元素的引用，就无法立即访问“next”元素。使用也可以，但是当在列表中发现重复项时，这种方法会变得非常混乱。不管怎样，我认为你的问题最好用索引代替列表来解决

如果使用基于索引的访问（例如，与迭代器或每个迭代器相反）在

LinkedList

对象上进行迭代，则可以执行以下操作：

for (int i = 0; i < myList.size(); i++) {
    // ...
    if ((i + 1) < myList.size()) {
        T nextElem = myList.get(i+1); // fetch the element at the next index
        // then do whatever you want with "nextElem"
    }
    // ...
}

for（int i=0；i

其中

T

指的是您正在使用的

LinkedList

的类型，即如果列表定义类似于

LinkedList myList=new LinkedList（），则为
String

是否有可能在我现在所在的元素之后到达该元素

如果使用简单的“for each”循环，则不会。列表中的“当前位置”被编码到列表的
迭代器中。使用“for each”时，
迭代器对应用程序隐藏

相反，您需要这样做：

List<Element> list = ...
Element current = null;
Element next = null;
Iterator<Element> it = list.iterator();
while (it.hasNext()) {
    current = next;
    next = it.next();
    if (current == null) {
        continue;
    }
    // process 'current' and use `next` when you need to refer to 
    // the following on element.
}
if (next != null) {
    // process 'next' as the last element.
}

List=。。。
元素电流=零；
元素next=null；
Iterator it=list.Iterator（）；
while（it.hasNext（））{
当前=下一个；
next=it.next（）；
如果（当前==null）{
继续；
}
//处理“当前”并在需要引用时使用“下一步”
//下面是有关元素的详细信息。
}
如果（下一步！=null）{
//将“下一步”作为最后一个元素处理。
}

注:

如果
null
是有效的列表元素，则改用标志
对同一个列表使用两个迭代器可能会为您提供更简洁的解决方案
您还可以为每个
使用一个
。。。并跟踪变量中的“previous”元素，就像我上面所做的那样。见@Jezor的答案
在（大型）
LinkedList
上使用
get（i）
是不可取的，因为在一般情况下，
get（int）
是
O（N）
操作
您既不能确定中下一个元素的索引，也不能确定其值

您可以保留对上一个元素的引用，但：

// List is initialized somewhere in the code.
List<Element> elements = ...;

Element previousElement = null;
for (Element element: elements) {
    if (previousElement != null) {
        // ... your code here...
        // previousElement is elements[i]
        // element is elements[i + 1]
    }

    previousElement = element;
} 

//列表在代码中的某个地方初始化。
列表元素=。。。；
元素previousElement=null；
for（元素：元素）{
if（previousElement！=null）{
//…你的代码在这里。。。
//previousElement是元素[i]
//元素是元素[i+1]
}
previousElement=元素；
} 

在上面的示例中，您可以使用实例化previousElement以避免空检查

您真正想要使用的是好的、带有计数器的旧for循环：

List<Element> elements = ...;

for (int i = 0; i < elements.size(); ++i) {
    // elements.get(i) is elements[i]
    // elements.get(i + 1) is elements[i + 1]
    // But be careful, (i + 1) will be out of bounds for the last element!
}

列出元素=。。。；
对于（int i=0；i

不要让你的生活变得不必要的复杂。
LinkedList
实现了
List
，它有一个
get（index）
方法，你可以使用。那会怎么样？i++已经这样做了@youceplaidani您能清楚地解释一下：
是否有可能在我现在所在的元素之后到达该元素？
@Lukäs，您使用了LinkedList数据结构，并尝试进行随机访问，如果我理解正确的话。但你真的很在乎表演。我认为您选择了错误的数据结构…使用（
列表
）
迭代器
；迭代时只需在局部变量中保留“previous”值。“No”有点难，你不觉得吗？大多数可能性都是无效的，但仍然是“可能的”。。。（忽略重复项）这不会一次迭代列表两个“步骤”吗？例如，每次返回循环的顶部时，都会碰到元素#0、#2、#4、。。。等等，而不是0、1、2。。。（不要说这是错误的，只是考虑一下。）循环中每次只有一个
next（）
调用。@StephenC啊，你说得对。我以为你是在暗示在身体中调用
next（）
后续时间，但我知道你现在在做什么。而且，您要考虑到
current
在第一次传递时为空。我的错。