it-swarm.com.de

unterschied zwischen zwei Listen in Java zurückgeben

Ich habe zwei Array-Listen, z. 

List<Date> a;
contains : 10/10/2014, 10/11/2016

List<Date> b;
contains : 10/10/2016

Wie kann ich eine Überprüfung zwischen Liste a und b durchführen, so dass der in b fehlende Wert zurückgegeben wird, z. 10/10/2014

25
Rory Lester

Sie können sie in Set-Sammlungen konvertieren und eine set difference-Operation für sie ausführen.

So was:

Set<Date> ad = new HashSet<Date>(a);
Set<Date> bd = new HashSet<Date>(b);
ad.removeAll(bd);
39

Wenn Sie nur in b fehlende Werte finden möchten, können Sie Folgendes tun:

List toReturn = new ArrayList(a);
toReturn.removeAll(b);

return toReturn;

Wenn Sie Werte herausfinden möchten, die in einer der beiden Listen vorhanden sind, können Sie den oberen Code zweimal ausführen. Mit geänderten Listen.

19
Denis Lukenich

Sie können CollectionUtils aus Apache Commons Collections 4.0 verwenden:

new ArrayList<>(CollectionUtils.subtract(a, b))
6
contrapost

Sie können einen Filter nach der Java 8 Stream-Bibliothek verwenden

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);

Ergebnis:

[e, t, s]

Ich habe nach einem anderen Problem gesucht und bin auf dieses Problem gestoßen, deshalb werde ich meine Lösung zu einem verwandten Problem hinzufügen: dem Vergleich zweier Maps.

    // 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()));
    }

Es funktioniert nach dem gleichen Prinzip wie die anderen Lösungen, vergleicht jedoch nicht nur, dass Werte vorhanden sind, sondern dass sie denselben Wert enthalten. Meistens habe ich dies in der Buchhaltungssoftware beim Vergleich von Daten aus zwei Quellen verwendet (von Mitarbeitern und Manager eingegebene Werte stimmen überein; Kunden- und Unternehmenstransaktionen stimmen überein ...).

1
Jefferey Cave
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);

Ausgabe:

[Apple, orange, banana, strawberry]
[Apple, orange]
output
[banana, strawberry]
0

Zuerst Liste in Mengen konvertieren.

// create an empty set 
Set<T> set = new HashSet<>(); 

// Add each element of list into the set 
for (T t : list) 
    set.add(t); 

Sie können Sets.difference(Set1, Set2) verwenden, wodurch zusätzliche in Set1 vorhandene Elemente zurückgegeben werden.
Sie können Sets.difference(Set2, Set1) verwenden, um zusätzliche Elemente in Set2 zurückzugeben.

0
gs manisha

Ich sah ähnlich aus, wollte aber den Unterschied in beiden Listen (ungewöhnliche Elemente zwischen den beiden Listen):

Sagen wir, ich habe:

List<String> oldKeys = Arrays.asList("key0","key1","key2","key5");
List<String> newKeys = Arrays.asList("key0","key2","key5", "key6");

Und ich wollte wissen, welcher Schlüssel hinzugefügt wurde und welcher Schlüssel entfernt wurde, dh ich wollte (key1, key6)

Verwendung von org.Apache.commons.collections.CollectionUtils

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

Ergebnis

[key1, key6]

0
justMe

Sie können die U.difference (Listen) -Methode in Underscore-Java library aufrufen. Ich bin der Betreuer des Projekts. Live-Beispiel

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]
    }
}
0