ArrayList Deduplication Problem Questions

I'm curious about removing duplicate data from an ArrayList.

Arraylist<String> a = new ArrayList<>();
Arraylist<String> b = new ArrayList<>();
    
a.add("0");
a.add("1");
a.add("2");
a.add("3");
a.add("4");
a.add("4");
a.add("1");
    
b.add("5");
b.add("6");
b.add("7");
b.add("8");
b.add("9");
b.add("10");
b.add("11");
    
for (int i = 0; i < a.size(); i++ {     
    for (int j = 0; j < a.size(); j++) {
            
        if (a.get(i).equals(a.get(j)) {
    
            a.remove(j);
            b.remove(j);
        }
    }
}

Duplicate values in a must be removed. I also want to remove values at the same index number in b.
The problem with this is that the size of a and b keeps getting smaller

Is there any good way?

From my understanding, you are trying to find the duplicate value to remove it, get its index in and from a, and then remove the value in b at that index. One big problem is that you are modifying the array AS you are trying to find the duplicated value this can cause a lot of problems. Moreover, the cause of a getting smaller (so is b) is because of

 a.remove(j);
 b.remove(j);

with the .remove() it will resize the ArrayList a and b. A way you can preserve the order and size of the array is to keep track of how many times you have removed the duplicate values and add the empty string again after the removal.

int charPos = 0;
for(int i = 0; i < a.size(); i++ {
   
  for(int j = 0; j < a.size(); j++) {
        
        if(a.get(i).equals(a.get(j)){

             a.remove(j);
             b.remove(j);
             charPos++;
        }

   }
}

for(int i = 0; i < charPos; i++) {
        a.add("");
        b.add("");
}

Your question definitely needs further clarification on what you're allowed to do and what not. It's very boarded right now. If possible please provide your expected output for the example you have given.

As always, there are many ways of achieving the same end result in programming... however nested loops are never to be desired. Also, you can not iterate over an ArrayList while removing elements from it, as you noticed. One way of achieving the result you want + better performance would be to do as follows:

(I didn't test it, but the logic makes sense inside my head... at least will give you some ideas)

        ArrayList<String> a = // initialize your array
		ArrayList<String> b = // initialize your array
		Map<String, Integer> m = new HashMap<>();

		// assign a count variable to each member of 'a'
		for (String s : a) {
			Integer count = m.get(s);
			m.put(s, count == null ? 1 : count + 1);
		}

		// find which elements of 'a' have duplicates and...
		m.forEach((key, value) -> {
            // if has duplicates... 
			if (value > 1) {
                // a) get index and remove from 'b'
				b.remove(a.indexOf(key));
                // b) remove from 'a'
				a.remove(key);
			}
		});

1. Removing duplicates from just one list<br/>
   To remove duplicates from a list, one can use a convenience method Collection::removeIf added in Java 8. The duplicates in the list may be identified by condition: x -> list.indexOf(x) != list.lastIndexOf(x);

Thus, the following code removes all duplicates from just list a:

a.removeIf(x -> a.indexOf(x) != a.lastIndexOf(x));

2. Deleting the duplicates in list a from both lists a and b<br/>
   It's better to collect the duplicates in list a into separate collection using the above-mentioned condition and then apply removeAll method to both lists:

Set<String> dups = a.stream()
                     .filter(x -> a.indexOf(x) != a.lastIndexOf(x))
                     .collect(Collectors.toSet());
a.removeAll(dups);
b.removeAll(dups);

3. Delete duplicates in a and the delete elements in b at the same indexes<br/>
   In addition to the set of duplicates dups, a list of indexes in a needs to be collected:

List<Integer> dupIndexes = IntStream.range(0, a.size())
                                    .filter(i-> i < b.size() && dups.contains(a.get(i)))
                                    .boxed()
                                    .collect(Collectors.toList());

Then the elements in b may be deleted using a reverse order (from end to start):

int index = dupIndexes.size() - 1;
for (int i = b.size() - 1; i >= 0 && index >= 0; i--) {
    int indexToDelete = dupIndexes.get(index);
    // System.out.printf("b[%d] = %s, dupIndexes[%d]=%d%n", i, b.get(i), index, indexToDelete);
    if (i == indexToDelete) {
        b.remove(indexToDelete);
        index--;
    }
}