web-dev-qa-db-fra.com

Un moyen simple de comparer 2 ArrayLists

J'ai 2 arraylists d'objet string.

List<String> sourceList = new ArrayList<String>();
List<String> destinationList = new ArrayList<String>();

J'ai une certaine logique dans laquelle je dois traiter la liste des sources et me retrouver avec la liste des destinations. Certains éléments supplémentaires seront ajoutés à la liste de destination ou supprimés de la liste de destination.

Ma sortie attendue est 2 ArrayList of string où la première liste doit avoir toutes les chaînes supprimées de la source et la seconde liste doit avoir toutes les chaînes nouvellement ajoutées à la source.

Une méthode plus simple pour y parvenir?

javalistarraylist
34
prabu

Convertir les listes en Collection et utiliser removeAll

    Collection<String> listOne = new ArrayList(Arrays.asList("a","b", "c", "d", "e", "f", "g"));
    Collection<String> listTwo = new ArrayList(Arrays.asList("a","b",  "d", "e", "f", "gg", "h"));


    List<String> sourceList = new ArrayList<String>(listOne);
    List<String> destinationList = new ArrayList<String>(listTwo);


    sourceList.removeAll( listTwo );
    destinationList.removeAll( listOne );



    System.out.println( sourceList );
    System.out.println( destinationList );

Sortie:

[c, g]
[gg, h]

[EDIT]

autre moyen (plus clair)

  Collection<String> list = new ArrayList(Arrays.asList("a","b", "c", "d", "e", "f", "g"));

    List<String> sourceList = new ArrayList<String>(list);
    List<String> destinationList = new ArrayList<String>(list);

    list.add("boo");
    list.remove("b");

    sourceList.removeAll( list );
    list.removeAll( destinationList );


    System.out.println( sourceList );
    System.out.println( list );

Sortie:

[b]
[boo]
58
Maxim Shoustin

Ceci devrait vérifier si deux listes sont égales, il effectue quelques vérifications de base en premier (c'est-à-dire des valeurs NULL et des longueurs), puis trie et utilise la méthode collections.equals pour vérifier si elles sont égales.

public  boolean equalLists(List<String> a, List<String> b){     
    // Check for sizes and nulls

    if (a == null && b == null) return true;


    if ((a == null && b!= null) || (a != null && b== null) || (a.size() != b.size()))
    {
        return false;
    }

    // Sort and compare the two lists          
    Collections.sort(a);
    Collections.sort(b);      
    return a.equals(b);
}
13
Husman

Convertissez le List dans en String et vérifiez si les chaînes sont identiques ou non

import Java.util.ArrayList;
import Java.util.List;



/**
 * @author Rakesh KR
 *
 */
public class ListCompare {

    public static boolean compareList(List ls1,List ls2){
        return ls1.toString().contentEquals(ls2.toString())?true:false;
    }
    public static void main(String[] args) {

        ArrayList<String> one  = new ArrayList<String>();
        ArrayList<String> two  = new ArrayList<String>();

        one.add("one");
        one.add("two");
        one.add("six");

        two.add("one");
        two.add("two");
        two.add("six");

        System.out.println("Output1 :: "+compareList(one,two));

        two.add("ten");

        System.out.println("Output2 :: "+compareList(one,two));
    }
}
4
Rakesh KR

La réponse est donnée dans @ dku-rajkumar post.

ArrayList commonList = CollectionUtils.retainAll(list1,list2);

2
Sumit Ramteke

Le moyen le plus simple consiste à parcourir les listes de sources et de destinations une à une, comme suit:

List<String> newAddedElementsList = new ArrayList<String>();
List<String> removedElementsList = new ArrayList<String>();
for(String ele : sourceList){
    if(destinationList.contains(ele)){
        continue;
    }else{
        removedElementsList.add(ele);
    }
}
for(String ele : destinationList){
    if(sourceList.contains(ele)){
        continue;
    }else{
        newAddedElementsList.add(ele);
    }
}

Bien que cela puisse ne pas être très efficace si vos listes de source et de destination comportent de nombreux éléments, il est sûrement plus simple.

1
Ishan Rastogi

Si vous souhaitez conserver l'ordre d'insertion et vérifier le contenu des deux listes, procédez comme suit:

List<String> listOne = new ArrayList<String>();
List<String> listTwo = new ArrayList<String>();

listOne.add("stack");
listOne.add("overflow");

listTwo.add("stack");
listTwo.add("overflow");

boolean result = Arrays.equals(listOne.toArray(),listTwo.toArray());

Cela reviendra vrai.

Cependant, si vous modifiez l'ordre par exemple:

listOne.add("stack");
listOne.add("overflow");

listTwo.add("overflow");
listTwo.add("stack");

boolean result = Arrays.equals(listOne.toArray(),listTwo.toArray());

retournera false car la commande est différente.

1
Nitin Chand
boolean isEquals(List<String> firstList, List<String> secondList){
    ArrayList<String> commons = new ArrayList<>();

    for (String s2 : secondList) {
        for (String s1 : firstList) {
           if(s2.contains(s1)){
               commons.add(s2);
           }
        }
    }

    firstList.removeAll(commons);
    secondList.removeAll(commons);
    return !(firstList.size() > 0 || secondList.size() > 0) ;
}
0
Nikhil

Si je comprends bien, je pense qu'il est plus facile de travailler avec 4 listes: - Votre sourceList - Votre destinationList - Un removeItemsList - Un nouvellement AddedItemsList

0
Michaël Benjamin Saerens
private int compareLists(List<String> list1, List<String> list2){
    Collections.sort(list1);
    Collections.sort(list2);

    int maxIteration = 0;
    if(list1.size() == list2.size() || list1.size() < list2.size()){
        maxIteration = list1.size();
    } else {
        maxIteration = list2.size();
    }

    for (int index = 0; index < maxIteration; index++) {
        int result = list1.get(index).compareTo(list2.get(index));
        if (result == 0) {
            continue;
        } else {
            return result;
        }
    }
    return list1.size() - list2.size();
}
0
Aniruddha