У меня есть два arrayList, и я пытаюсь "вычесть" один arrayList из другого. Например, если у меня есть один arrayList [1,2,3], и я пытаюсь вычесть [0, 2, 4], результирующий arrayList должен быть [1,3].
List<Integer> a = new ArrayList<>(Arrays.asList(1, 2, 3));
List<Integer> b = Arrays.asList(0, 2, 4);
subtract(a,b) // should return [1,3]
Вот мой код
//returns a new IntSet after subtracting a from b
// .minus().toString()
ArrayList<Integer> minusArray = new ArrayList<Integer>();
minusArray.addAll(array1);
for(int i =0; i< minusArray.size(); i++){
for(int j = 0; j < array2.size(); j++){
if(minusArray.get(i).equals(array2.get(j))){
minusArray.remove(i);
if(i == 0){
;
}
else if(j == 0){
;
}
else{
i = 0;
j = 0;
}
}
else{}
}
}
return minusArray;
Мой код работает в некоторых случаях, например, если arrayList1 = [4,6] и arrayList2 = [6] это даст мне результат [4]. Но если я попробую что-то вроде [1,2,4] и [0,4,8]
Я получаю это исключение:
java.lang.IndexOutOfBoundsException: Index: 2, Size: 2
at java.util.ArrayList.rangeCheck(Unknown Source)
at java.util.ArrayList.get(Unknown Source)
at IntSet.minus(IntSet.java:119)
at IntSetDriver.main(IntSetDriver.java:62)
Вот код, который я придумал. Я сделал тестовые прогоны через него, и я думаю, что это должно работать. Пользователь вводит эти arrayLists и они предварительно отсортированы, я также не знаю Hash или big-O.
ArrayList<Integer> minusArray = new ArrayList<Integer>();
minusArray.addAll(array1);
for(int i =0; i< minusArray.size(); i++){
for(int j = 0; j < array2.size(); j++){
if(minusArray.get(i).equals(array2.get(j))){
minusArray.remove(i);
}
else{}
}
}
return minusArray;
Ваша проблема в том, что в вашем вызове minusArray.remove(...) вы можете уменьшить размер minusArray. Чтобы исправить это, начните с array.size() - 1 и пересчитайте назад до 0
Убедитесь, что - даже это не исправит. Вам нужно изменить порядок ваших циклов.
Есть ли причина, по которой вы не можете просто использовать List.removeAll(List)?
List<Integer> one = new ArrayList<Integer>();
one.add(1);
one.add(2);
one.add(3);
List<Integer> two = new ArrayList<Integer>();
two.add(0);
two.add(2);
two.add(4);
one.removeAll(two);
System.out.println(one);
result: "[1, 3]"
Попробуйте использовать метод вычитания класса org.apache.commons.collections.CollectionUtils.
Возвращает новую коллекцию, содержащую a - b. Мощность каждого элемента e в возвращенной Коллекции будет равна количеству элементов e в минус количество элементов e в b или ноль, в зависимости от того, что больше.
CollectionUtils.subtract(java.util.Collection a, java.util.Collection b)
Вы также можете использовать потоки:
List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(1, 2, 4, 5);
List<Integer> diff = list1.stream()
.filter(e -> !list2.contains(e))
.collect (Collectors.toList()); // (3)
Этот ответ не манипулирует первоначальным списком. Если намерение состоит в том, чтобы изменить исходный список, тогда мы можем использовать remove. Также мы можем использовать forEach (метод по умолчанию в Iterator) или поток с фильтром.
Другой вариант - использовать ListUtils если мы используем Apache common:
ListUtils.subtract(list, list2)
Это вычитает все элементы во втором списке из первого списка, помещая результаты в новый список. Это отличается от List.removeAll(Collection) тем, что количество List.removeAll(Collection) соблюдается; если list1 содержит два вхождения null а list2 содержит только одно вхождение, то возвращенный список будет по-прежнему содержать одно вхождение.
Прохождение minusArray с использованием индекса - один из способов сделать это, но я предлагаю вам использовать метод contains(Object), который позволит вам использовать remove(Object) для конкретного элемента array2.
Конечно, всегда есть removeAll(Collection), который делает практически все, что вам нужно...
Вы можете использовать org.apache.commons.collections.ListUtils и сделать все, что хотите, только в одной строке =)
List resultList = ListUtils.subtract(list, list2);
Я предполагаю, что вы получаете проблему с диапазоном, потому что вы устранили один из элементов, который меняет то, что ищет внутренний цикл (я знаю, что эта проблема возникает при работе с обычными списками и коллекциями).
То, что мне нужно было сделать в прошлом, чтобы обойти это, - это создать список элементов, которые нужно удалить (то есть те, которые находятся в исходном списке). Итерации через этот новый список и прямое удаление исходных элементов списка без необходимости прохождения итератора через него.
Попробуйте этот ответ, если
removeAll()не то, что вы хотите. например, если вас интересует что-то вроде расчета разницы двух списков с дубликатами
вычесть (а, б)
b.forEach((i)->a.remove(i));
теперь содержит
[1, 3]
Это следует за предложением разработчиков Guava о том, как реализовать вычитание
msgstr "создать ArrayList, содержащий a, а затем вызвать delete для него для каждого элемента в b."
Который ведет себя как эта реализация, используемая в Apache Commons
Разница для удаления All()
[1,2,2,3].removeAll([1,2,3]) //is empty
[1,2,3].forEach((i)->[1,2,2,3].remove(i)); //a is [2]