Java 元素在Arraylist的迭代过程中丢失

有人能解释一下下面的代码有什么问题吗

public static void main(String[] args) {
 List<String> l = new ArrayList<String>();
  l.add("1");
  l.add("2");
  l.add("3");
  l.add("4");

  for (int i = 0; i < l.size(); i++) {
   if(l.get(i).equals("1"))
    l.remove(l.get(i));
   else
    System.out.println(l.get(i));
  }
 }

publicstaticvoidmain（字符串[]args）{
列表l=新的ArrayList（）；
l、 添加（“1”）；
l、 添加（“2”）；
l、 添加（“3”）；
l、 添加（“4”）；
对于（int i=0；i

给我一个[3.4]的输出，而不是[2,3,4]。。我的[2]在哪里？我对列表中的这种行为感到困惑。。很好，如果有人能解释

---

提前感谢：）

调用

l.remove

后，当前元素（

l.get（i）

）将成为下一个元素（

“2”

）。
但是，在调用

remove

之后，您将继续循环并最终跳过元素

---

要解决这个问题，您可以在

if

中添加

i--

，以便新的当前元素在下一次迭代中得到处理（在

i++

之后）

调用

l.remove

后，当前元素（

l.get（i）

）最终成为下一个元素（

“2”

）。
但是，在调用

remove

之后，您将继续循环并最终跳过元素

---

要解决这个问题，您可以在

if

中添加

i--

，以便在下一次迭代（在

i++

之后）中处理新的当前元素。

SLaks是正确的，关于问题是什么，我可以建议更像这样的语法

int i=0;
while(i < l.size())
{
  if(l.get(i).equals("1"))
    l.remove(l.get(i));
  else
  {
    System.out.println(l.get(i++));
  }
}

inti=0；
而（i

SLaks对于问题所在是正确的，我建议使用类似的语法

int i=0;
while(i < l.size())
{
  if(l.get(i).equals("1"))
    l.remove(l.get(i));
  else
  {
    System.out.println(l.get(i++));
  }
}

inti=0；
而（i

原因是：
当i=0时，删除第一个元素，i变为1
当i=1时，您现在处于第三个元素，因为您已将所有元素下移了1，所以您写下“3”
当i=2时，写第三个元素，即“4”

给你一个“3”，“4”的输出

另一种实现方式可能是：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Item {
    public static void main(String[] args) {
        List<String> l = new ArrayList<String>();
        l.add("1");
        l.add("2");
        l.add("3");
        l.add("4");

        Iterator<String> iter = l.iterator();
        while(iter.hasNext())
        {
            String value = iter.next();
            if("1".equals(value))
            {
                iter.remove();
            }
            else
            {
                System.out.println(value);
            }
        }
    }
}

import java.util.ArrayList；
导入java.util.Iterator；
导入java.util.List；
公共类项目{
公共静态void main（字符串[]args）{
列表l=新的ArrayList（）；
l、 添加（“1”）；
l、 添加（“2”）；
l、 添加（“3”）；
l、 添加（“4”）；
迭代器iter=l.Iterator（）；
while（iter.hasNext（））
{
字符串值=iter.next（）；
如果（“1”。等于（值））
{
iter.remove（）；
}
其他的
{
系统输出打印项次（值）；
}
}
}
}

原因是：
当i=0时，删除第一个元素，i变为1
当i=1时，您现在处于第三个元素，因为您已将所有元素下移了1，所以您写下“3”
当i=2时，写第三个元素，即“4”

给你一个“3”，“4”的输出

另一种实现方式可能是：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Item {
    public static void main(String[] args) {
        List<String> l = new ArrayList<String>();
        l.add("1");
        l.add("2");
        l.add("3");
        l.add("4");

        Iterator<String> iter = l.iterator();
        while(iter.hasNext())
        {
            String value = iter.next();
            if("1".equals(value))
            {
                iter.remove();
            }
            else
            {
                System.out.println(value);
            }
        }
    }
}

import java.util.ArrayList；
导入java.util.Iterator；
导入java.util.List；
公共类项目{
公共静态void main（字符串[]args）{
列表l=新的ArrayList（）；
l、 添加（“1”）；
l、 添加（“2”）；
l、 添加（“3”）；
l、 添加（“4”）；
迭代器iter=l.Iterator（）；
while（iter.hasNext（））
{
字符串值=iter.next（）；
如果（“1”。等于（值））
{
iter.remove（）；
}
其他的
{
系统输出打印项次（值）；
}
}
}
}

如果您取出else，它将为您提供所需的功能

List<String> l = new ArrayList<String>();
l.add("1");
l.add("2");
l.add("3");
l.add("4");

for (int i = 0; i < l.size(); i++) {

    if(l.get(i).equals("1"))
        l.remove(l.get(i));

    System.out.println(l.get(i));
}

listl=newarraylist（）；
l、 添加（“1”）；
l、 添加（“2”）；
l、 添加（“3”）；
l、 添加（“4”）；
对于（int i=0；i

如果您取出else，它将为您提供所需的功能

List<String> l = new ArrayList<String>();
l.add("1");
l.add("2");
l.add("3");
l.add("4");

for (int i = 0; i < l.size(); i++) {

    if(l.get(i).equals("1"))
        l.remove(l.get(i));

    System.out.println(l.get(i));
}

listl=newarraylist（）；
l、 添加（“1”）；
l、 添加（“2”）；
l、 添加（“3”）；
l、 添加（“4”）；
对于（int i=0；i

如果您可以直接使用

l.remove（i）

为什么要使用

l.remove（i）

？如果您可以直接使用

l.remove（i）

为什么要使用

l.remove（i）

。。迭代器为我完成了这项工作。。但是你。糟糕的错误。。再次感谢各位：）好的。。迭代器为我完成了这项工作。。但是你。糟糕的错误。。再次感谢各位：）您应该尽可能使用迭代器删除元素，以避免手动减少索引变量。这样安全多了。当然，您不能总是使用它，但如果可以，请这样做。您应该尽可能使用迭代器删除元素，以避免手动减少索引变量。这样安全多了。当然，你不能总是使用它，但如果可以，请使用它。