Comparer plusieurs tableaux entre eux

Bonjour à tous :),

J'ai 8 tableaux composés chacun de 3 lignes et 21 colonnes. (tab1......tab8)
chaque colonne de 3 valeurs représente la valeur d'un pixel en RGB.

ex:
tab1=
1 4 7
2 5 8
3 6 9

tab2 =
10 1 54
11 2 14
12 3 87
J'aimerais pour chaque tableau, en les comparant un à un, savoir si ils ont des pixels en commun.
Si oui j'incrémente un compteur propre à un tableau (J'ai donc 8 compteur), si non -> rien.
Ici ces deux tableaux ont un pixel en commun (1,2,3)

Donc le compteur du premier tableau serait cpt1 = 1, et celui du deuxième serait cpt2 = 1.
Je veux donc que chaque tableau soit comparé aux 7 autres pour avoir 8 compteurs au final.

Je pensais donc partir sur une méthode avec des if :

Code:

---

1 2 3 4 5 6

for(int i = 0; i<21;i++){ if((tab1[0][i]==tab2[0][i]) && (tab1[1][i]==tab2[1][i]) && (tab1[2][i]==tab2[2][i])){ cpt1++; } }

---

Mais comme mes tableaux ont des noms différents je devrais faire 7 if pour chaque tableau, donc 56 if :/ Ce qui me fait un code énorme

Avez-vous une autre solution à me proposer ?

Merci beaucoup :)

Salut,

La méthode Arrays.equals(int[], int[]) permet de comparer 2 tableaux : on considère qu'ils sont égaux s'ils ont la même taille et les mêmes valeurs dans le même ordre.

Code:

---

1 2 3 4 5

int[] a= {1,2,3}; int[] b= {1,2,3}; int[] c= {3,2,1}; System.out.println( Arrays.equals(a, b) ); System.out.println( Arrays.equals(a, c) );

---

Affiche true puis false.

Si tu fais if ( Arrays.equals(a,b) && Arrays.equals(a,c) ) tu peux tester l'égalité entre 3 tableaux.

Ensuite, si tu as un tableau à 2 dimensions, c'est comme si c'était un tableau de tableaux, donc tu peux écrire :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

int[][] array1 = /*...*; int[][] array2 = /*...*/;   boolean eq=false; if ( array1.length==array2.length) { eq=true; for(int i=0; eq && i<array1.length; i++ ) { eq = Arrays.equals( array1[i], array2[i] ) ; } } System.out.println("Tableaux égaux : " + eq);

---

(Tu as aussi une méthode Arrays.deepEquals() qui fait ça toute seule, mais tu ne pourras pas t'en servir pour compter les pixels en commun).

Alors merci beaucoup je ne connaissez pas cette méthode je peux essayer de commencer avec ça.

Cette méthode ne renvoi "True" que si les tableaux ont les valeurs dans le même ordre.

Pourtant je voudrais que la détection se fasse même si les valeurs sont dans le désordre :

Code:

---

1 2 3

int[][] array1 = {{1,2,3},{12,4,5}}; int[][] array2 = {{1,2,3},{9,4,8}};

---

ici j'ai bien un pixel en commun mais ça me renvoi false

En tout cas merci je vais commencer par chercher dans ce coin là :)

Une piste intéressante serait de te créer une classe qui représente un pixel et qui contienne les 3 valeurs, pour obtenir 8 tableaux de 21 pixels.
Ensuite tu peux surcharger la méthode Object#Equals (et Object#hashcode au passage) pour que 2 pixels avec les mêmes valeurs soit considérés comme égales.
Enfin, tu pourras utiliser la méthode Arrays#binarySearch pour rechercher chaque valeur dans chaque tableau, ou passer sur des List et utiliser List#contains plutôt.

Citation:

---

Envoyé par Moux88

Code:

---

1 2 3

int[][] array1 = {{1,2,3},{12,4,5}}; int[][] array2 = {{1,2,3},{9,4,8}};

---

ici j'ai bien un pixel en commun mais ça me renvoi false

---

Non, mais il ne faut utiliser Arrays.equals() que pour le tableau de composantes évidemment. Pour le tableau de pixels, tu es obligé de le parcourir. Là, ça te rend false parce que {12,4,5} est différent de {9,4,8}.

If faut que tu parcours le premier tableau, et que tu parcours ensuite le second, comme ça, par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

int[][] array1 = {{1,2,3},{12,4,5}}; int[][] array2 = {{1,2,3},{9,4,8}}; for(int i=0; i<array1.length; i++) {   for(int[] pixel2 : array2 ) { if ( Arrays.equals(array1[i], pixel2) ) { System.out.println("Le pixel de position " + (i+1) + " dans le premier tableau se trouve aussi dans le second"); break; } }     }

---

Merci pour vos réponses. Je ne suis pas encore très à l'aise avec les classes je n'en ai qu'une pour le moment. Je vais regarder ducoup merci JohannL :)

Et je ne comprends pas ce morceau :

Citation:

---

Code:

---

1 2 3 4 5

for(int[] pixel2 : array2 ) { if ( Arrays.equals(array1[i], pixel2) ) { } }

---

---

Je ne savais pas qu'on pouvais initialiser un tableau dans un for :)
Ducoup si on traduit ça veut dire ;

Pour tableau "pixel2" allant de ? à taille tableau array2
Faire Si l'élément sélectionné est égal au pixel choisi
Alors (la suite...)

c'est bien ça ?

Citation:

---

Envoyé par Moux88

Et je ne comprends pas ce morceau :

Citation:

---

Code:

---

1 2 3 4 5

for(int[] pixel2 : array2 ) { if ( Arrays.equals(array1[i], pixel2) ) { } }

---

---

---

Il s'agit d'un forEach. Pout tout objet "object" itérable de T (dont le type est une classe implémentant directement ou indirectement Iterable<T> ou un tableau T[]), on peut écrire :

Code:

---

1 2	for(T item : object) { }

---

Ce qui revient à écrire pour T implémentant Iterable<T> :

Code:

---

1 2 3

for(Iterator<T> iterator = object.iterator(); iterator.hasNext(); ) { T item = iterator.next(); }

---

Et pour un tableau,

Code:

---

1 2 3

for(int i=0; i<object.length; i++) { T item = object[i]; }

---

Si T est un tableau de int (soit int[]), ce qui est le cas avec un int[][], qui est un tableau de int[], on peut écrire :

Code:

---

1 2 3 4

int[][] array = /*...*/ for(int i=0; i<array.length; i++) { int[] ligne = array[i]; }

---

Donc on peut écrire :

Code:

---

1 2 3

int[][] array = /*...*/ for(int[] ligne : array) { }

---

Ce qui revient au même, sauf que dans le second cas, on n'a pas de variable i, donc on ne peut connaitre l'index (la position du tableau ligne dans le tableau array). Quand on n'a pas besoin de la connaitre, on peut s'en passer et simplifier l'écriture de la boucle par un forEach.

D'ailleurs, on peut écrire, de même :

Code:

---

1 2 3 4 5

int[][] array = /*...*/ for(int[] ligne : array) { for(int valeur : ligne) { } }

---

Ah super merci :)
bon j'essaye tout ça alors !

Bonjour,

J'ai donc adapté votre code au miens merci beaucoup :)
Ce qui me donne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

int compteur =0 ; for(int i=0; i<tab1.length; i++) { for(int[] pixel2 : tab2 ) { if ( Arrays.equals(tab1[i], pixel2) ) { compteur++; break; } } } System.out.println("Common Pixels : "+ compteur);

---

j'obtiens donc entre le 1er et le deuxième tableau le nombre de pixels en commun :)

Cependant j'ai 8 tableaux (tab1 tab2 tab3 tab4....tab8), je dois donc appliquer ce code 7 fois pour chaque tableau, donc 56 fois.
J'essaye de créer une méthode mais je n'ai pas trop d'idée car mes tableaux n'ont pas le même nom.

Avez-vous une idée ?
J'ai fait ça pour la première comparaison mais ma méthode est vraiment très répétitive, désolé je ne suis pas très à l'aise encore avec les méthodes :

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 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

public void Compare_Pixels(){ int compteur =0 ; for(int i=0; i<tab1.length; i++) { for(int[] pixel2 : tab2 ) { if ( Arrays.equals(tab1[i], pixel2) ) { compteur++; break; } } for(int[] pixel3 : tab3 ) { if ( Arrays.equals(tab1[i], pixel3) ) { compteur++; break; } } for(int[] pixel4 : tab4 ) { if ( Arrays.equals(tab1[i], pixel4) ) { compteur++; break; } } for(int[] pixel5 : tab5 ) { if ( Arrays.equals(tab1[i], pixel5) ) { compteur++; break; } } for(int[] pixel6 : tab6 ) { if ( Arrays.equals(tab1[i], pixel6) ) { compteur++; break; } } for(int[] pixel7 : tab7 ) { if ( Arrays.equals(tab1[i], pixel7) ) { compteur++; break; } } for(int[] pixel8 : tab8 ) { if ( Arrays.equals(tab1[i], pixel8) ) { compteur++; break; } } } labelComplexValue.setText("Common Pixels : "+ compteur); }

---

Merci :)

Si tu fais une méthode, c'est justement pour pouvoir l'appeller plusieurs fois, avec différents tableaux en paramètre.

Si tu as une méthode, par exemple qui compte le nombre d'occurance d'une valeur dans un tableau :

Code:

---

1 2 3 4 5 6 7

public static int compte(int[] tab, int v) { int n=0; for(int i : tab) { if ( i==v ) n++; } return n; }

---

Tu peux l'appeller :

Code:

---

1 2 3 4 5 6 7 8 9

int[] tab1 = {1,2,3}; int[] tab2 = {1,2,1}; int[] tab3 = {1,1,1}; int[] tab5 = {2,3,4}; int n = compte(tab1, 1); n += compte(tab2, 1); n += compte(tab3, 1); n += compte(tab4, 1); System.out.println( "Le nombre de 1 dans tous les tableaux est : " + n);

---

Si en plus tu as la possibilité de mettre les tableaux eux-même dans un tableau, ou tout Iterable, tu pourras faire une boucle :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

int[][] tabs = { {1,2,3}, {1,2,1}, {1,1,1}, {2,3,4} };   int n=0; for(int[] tab : tabs) { n += compte(tab, 1); } System.out.println( "Le nombre de 1 dans tous les tableaux est : " + n);

---

Merci beaucoup c'est cette notion de paramètre qu'il me manquait.
Je réfléchis avec ça alors :)

Ah je suis content merci grâce à vous je viens de réaliser ma première méthode avec un return :) c'est un grand pas pour moi :
La voici :) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public static int Compare(int [][] tab){ int compteur = 0; for(int i=0;i<tab1.length;i++){ for(int[] pixel : tab){ if( Arrays.equals(tab1[i], pixel)){ compteur++; break; } } } return compteur; }   public static void Compare_Pixels(){ int compteur = Compare(tab2); labelComplexValue.setText("Common Pixels : "+ compteur); }

---