Comparer de tableau d'entiers

Salut la communauté.
Est ce qu'il existe en java une methode qui permet de comparer deux tableaux d'entiers et de renvoyer si possible le resultat (les elements presents dans l'un et absents dans l'autre) dans un nouveau tableau; un peu comme en php avec array_diff.Sinon est ce que quelqu'un a déjà ecrit un code comme ca.
Merci

Ca ne me dit rien.
Fait le à la main !
1. trier tes deux tableaux avec java.util.Arrays.sort
2. itérer sur les deux tableaux en parallèle et ranger les éléments dans un nouveau tableau.

Ou faire directement quelque chose du genre (mais avec des listes...)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
    List<Integer> list1 = new ArrayList<Integer>();
    for (int i = 0; i < 11; i=i+3) {
        list1.add(i);
    }
    List<Integer> list2 = new ArrayList<Integer>();
    for (int i = 0; i < 11; i = i + 2) {
        list2.add(i);
    }
    List<Integer> listNonPresent = new ArrayList<Integer>();
    List<Integer> listPresent = new ArrayList<Integer>();
    for (Integer element : list1) {
        if (list2.contains(element)) {
        listPresent.add(element);
        } else {
        listNonPresent.add(element);
        }
    }
    for (Integer element : list2) {
        if (!list1.contains(element)) {
        listNonPresent.add(element);
        }
    }

Pour faire une recherche rapide, en plus de trier ton tableau, je te conseille de faire une recherche dichotomique. Tu trouveras un exemple en java ici.

Une autre solution serait d'utiliser les ArrayList, ce serait plus simple mais je pense moins performant.

Voila la solution avec des listes (et générique en plus...) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ArrayUtil<T> {
 
    public T[] arrayDiff(T[] array1, T[] array2) {
        List<T> array1List = Arrays.asList(array1);
        List<T> array2List = Arrays.asList(array2);
        List<T> resultList = new ArrayList();
 
        for(T element : array1List) {
            if (!array2List.contains(element)) {
                resultList.add(element);
            }
        }
 
        return (T[]) resultList.toArray(new Object[resultList.size()]);
    }
 
}

J'ai pas testé le :

Code:

return (T[]) resultList.toArray(new Object[resultList.size()]);

Comme on peut pas créer un tableau générique j'ai tapé ça sans tester... :) Mais je pense que ça devrait marcher.

Salut,merci pour toutes vos réponses et désolé de n'avoir pas vite donné suite.
J'ai finalement écris un code qui marche. Je voulais juste un truc simple ; exemple comparer les tableaux tab={0,10,30,45,60} et tab1={0,15,45} puis ressortir les éléments présents dans tab et absents dans tab1 et les mettre dans le tableau compare.Voici ce que j'ai fais:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
 for(k=0;k<tab.length;k++)
	         {	 
	           for(l=0;l<tab1.length;l++)
	            {  
	              if(tab[k]==tab1[l])
	              {
	               break;
	              }
	              else p++;
	            }
	           if(p==3)
	            {
	              compare[a]=tab[k];
	              a++;
	              p=0;
	            }
	            l=0;
	            p=0;
 
	         }
	         //Affichage du tableau resultat
	         for(u=0;u<a;u++)
		       {
		         System.out.println(""+compare[u]);	         
		       }
 
	        }

Citation:

Envoyé par charles9

Salut,merci pour toutes vos réponses et désolé de n'avoir pas vite donné suite.
J'ai finalement écris un code qui marche. Je voulais juste un truc simple ; exemple comparer les tableaux tab={0,10,30,45,60} et tab1={0,15,45} puis ressortir les éléments présents dans tab et absents dans tab1 et les mettre dans le tableau compare.Voici ce que j'ai fais:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
 for(k=0;k<tab.length;k++)
	         {	 
	           for(l=0;l<tab1.length;l++)
	            {  
	              if(tab[k]==tab1[l])
	              {
	               break;
	              }
	              else p++;
	            }
	           if(p==3)
	            {
	              compare[a]=tab[k];
	              a++;
	              p=0;
	            }
	            l=0;
	            p=0;
 
	         }
	         //Affichage du tableau resultat
	         for(u=0;u<a;u++)
		       {
		         System.out.println(""+compare[u]);	         
		       }
 
	        }

Tu trouve vraiment ça plus simple que ça :

Code:

1
2
3
4
5
6
7
8
9
        List<Integer> array1List = Arrays.asList(array1);
        List<Integer> array2List = Arrays.asList(array2);
        List<Integer> resultList = new ArrayList();
 
        for(Integer element : array1List) {
            if (!array2List.contains(element)) {
                resultList.add(element);
            }
        }

En plus on comprend en un coup d'oeil ce que ça fait...

Et pour afficher :

Code:

1
2
3
        for(Integer element : resultList) {
            System.out.println("" + element.intValue());
        }

Ou obtenir un tableau :

Code:

Integer[] resultArray = resultList.toArray(new Integer[resultList.size()]);

En fait je trouve les tableaux horribles à manipuler... en général j'évite de les utiliser.