blocks|key|1464498|text|这是因为通过删除元素可以修改ArrayList的索引。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1464499|entityMap^0|E|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

This happens because by deleting the elements you modify the index of an <code>ArrayList</code>.

blocks|key|1464513|text|因为一旦删除了一个值，索引就不再好用了|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1464514|此外，你将无法转到size，因为如果你删除了一个元素，大小就会改变。|offset|length|style|CODE|1464515|您可以使用iterator来实现这一点。|1464516|entityMap^0|0|9|4|0|5|8|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

Because your index isn't good anymore once you delete a value

Moreover you won't be able to go to <code>size</code> since if you remove one element, the size as changed.

You may use an <code>iterator</code> to achieve that.

blocks|key|1464525|text|在遍历列表时，不应该删除列表中的项。相反，请使用Iterator.remove()，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1464526|for+(Iterator<Object>+it+=+list.iterator();+it.hasNext();)+{
++++if+(+condition+is+true+)+{
++++++++it.remove();
++++}
}|code-block|syntax|javascript|1464527|entityMap^0|O|H|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You shouldn't remove items from a List while you iterate over it. Instead, use <code>Iterator.remove()</code> like:

<pre><code>for (Iterator&lt;Object&gt; it = list.iterator(); it.hasNext();) {
 if ( condition is true ) {
 it.remove();
 }
}
</code></pre>

blocks|key|1464552|text|如果你把它想透了，这是完全有道理的。假设你有一个列表[A,+B,+C]。第一个循环是i+==+0。您看到元素A，然后将其删除，因此列表现在是[B,+C]，元素0是B。现在，您在循环的末尾递增i，因此您看到的是list[1]，它是C。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1464553|一种解决方案是每当您删除一个项目时递减i，以便它“抵消”随后的递增。正如matt+b上面指出的，更好的解决方案是使用具有内置remove()函数的Iterator<T>。|1464554|一般来说，当面对这样的问题时，拿出一张纸，假装你是电脑，这是一个好主意--完成循环的每一步，边走边写下所有的变量。这将使“跳过”变得清晰。|1464555|entityMap^0|Q|9|16|6|1I|1|1Y|6|29|1|2N|1|2W|7|36|1|0|J|1|1Q|8|21|B|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|19|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|K|$]]

It makes perfect sense if you think it through. Say you have a list <code>[A, B, C]</code>. The first pass through the loop, <code>i == 0</code>. You see element <code>A</code> and then remove it, so the list is now <code>[B, C]</code>, with element 0 being <code>B</code>. Now you increment <code>i</code> at the end of the loop, so you're looking at <code>list[1]</code> which is <code>C</code>.

One solution is to decrement <code>i</code> whenever you remove an item, so that it "canceles out" the subsequent increment. A better solution, as matt b points out above, is to use an <code>Iterator&lt;T&gt;</code> which has a built-in <code>remove()</code> function.

Speaking generally, it's a good idea, when facing a problem like this, to bring out a piece of paper and pretend you're the computer -- go through each step of the loop, writing down all of the variables as you go. That would have made the "skipping" clear.

blocks|key|1463953|text|这里的问题是，您正在从0到迭代大小，并且在循环中您正在删除项。删除项目将减小列表的大小，当您尝试访问大于有效大小(已删除项目之后的大小)的索引时，列表将失败。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1463954|有两种方法可以做到这一点。|1463955|如果不想处理索引，请使用迭代器删除。|1463956|for+(Iterator<Object>+it+=+data.iterator();+it.hasNext();)+{
if+(it.next().getCaption().contains("_Hardi"))+{
++++it.remove();
}
}|code-block|syntax|javascript|1463957|否则，从末尾删除。|1463958|for+(int+i+=+size-1;+i+>=+0;+i--){
++++if+(data.get(i).getCaption().contains("_Hardi")){
++++++++++++data.remove(i);
++++}
+}|1463959|entityMap^0|D|H|0|0|D|0|H|1|0|0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|17|8|@]|D|@]|E|$M|N]]|$1|S|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|T|$]]

The Problem here is you are iterating from 0 to size and inside the loop you are deleting items. Deleting the items will reduce the size of the list which will fail when you try to access the indexes which are greater than the effective size(the size after the deleted items).

There are two approaches to do this.

Delete using iterator if you do not want to deal with index.

<pre><code>for (Iterator&lt;Object&gt; it = data.iterator(); it.hasNext();) {
if (it.next().getCaption().contains("_Hardi")) {
 it.remove();
}
}
</code></pre>

Else, delete from the end.

<pre><code>for (int i = size-1; i &gt;= 0; i--){
 if (data.get(i).getCaption().contains("_Hardi")){
 data.remove(i);
 }
 }
</code></pre>

blocks|key|2461354|text|for+(Iterator<Object>+it+=+data.iterator();+it.hasNext();)+{
++++if+(+it.getCaption().contains("_Hardi"))+{
++++++++it.remove();+//+performance+is+low+O(n)
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2461355|如果您的删除操作是必需的，请在列表中列出。你最好使用LinkedList，它可以提供更好的性能大O(1)+(大致)。|unstyled|offset|length|style|BOLD|CODE|2461356|在ArrayList中，性能是O(n)+(大致)。因此对移除操作影响很大。|2461357|entityMap^0|0|Q|A|1C|4|0|F|4|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|Q|8|@$G|R|H|S|I|J]|$G|T|H|U|I|K]]|9|@]|A|$]]|$1|L|3|M|5|F|7|V|8|@$G|W|H|X|I|K]]|9|@]|A|$]]|$1|N|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|O|$]]

<pre><code>for (Iterator&lt;Object&gt; it = data.iterator(); it.hasNext();) {
 if ( it.getCaption().contains("_Hardi")) {
 it.remove(); // performance is low O(n)
 }
}
</code></pre>

If your remove operation is required much on list. Its better you use LinkedList which gives better performance Big <code>O(1)</code> (roughly).

Where in ArrayList performance is <code>O(n)</code> (roughly) . So impact is very high on remove operation.

blocks|key|2545181|text|这是因为当您从列表中删除一个元素时，该列表的元素会向上移动。因此，如果您删除索引为0的第一个元素ie，则索引为1的元素将被移至索引0，但循环计数器将在每次迭代中不断增加。所以你得到的不是第0个index元素，而是第1个index元素。因此，每次从列表中删除一个元素时，只需将计数器减1即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2545182|您可以使用以下代码使其正常工作：|2545183|for+(int+i+=+0;+i+<+data.size();+i%2B%2B){
++++if+(data.get(i).getCaption().contains("_Hardi")){
++++++++data.remove(i);
++++++++i--;
++++}
}|code-block|syntax|javascript|2545184|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Its because when you remove an element from a list, the list's elements move up. So if you remove first element ie at index 0 the element at index 1 will be shifted to index 0 but your loop counter will keep increasing in every iteration. so instead you of getting the updated 0th index element you get 1st index element. So just decrease the counter by one everytime you remove an element from your list.

You can use the below code to make it work fine :

<pre><code>for (int i = 0; i &lt; data.size(); i++){
 if (data.get(i).getCaption().contains("_Hardi")){
 data.remove(i);
 i--;
 }
}
</code></pre>

blocks|key|2545217|text|除了现有的答案之外，您还可以使用带有条件增量的常规while循环：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2545218|int+i+=+0;
while+(i+<+data.size())+{
++++if+(data.get(i).getCaption().contains("_Hardi"))
++++++++data.remove(i);
++++else+i%2B%2B;
}|code-block|syntax|javascript|2545219|请注意，每次在循环条件中都必须调用data.size()，否则将以IndexOutOfBoundsException结束，因为每次删除的项都会改变列表的原始大小。|offset|length|style|CODE|2545220|entityMap^0|0|0|H|B|X|P|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

In addition to the existing answers, you can use a regular while loop with a conditional increment:

<pre><code>int i = 0;
while (i &lt; data.size()) {
 if (data.get(i).getCaption().contains("_Hardi"))
 data.remove(i);
 else i++;
}
</code></pre>

Note that <code>data.size()</code> must be called every time in the loop condition, otherwise you'll end up with an <code>IndexOutOfBoundsException</code>, since every item removed alters your list's original size.

blocks|key|1464008|text|虽然已经很晚了，但对某些人来说可能是可行的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1464009|Iterator<YourObject>+itr+=+yourList.iterator();

//+remove+the+objects+from+list
while+(itr.hasNext())
{
++++YourObject+object+=+itr.next();
++++if+(Your+Statement)+//+id+==+0
++++{
++++++++itr.remove();
++++}
}|code-block|syntax|javascript|1464010|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It is late but it might work for someone.

<pre><code>Iterator&lt;YourObject&gt; itr = yourList.iterator();

// remove the objects from list
while (itr.hasNext())
{
 YourObject object = itr.next();
 if (Your Statement) // id == 0
 {
 itr.remove();
 }
}
</code></pre>

blocks|key|823125|text|import+java.util.ArrayList;

public+class+IteratorSample+{

++++public+static+void+main(String[]+args)+{
++++++++//+TODO+Auto-generated+method+stub

++++++++ArrayList<Integer>+al+=+new+ArrayList<Integer>();
++++++++al.add(1);
++++++++al.add(2);++++++
++++++++al.add(3);
++++++++al.add(4);

++++++++System.out.println("before+removal!!");
++++++++displayList(al);

++++++++for(int+i+=+al.size()-1;+i+>=+0;+i--){
++++++++++++if(al.get(i)==4){
++++++++++++++++al.remove(i);
++++++++++++}
++++++++}

++++++++System.out.println("after+removal!!");
++++++++displayList(al);


++++}

++++private+static+void+displayList(ArrayList<Integer>+al)+{
++++++++for(int+a:al){
++++++++++++System.out.println(a);
++++++++}
++++}

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|823126|输出：|unstyled|823127|删除前1+2+3+4|823128|删除后1+2+3|823129|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>import java.util.ArrayList;

public class IteratorSample {

 public static void main(String[] args) {
 // TODO Auto-generated method stub

 ArrayList&lt;Integer&gt; al = new ArrayList&lt;Integer&gt;();
 al.add(1);
 al.add(2); 
 al.add(3);
 al.add(4);

 System.out.println("before removal!!");
 displayList(al);

 for(int i = al.size()-1; i &gt;= 0; i--){
 if(al.get(i)==4){
 al.remove(i);
 }
 }

 System.out.println("after removal!!");
 displayList(al);


 }

 private static void displayList(ArrayList&lt;Integer&gt; al) {
 for(int a:al){
 System.out.println(a);
 }
 }

}
</code></pre>

output:

before removal!!
1
2
3
4

after removal!!
1
2
3

blocks|key|823151|text|我不明白为什么这个解决方案对大多数人来说是最好的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|823152|for+(Iterator<Object>+it+=+data.iterator();+it.hasNext();)+{
++++if+(it.next().getCaption().contains("_Hardi"))+{
++++++++it.remove();
++++}
}|code-block|syntax|javascript|823153|第三个参数为空，因为已移动到下一行。此外，it.next()不仅增加了循环变量，而且还用来获取数据。对我来说，使用for循环是一种误导。为什么不使用while|offset|length|style|CODE|823154|Iterator<Object>+it+=+data.iterator();
while+(it.hasNext())+{
++++Object+obj+=+it.next();
++++if+(obj.getCaption().contains("_Hardi"))+{
++++++++++++it.remove();
++++}
}|823155|entityMap^0|0|0|L|9|1L|3|22|5|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

I don't understand why this solution is the best for most of the people.

<pre><code>for (Iterator&lt;Object&gt; it = data.iterator(); it.hasNext();) {
 if (it.next().getCaption().contains("_Hardi")) {
 it.remove();
 }
}
</code></pre>

Third argument is empty, because have been moved to next line. Moreover <code>it.next()</code> not only increment loop's variable but also is using to get data. For me use <code>for</code> loop is misleading. Why you don't using <code>while</code>?

<pre><code>Iterator&lt;Object&gt; it = data.iterator();
while (it.hasNext()) {
 Object obj = it.next();
 if (obj.getCaption().contains("_Hardi")) {
 it.remove();
 }
}
</code></pre>

blocks|key|823190|text|有一种更简单的方法来解决这个问题，而不需要创建新的迭代器对象。这是一个概念。假设您的arrayList包含一个名称列表：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|823191|names+=+[James,+Marshall,+Susie,+Audrey,+Matt,+Carl];|code-block|syntax|javascript|823192|要删除Susie中的所有内容，只需获取Susie的索引并将其赋给一个新变量：|823193|int+location+=+names.indexOf(Susie);//index+equals+2|823194|现在您有了索引，告诉java计算您希望从arrayList中删除值的次数：|823195|for+(int+i+=+0;+i+<+3;+i%2B%2B)+{+//remove+Susie+through+Carl
++++names.remove(names.get(location));//remove+the+value+at+index+2
}|823196|每次运行循环值时，arrayList的长度都会缩短。由于您已经设置了索引值，并且正在计算删除值的次数，因此一切都设置好了。下面是每次遍历后的输出示例：|823197|+++++++++++++++++++++++++++[2]
names+=+[James,+Marshall,+Susie,+Audrey,+Matt,+Carl];//first+pass+to+get+index+and+i+=+0
+++++++++++++++++++++++++++[2]
names+=+[James,+Marshall,+Audrey,+Matt,+Carl];//after+first+pass+arrayList+decreased+and+Audrey+is+now+at+index+2+and+i+=+1
+++++++++++++++++++++++++++[2]
names+=+[James,+Marshall,+Matt,+Carl];//Matt+is+now+at+index+2+and+i+=+2
+++++++++++++++++++++++++++[2]
names+=+[James,+Marshall,+Carl];//Carl+is+now+at+index+3+and+i+=+3

names+=+[James,+Marshall,];+//for+loop+ends|823198|下面是你的最终方法的一个片段：|823199|public+void+remove_user(String+name)+{
+++int+location+=+names.indexOf(name);+//assign+the+int+value+of+name+to+location
+++if+(names.remove(name)==true)+{
++++++for+(int+i+=+0;+i+<+7;+i%2B%2B)+{
+++++++++names.remove(names.get(location));
++++++}//end+if
++++++print(name+%2B+"+is+no+longer+in+the+Group.");
}//end+method|823200|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

There is an easier way to solve this problem without creating a new iterator object. Here is the concept. Suppose your arrayList contains a list of names:

<pre><code>names = [James, Marshall, Susie, Audrey, Matt, Carl];
</code></pre>

To remove everything from Susie forward, simply get the index of Susie and assign it to a new variable:

<pre><code>int location = names.indexOf(Susie);//index equals 2
</code></pre>

Now that you have the index, tell java to count the number of times you want to remove values from the arrayList:

<pre><code>for (int i = 0; i &lt; 3; i++) { //remove Susie through Carl
 names.remove(names.get(location));//remove the value at index 2
}
</code></pre>

Every time the loop value runs, the arrayList is reduced in length. Since you have set an index value and are counting the number of times to remove values, you're all set. Here is an example of output after each pass through:

<pre><code> [2]
names = [James, Marshall, Susie, Audrey, Matt, Carl];//first pass to get index and i = 0
 [2]
names = [James, Marshall, Audrey, Matt, Carl];//after first pass arrayList decreased and Audrey is now at index 2 and i = 1
 [2]
names = [James, Marshall, Matt, Carl];//Matt is now at index 2 and i = 2
 [2]
names = [James, Marshall, Carl];//Carl is now at index 3 and i = 3

names = [James, Marshall,]; //for loop ends
</code></pre>

Here is a snippet of what your final method may look like:

<pre><code>public void remove_user(String name) {
 int location = names.indexOf(name); //assign the int value of name to location
 if (names.remove(name)==true) {
 for (int i = 0; i &lt; 7; i++) {
 names.remove(names.get(location));
 }//end if
 print(name + " is no longer in the Group.");
}//end method
</code></pre>

blocks|key|1464083|text|这是使用Arraylist时的一个常见问题，它的发生是因为Arraylist的长度(大小)可以改变。在删除时，大小也会发生变化；因此，在第一次迭代之后，您的代码就会变得混乱。最好的建议是要么使用迭代器，要么从后面循环，我推荐backword循环，因为我认为它不那么复杂，而且它仍然可以很好地处理大量元素：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1464084|//Let's+decrement!
for(int+i+=+size-1;+i+>=+0;+i--){
++++if+(data.get(i).getCaption().contains("_Hardi")){
++++++++data.remove(i);
++++}
+}|code-block|syntax|javascript|1464085|仍然是你的老代码，只是循环方式不同！|1464086|我希望这能帮到你。|1464087|编码快乐！|1464088|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is a common problem while using Arraylists and it happens due to the fact that the length (size) of an Arraylist can change. While deleting, the size changes too; so after the first iteration, your code goes haywire. Best advice is either to use Iterator or to loop from the back, I'll recommend the backword loop though because I think it's less complex and it still works fine with numerous elements:

<pre><code>//Let's decrement!
for(int i = size-1; i &gt;= 0; i--){
 if (data.get(i).getCaption().contains("_Hardi")){
 data.remove(i);
 }
 }
</code></pre>

Still your old code, only looped differently!

I hope this helps...

Merry coding!!!

I got a weird problem.
I thought this would cost me few minutes, but I am struggling for few hours now...
Here is what I got:

<pre><code>for (int i = 0; i &lt; size; i++){
 if (data.get(i).getCaption().contains("_Hardi")){
 data.remove(i);
 }
}
</code></pre>

The <code>data</code> is the <code>ArrayList.</code>
In the ArrayList I got some strings (total 14 or so), and 9 of them, got the name _Hardi in it.

And with the code above I want to remove them.
If I <code>replace data.remove(i);</code> with a <code>System.out.println</code> then it prints out something 9 times, what is good, because _Hardi is in the ArrayList 9 times.

But when I use <code>data.remove(i);</code> then it doesn't remove all 9, but only a few.
I did some tests and I also saw this:

When I rename the Strings to:
Hardi1
Hardi2
Hardi3
Hardi4
Hardi5
Hardi6

Then it removes only the on-even numbers (1, 3, 5 and so on).
He is skipping 1 all the time, but can't figure out why.

How to fix this? Or maybe another way to remove them?

Delete data from ArrayList with a For-loop

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有个奇怪的问题。我以为这会花费我几分钟的时间，但我现在已经挣扎了几个小时……下面是我得到的信息：for (int i = 0; i < size; i++){ if (data.get(i).getCaption().contains("_Hardi")){ data.remove(i); ...

问使用For循环从ArrayList中删除数据
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用For循环从ArrayList中删除数据EN