Question is simple:
I have two List
List<String> columnsOld = DBUtils.GetColumns(db, TableName);
List<String> columnsNew = DBUtils.GetColumns(db, TableName);
And I need to get the intersection of these. Is there a quick way to achieve this?
-
1@JohnnyCoder seriously?Pentium10– Pentium102015-06-03 13:33:34 +00:00Commented Jun 3, 2015 at 13:33
-
@Ungeheuer that doesn't work if you want duplicates only to be included if they are in both listsxeruf– xeruf2020-01-08 13:13:07 +00:00Commented Jan 8, 2020 at 13:13
Add a comment
|
9 Answers
You can use retainAll method:
columnsOld.retainAll (columnsNew);
3 Comments
Topper Harley
Note: for this to work with other objects than
String, you need of course to implement equals and hashCode.
John Kugelman
The code is simple but the algorithmic complexity is poor: O(n×m), versus O(n+m) for the set version. With two million-item lists it's the difference between trillions of operations and millions of operations.
razor
if you use
retainAll on Lists, it runs O(n^2)Using Google's Guava library:
Sets.intersection(Sets.newHashSet(setA), Sets.newHashSet(setB))
Note: This is much more efficient than naively doing the intersection with two lists: it's O(n+m), versus O(n×m) for the list version. With two million-item lists it's the difference between millions of operations and trillions of operations.
Comments
Since retainAll won't touch the argument collection, this would be faster:
List<String> columnsOld = DBUtils.GetColumns(db, TableName);
List<String> columnsNew = DBUtils.GetColumns(db, TableName);
for(int i = columnsNew.size() - 1; i > -1; --i){
String str = columnsNew.get(i);
if(!columnsOld.remove(str))
columnsNew.remove(str);
}
The intersection will be the values left in columnsNew. Removing already compared values fom columnsOld will reduce the number of comparisons needed.
4 Comments
Roman
But your code definitly should be extracted to a new separate method because it's absolutely unclear from this code what does it do. And I also wouln't have refused an additional unit test for this code.
bjornhol
Agree, good method separation, naming and unit tests is always rule number one.
Calon
Shouldn't this method add the elements that can not be found in the columnsOld to the columnsNew? It looks like those elements will be missing in the result.
Bogdan Calmac
The optimization of removing columns from columnsOld might actually make no difference (the remove has itself a cost) or even be slower in cases like ArrayList where a remove shifts the elements.
How about
private List<String> intersect(List<String> A, List<String> B) {
List<String> rtnList = new LinkedList<>();
for(String dto : A) {
if(B.contains(dto)) {
rtnList.add(dto);
}
}
return rtnList;
}
using retainAll if don't care occurrences, otherwise using N.intersection
a = N.asList(12, 16, 16, 17, 19);
b = N.asList(16, 19, 107);
a.retainAll(b); // [16, 16, 19]
N.println(a);
a = N.asList(12, 16, 16, 17, 19);
b = N.asList(16, 19, 107);
a = N.intersect(a, b);
N.println(a); // [16, 19]
N is an utility class in abacus-common
Comments
There is a nice way with streams which can do this in one line of code and you can two lists which are not from the same type which is not possible with the containsAll method afaik:
columnsOld.stream().filter(c -> columnsNew.contains(c)).collect(Collectors.toList());
An example for lists with different types. If you have a realtion between foo and bar and you can get a bar-object from foo than you can modify your stream:
List<foo> fooList = new ArrayList<>(Arrays.asList(new foo(), new foo()));
List<bar> barList = new ArrayList<>(Arrays.asList(new bar(), new bar()));
fooList.stream().filter(f -> barList.contains(f.getBar()).collect(Collectors.toList());
3 Comments
Андрей Щеглов
c -> columnsNew.contains(c) lambda can be rewritten more concise as a method reference: columnsNew::contains.
Aaron_H
won't this run in O(n^2) time though?
razor
This is O(n^2) ! you should use
contains on a SetIf you put the second list in a set say HashSet. And just iterate over the first list checking for presence on the set and removing if not present, your first list will eventually have the intersection you need. It will be way faster than retainAll or contains on a list. The emphasis here is to use a set instead of list. Lookups are O(1). firstList.retainAll (new HashSet (secondList)) will also work.
Comments
use org.apache.commons.collections4.ListUtils#intersection
Comments
With Java 8 Stream API (and Java 9 List.of()) you can do following:
List<Integer> list1 = List.of(1, 1, 2, 2);
List<Integer> list2 = List.of(2, 2, 3, 3);
List<Integer> intersection = list1.stream()
.filter(list2::contains)
.distinct()
.collect(Collectors.toList());
