web-dev-qa-db-fra.com

retourne la différence entre deux listes en java

J'ai deux listes de tableaux, par exemple. 

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

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

Comment puis-je effectuer un contrôle entre list a et b afin que la valeur manquante dans b soit renvoyée? 10/10/2014

javalistobjectfiltering
25
Rory Lester

Vous pouvez les convertir en collections Set et effectuer une opération set difference sur elles.

Comme ça:

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

Si vous voulez seulement trouver les valeurs manquantes dans b, vous pouvez faire:

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

return toReturn;

Si vous souhaitez connaître les valeurs présentes dans l'une ou l'autre liste, vous pouvez exécuter le code supérieur deux fois. Avec des listes modifiées.

19
Denis Lukenich

Vous pouvez utiliser CollectionUtils à partir de Apache Commons Collections 4.0 :

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

Vous pouvez utiliser le filtre de la bibliothèque Java 8 Stream

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

Résultat:

[e, t, s]
4
Milton Jacomini Neto

Je cherchais un autre problème et je l'ai rencontré. Je vais donc ajouter ma solution à un problème connexe: comparer deux cartes.

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

Cela fonctionne sur le même principe que les autres solutions, mais compare également non seulement le fait que des valeurs sont présentes, mais qu'elles contiennent la même valeur. La plupart du temps, je l'ai utilisé dans un logiciel de comptabilité pour comparer des données provenant de deux sources (les valeurs saisies par les employés et les gestionnaires correspondent; les transactions des clients et des entreprises correspondent; ... etc.)

1
Jefferey Cave

Je ressemblais mais je voulais la différence dans l'une ou l'autre liste (éléments peu communs entre les 2 listes):

Disons que j'ai:

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

Et je voulais savoir quelle clé a été ajoutée et quelle clé a été supprimée, c'est-à-dire que je voulais obtenir (key1, key6)

Utilisation de org.Apache.commons.collections.CollectionUtils 

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

Résultat

[key1, key6]

0
justMe

Vous pouvez appeler la méthode U.difference (lists) dans underscore-Java library. Je suis le mainteneur du projet. Exemple live

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
Valentyn Kolesnikov