Неожиданный IndexOutOfBoundsException

Без SSCCE, который мы можем запустить сами, мы не можем дать вам ответ наверняка. Однако на основе описания и комментариев, которые вы опубликовали, вот одно из возможных объяснений, которое приходит на ум:

Вы одновременно изменяете список, который вы выполняете, таким образом, чтобы не запускать исключение ConcurrentModificationException. Несмотря на название, вполне возможно столкнуться с такой проблемой даже в одном потоке; вот простой пример (SSCCE, если хотите):

int len = ls.size();
for(int i = 0; i < len; i++) {
  if(i %2 == 0) {
    ls.remove(i);
  }
}

Поскольку это изменяет список во время итерации по нему, i отсоединяюсь от элементов списка. Вместо того, чтобы удалять четные элементы, как может быть предполагаемое поведение, это приведет к удалению 0-го, 3-го, 6-го и т.д., IndexOutOfBoundException он не IndexOutOfBoundException частично через цикл.

Как правило, правильный способ избежать этой проблемы - перебрать одну коллекцию, изменить копию или работать с Iterator на время операций удаления. Например, это безопасный способ удалить все остальные элементы - обратите внимание, что вместо работы с индексами мы работаем исключительно с итератором, который внутренне сохраняет свою позицию в списке независимо от того, что удалено:

Iterator<?> iter = ls.iterator();
while(iter.hasNext()) {
  iter.next();
  iter.remove();
  if(iter.hasNext()) {
    iter.next();
  }
}

Хорошо, давайте попробуем другой пример, основанный более непосредственно на коде в вашем цикле.

У меня есть список указателей, которые я хотел бы удалить из другого списка:

List<Integer> toRemove = Arrays.asList(0,2,4,6);
List<String> myList = new ArrayList<>(
                        Arrays.asList("A","B","C","D","E","F","G","H"));

Теперь, если я попытаюсь удалить idexes 0, 2, 4 и 6 из myList, я получу myList IndexOutOfBoundsException потому что, когда я вызываю .remove() список сжимается на единицу, а все элементы, находящиеся позже в списке, перемещаются вниз.

for(int i : toRemove) {
  myList.remove(i);
}

Хотя я не могу точно сказать, что подходит для вашего случая использования, один из вариантов заключается в том, чтобы оставить исходный список неповрежденным, изменить копию, а затем сохранить эту измененную копию после того, как все изменения были сделаны. Вот один из способов сделать это:

Set<Integer> toRemoveSet = new HashSet<>(toRemove);
List<String> cleanList = new ArrayList<>();
for(int i = 0; i < myList.size(); i++) {
  if(!toRemoveSet.contains(i)) {
    cleanList.add(myList.get(i));
  }
}
System.out.println(cleanList);

Вместо того, чтобы удалять элементы один за другим, мы проверяем, должен ли поддерживаться каждый индекс или нет, и пропустите все, что не должно. Это позволяет избежать непоследовательного состояния попыток удалить элементы из списка, который уменьшается при работе с ним.

В общем, изменчивые коллекции могут быть сложными для работы, поскольку проекты растут по размеру. Отличная библиотека Guava предоставляет набор непреложных коллекций, специально предназначенных для того, чтобы помочь людям избежать подобных проблем. Это требует немного другого способа мышления о решении проблем, но это гораздо более надежный способ. Даже если вы не используете Guava, считайте свои коллекции неизменными, когда это возможно, и создавайте защитные копии при попытке структурных изменений.