循环中的Arraylist

Question

So I have 2 arraylists (player1List, and player2List) each of which have 26 ints in them. I run them through a for-loop comparing two numbers from each. If one list has a number that is bigger than the other, the smaller number gets added to the winning list. However, when I run it through the for-loop at a certain point I get an "indexOutOfBoundsException: Index 21: Size 21." How do I get to run through the loop until one of the arraylists is empty? Here is my code.

    for (int i = 0; i < player1List.size; i++){
        if (player1List.get(i) < player2List.get(i)){
            System.out.printf("Player 1: %d\n", player1List.get(i));
            System.out.printf("Player 2: %d\n", player2List.get(i));
            System.out.printf("Player 2 wins round!\n");
            player2List.add(player1List.get(i));
            player1List.remove(player1List.get(i));
        }
        if (player1List.get(i) > player2List.get(i)){
            System.out.printf("Player 1: %d\n", player1List.get(i));
            System.out.printf("Player 2: %d\n", player2List.get(i));
            System.out.printf("Player 1 wins round!\n");
            player1List.add(player2List.get(i));
            player2List.remove(player2List.get(i));
        }
        if (player1List.get(i) == player2List.get(i)){

            System.out.printf("Player 1: %d\n", player1List.get(i));
            System.out.printf("Player 2: %d\n", player2List.get(i));
            System.out.printf("It's a tie, cards return to your deck.\n");

        }
        if (player1List.isEmpty()){
        System.out.printf("Player 2 wins the game.\n");
        break;
        }
        if (player2List.isEmpty()){
        System.out.printf("Player1 wins the game.\n");
        break;
        }
        }

I have asked a similar question to this, however, this is more narrowed down to what I need.

Answer 1

If you need intermediate additions to the collection to matter in the next iteration, then you need to make sure your indexes are correct. Hold two counters. When removing - do not increment. Check if the list is not bigger than the current index.

As you can see - removing and adding while iterating makes things more complex when indexes are concerned. That's why a better solution would be to use iterators:

Iterator<Foo> it1 = list1.iterator();
Iterator<Foo> it2 = list2.iterator();

while(it1.hasNext() && it2.hasNext()) {
   Foo foo1 = it1.next();
   Foo foo2 = it2.next();
   if (..) {
       it2.remove();
   }
}

When you need to add to one of the collections, add to a new collection instead, that does not interfere in the iteration.

Answer 2

int size = list2.size()>list1.size()?list1.size():list2.size();
for(int i=0; i<size;i++){
   ...//do all your work here.

  size = list2.size()>list1.size()?list1.size():list2.size();//last line in loop
}

because you are modifying your lists (ie removing elements), you should continuously check your limit; hence the last line in the loop.

Answer 3

Here we go:

ArrayList<Integer> a = new ArrayList<Integer>(
    Arrays.asList(new Integer[]{0, 1, 5}));
ArrayList<Integer> b = new ArrayList<Integer>(
    Arrays.asList(new Integer[]{3, 4, 2}));

int sA = a.size();
int sB = b.size();

for (int i = 0, j = 0; i < sA && j < sB; i++, j++) {
  int iA = a.get(i);
  int iB = b.get(j);

  if (iA < iB) {
    b.add(iA);
    a.remove(i--);
    sA--;

  } else if (iA > iB) {
    a.add(iB);
    b.remove(j--);
    sB--;
  }
}

System.out.println("a: " + a);
System.out.println("b: " + b);

Output:

a: [5, 2]
b: [3, 4, 0, 1]

Suppose there are N1 items in the first list and N2 items in the second list, the number of iterations will always be limited to the lesser of N1 and N2 . eg if N1 is 10 and N2 is 11, there will be at most 10 iterations.

When an item is transferred from one list to the other, we decrement the index counter as well as the total number of items we need to look at for the list from which the item was just removed; we don't care about the list to which the item was added, because it's always added at the end and we'll never get that far in the loop.

Comparisons are between corresponding items in the original lists before they are modified. In the above example, 5 is compared with 2, even though 5 is at the index 0 in the first list and 2 is at the index 2 in the second list by the time the comparison is actually done.