How to keep duplicate items with set subtraction? - list

Question

By groovy way, the code like:
def l1 = [] as List;
def l2 = [] as List;
for(int i = 0; i < 5; i++) {
l1 << i;
l2 << i;
l1 << i;
}
println(l1);
println(l2);
def l = l1-l2;
println(l);
The l is empty, but I want it be [0,1,2,3,4], just subtract the item once(if there is only on item in l2).

Answer 1

It works that way, because List.minus(Object el) searches for all elements matching el object and removes them from the input list. Alternatively you can make usage of List.removeElement(Object el) which searches for the first element and removes it from the list. This method can be combined with Groovy's inject method:
def l1 = [] as List
def l2 = [] as List
for(int i = 0; i < 5; i++) {
l1 << i
l2 << i
l1 << i
}
def l3 = l2.inject(l1) { List list, el ->
list.removeElement(el)
return list
}
println "l1 is ${l1}"
println "l2 is ${l2}"
println "l3 is ${l3}"
Output:
l1 is [0, 0, 1, 1, 2, 2, 3, 3, 4, 4]
l2 is [0, 1, 2, 3, 4]
l3 is [0, 1, 2, 3, 4]
In this example we use l2 list to iterate over its elements and we pass l1 as our initial value to inject method. Then for each element from l2 list we remove the list we passed to the inject method and we return it so in the next iteration step this list is seen as list variable in the closure passed to inject. List.removeElement(Object el) is a safe method and there is no exception thrown if we try to remove an element that does not exist in the list.
However the code I have shown you has one significant drawback - it passes l1 to inject method and this list gets modified by it. That's why when you print l1 in the end you will see it is equal l3 we just created with inject method. The solution to this problem is fairly simple - instead of passing a refernce to l1 you can create a copy of this list, e.g. with new ArrayList<>(l1) and now l1 list does not gets updated by the inject method.
def l3 = l2.inject(new ArrayList<>(l1)) { List list, el ->
list.removeElement(el)
return list
}
Hope it helps.

Answer 2

The problem is that removal is done on the basis of element equality.
As an alternative, you can use indices to search the larger list, and build a diff list that includes all elements from l1 except the ones at first index of matches:
//find the first index of each l2 element in l1:
def match = l2.collect{l1.indexOf(it)}
//find indices of all elements that were not found in l1
def indices = (0..(-1+l1.size())).grep{!match.contains(it)}
//make a list of all elements that were not selected
//and that's basically the result of YOUR l1-l2
def diff = indices.collect{l1[it]}
println(diff)
That outputs:
[0, 1, 2, 3, 4]
Please note that this is not a generic method. It's completely based on your example above and assumes, for example, that l1 is a superset of l2, but it gives an idea.