Jak mogę zwrócić różnicę między dwiema listami?


Mam na przykład dwie listy tablic
List<Date> a;
contains : 10/10/2014, 10/11/2016List<Date> b;
contains : 10/10/2016

Jak mogę sprawdzić między listami
a
i
b
, aby zwrócić wartość, której nie ma w
b
? Np.
10/10/2014
Zaproszony:
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Możesz przekonwertować je na kolekcje
Set
i wykonać na nich operację ustawiania różnicy.
Podobne do tego:
Set<Date> ad = new HashSet<Date>(a);
Set<Date> bd = new HashSet<Date>(b);
ad.removeAll(bd);
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Jeśli chcesz znaleźć tylko brakujące wartości w b, możesz to zrobić:
List toReturn = new ArrayList(a);
toReturn.removeAll(b);return toReturn;

Jeśli chcesz poznać wartości obecne na dowolnej liście, możesz dwukrotnie wykonać powyższy kod. Ze zmienionymi listami.
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Wyglądałem podobnie, ale potrzebowałem różnicy w dowolnej liście (nietypowe pozycje między 2 listami):
Niech powiedzą, że mam:
List<String> oldKeys = Arrays.asList("key0","key1","key2","key5");
List<String> newKeys = Arrays.asList("key0","key2","key5", "key6");

I chciałem wiedzieć, który klucz został dodany, a który usunięty, czyli chciałem dostać

(key1, key6

)
Za pomocą

org.apache.commons.collections.CollectionUtils

List<String> list = new ArrayList<>(CollectionUtils.disjunction(newKeys, oldKeys));


Wynik

[klucz1, klucz6]
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Możesz filtrować według biblioteki strumieniowej Java 8
List<String> aList = Arrays.asList("l","e","t","'","s");
List<String> bList = Arrays.asList("g","o","e","s","t");List<String> result = aList.stream().filter(aObject -> {
return bList.contains(aObject);
}).collect(Collectors.toList());//or more reduced without curly braces and return
List<String> result2 = aList.stream().filter(aObject ->
!bList.contains(aObject)).collect(Collectors.toList());System.out.println(result);

Wynik:
[e, t, s]
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Możesz użyć CollectionUtils z

Apache Commons Collections 4.0
https://commons.apache.org/pro ... .html
:
new ArrayList<>(CollectionUtils.subtract(a, b))
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Najpierw przekonwertuj listę na zestawy.
// create an empty set 
Set<T> set = new HashSet<>();// Add each element of list into the set
for (T t : list)
set.add(t);

Możesz użyć
Sets.difference (Set1, Set2)
, która zwraca dodatkowe elementy obecne w Set1.

Możesz użyć
Sets.difference (Set2, Set1)
, która zwraca dodatkowe elementy obecne w Set2.
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Możesz wywołać metodę
U.difference (lists)
w bibliotece

underscore-java
https://github.com/javadev/underscore-java... Jestem opiekunem projektu.

Przykład na żywo
https://www.jdoodle.com/embed/v0/tIG
import com.github.underscore.U;
import java.util.Arrays;
import java.util.List;public class Main {
public static void main(String[] args) {
List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(1, 2);
List<Integer> list3 = U.difference(list1, list2);
System.out.println(list3);
// [3]
}
}
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Oto ogólne rozwiązanie tego problemu.
public <T> List<T> difference(List<T> first, List<T> second) {
List<T> toReturn = new ArrayList<>(first);
toReturn.removeAll(second);
return toReturn;
}
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

Szukałem innego problemu i natknąłem się na niego, więc dodam rozwiązanie do powiązanego problemu: porównanie dwóch kart.
// make a copy of the data
Map<String,String> a = new HashMap<String,String>(actual);
Map<String,String> e = new HashMap<String,String>(expected);
// check *every* expected value
for(Map.Entry<String, String> val : e.entrySet()){
// check for presence
if(!a.containsKey(val.getKey())){
System.out.println(String.format("Did not find expected value: %s", val.getKey()));
}
// check for equality
else{
if(0 != a.get(val.getKey()).compareTo(val.getValue())){
System.out.println(String.format("Value does not match expected: %s", val.getValue()));
}
// we have found the item, so remove it
// from future consideration. While it
// doesn't affect Java Maps, other types of sets
// may contain duplicates, this will flag those
// duplicates.
a.remove(val.getKey());
}
}
// check to see that we did not receive extra values
for(Map.Entry<String,String> val : a.entrySet()){
System.out.println(String.format("Found unexpected value: %s", val.getKey()));
}

Działa na tej samej zasadzie co inne rozwiązania, ale porównuje nie tylko to, czy wartości są obecne, ale także to, że zawierają tę samą wartość. Używałem tego głównie w oprogramowaniu księgowym przy porównywaniu danych z dwóch źródeł (dopasowanie wartości wprowadzonych przez pracownika i menedżera; dopasowanie transakcji klienta i firmy; ... itd.)
Anonimowy użytkownik

Anonimowy użytkownik

Potwierdzenie od:

List<String> l1 = new ArrayList<String>();
l1.add("apple");
l1.add("orange");
l1.add("banana");
l1.add("strawberry");List<String> l2 = new ArrayList<String>();
l2.add("apple");
l2.add("orange");System.out.println(l1);
System.out.println(l2);for (String A: l2) {
if (l1.contains(A))
l1.remove(A);
}System.out.println("output");
System.out.println(l1);

Wyjście:
[apple, orange, banana, strawberry]
[apple, orange]
output
[banana, strawberry]

Aby odpowiedzieć na pytania, Zaloguj się lub Zarejestruj się