Erreur de comparaison de deux matrices

Version imprimable

Bonjour à tous,
Il y a une erreur que j'arrive pas à corriger dans le code suivant:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public static void compareMatrices(char[][] mat1, char[][] mat2 ,String ch,int n) {
		ArrayList<Point> list = new ArrayList<Point>();	
		 n=ch.length()+1;
		for (int i = 0;i<n;i++) {
			for (int j = 0;j<mat1[0].length;j++) {
				if (mat1[i][j] != mat2[i][j]) {
					list.add(new Point(i+1,j+1));
					mat2[i][j] = mat1[i][j];
				}
			}
		}
		for (Point p : list) {
			System.out.println("nouvelle valeur Matrice2("+((int)p.getX()+","+ (int)p.getY()+") = " + mat2[(int)p.getX()][(int)p.getY()]));
			System.out.println();
		}

Voici l'erreur

Code:

1
2
3
 
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 8
	at M.compareMatrices(M.java:14)

Autre chose je ne comprend pas non plus pourquoi le code considère les lignes de 2 jusque à n toutes erronées pourtant ce n' est pas le cas.
:?:?
Merci à vous.

11/05/2013, 00h55
joel.drigo

Salut,

je ne sais pas ce que tu cherches à faire au juste (itérer sur des tableaux en utilisant des bornes déduites d'autres variables est plutôt tordu), mais je suppose que tu postules que tes deux matrices mat1 et mat 2 sont de mêmes dimensions déjà. qu'est que la string ch ? et pourquoi un argument n, réinitialisé dès le début de la méthode ?

or tu fais, lorsqu'une différence est détectée en i,j :

Code:

list.add(new Point(i+1,j+1));

ou j est compris entre 0 et mat1[0].length exclus, donc j+1 est compris entre 1 et mat1[0].length inclus. donc mat2[i][j] est possiblement hors bornes (même si mat1[i].length==mat2[i].length)

Je ne sais pas quel est ton appel et quel résultat il est censé donner, mais comme tu affiches les différences pour un item de coordonnées i,j mais que la valeur qui est affichée est celle de la case i+1,j+1 tu affiches forcément des valeurs qui ne correspondent pas à celles testées comme différentes.

en clair : si une différence est détectée entre mat1[i0][j0] et mat2[i0][j0] tu affiches la valeur de la case mat1[i0+1][j0+1]

le +1 explique que ça commence en 2ème ligne ( et probablement en deuxième colonne).

Re bonjour,

J'ai fais une erreur tout à l'heure, le code était :

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
import java.util.ArrayList;
import java.awt.Point;

public class Matrice {
 	
	public static void main(String[] args) {
		
		String[][] matrice1 = { {"1", "0", "0", "1", "0", "0", "0", "0"},
					{"1", "0", "0", "0", "1", "0", "1", "1"},
					{"1", "0", "0", "1", "1", "0", "0", "1"},
					{"1", "0", "0", "1", "1", "0", "0", "1"},
					{"1", "0", "0", "1", "1", "1", "0", "1"},
					{"1", "0", "0", "0", "0", "1", "0", "0"}};
					
		String[][] matrice2 = { {"1", "0", "0", "1", "0", "0", "0", "0"},
					{"1", "0", "0", "0", "1", "0", "1", "1"},
					{"1", "0", "0", "0", "1", "0", "0", "1"},
					{"1", "0", "0", "1", "1", "0", "0", "1"},
					{"1", "0", "0", "1", "1", "1", "1", "1"},
					{"1", "0", "0", "0", "0", "1", "0", "0"}};
					
		ArrayList<Point> listeErreurs = compareMatrices( matrice1, matrice2);
		for (Point p : listeErreurs) {
			System.out.println("Erreur ligne " + p.getX() + " et colonne " + p.getY() );
			System.out.println("nouvelle valeur Matrice2("+((int)p.getX()+","+ (int)p.getY()+") = " + matrice2[(int)(p.getX()-1)][(int)(p.getY()-1)]));
			System.out.println();
		}
		
	}
	
	public static ArrayList<Point> compareMatrices(String[][] mat1, String[][] mat2) {
		ArrayList<Point> list = new ArrayList<Point>();
		for (int i = 0;i<mat1.length;i++) {
			for (int j = 0;j<mat1[0].length;j++) {
				if (mat1[i][j] != mat2[i][j]) {
					list.add(new Point(i+1,j+1));
					mat2[i][j] = mat1[i][j];
				}
			}
		}
		return list;
	}
}

donc fait pareil ici. par contre n n'a rien à faire dans les parametres de la méthode puisque tu le definis apres

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void compareMatrices(char[][] mat1, char[][] mat2 ,String ch,int n) {
		ArrayList<Point> list = new ArrayList<Point>();	
		 int n=ch.length()+1;
		for (int i = 0;i<n;i++) {
			for (int j = 0;j<mat1[0].length;j++) {
				if (mat1[i][j] != mat2[i][j]) {
					list.add(new Point(i+1,j+1));
					mat2[i][j] = mat1[i][j];
				}
			}
		}
		for (Point p : list) {
			System.out.println("nouvelle valeur Matrice2("+((int)p.getX()+","+ (int)p.getY()+") = " + mat2[(int)(p.getX()-1)][(int)(p.getY()-1)]));
			System.out.println();
		}

11/05/2013, 01h10
joel.drigo

hum, pour comparer des matrices de char on peut faire :

Code:

if (mat1[i][j] != mat2[i][j])

mais pour des matrices de String, il faut faire :

Code:

if (!mat1[i][j].equals(mat2[i][j]))

Citation:

Envoyé par ludomacho

Re bonjour,

J'ai fais une erreur tout à l'heure, le code était :

donc fait pareil ici. par contre n n'a rien à faire dans les parametres de la méthode puisque tu le definis apres

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void compareMatrices(char[][] mat1, char[][] mat2 ,String ch,int n) {
		ArrayList<Point> list = new ArrayList<Point>();	
		 int n=ch.length()+1;
		for (int i = 0;i<nh;i++) {
			for (int j = 0;j<mat1[0].length;j++) {
				if (mat1[i][j] != mat2[i][j]) {
					list.add(new Point(i+1,j+1));
					mat2[i][j] = mat1[i][j];
				}
			}
		}
		for (Point p : list) {
			System.out.println("nouvelle valeur Matrice2("+((int)p.getX()+","+ (int)p.getY()+") = " + mat2[(int)(p.getX()-1)][(int)(p.getY()-1)]));
			System.out.println();
		}

Salut merci à vous
j'ai fai la meme chose effectivement mais voici l'erreur suivant:

Code:

1
2
3
 
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 7
	at M.compareMatrices(M.java:75)

Avec le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public static void compareMatrices(char[][] mat1, char[][] mat2 ) {
		ArrayList<Point> list = new ArrayList<Point>();	
 
		for (int i = 0;i<mat1.length;i++) {
			for (int j = 0;j<mat1[0].length;j++) {
				if (mat1[i][j] != mat2[i][j]) {
					list.add(new Point(i+1,j+1));
					mat2[i][j] = mat1[i][j];
				}
			}
		}
		for (Point p : list) {
			System.out.println("nouvelle valeur Matrice2("+((int)p.getX()+","+ (int)p.getY()+") = " + mat2[(int)(p.getX()-1)][(int)(p.getY()-1)]));
			System.out.println();
		}

Le problème c 'est au niveau de:

Code:

if (mat1[i][j] != mat2[i][j])

11/05/2013, 02h05
joel.drigo
si tu continues à avoir une erreur d'index hors bornes dans la ligne :

Code:

if (mat1[i][j] != mat2[i][j])

c'est que tes 2 matrices n'ont pas la même taille.

ajoutes au début de ta méthode :
Code:

1 2 3 if ( mat1.length!=mat2.length || mat1[0].length!=mat2[0].length ){ throw new IllegalArgumentException(); }
pour t'en assurer...
11/05/2013, 03h35
proc02

Citation:

Envoyé par joel.drigo

pour t'en assurer...

Salut à tous
dans le cas ou les deux matrices auraient des tailles differentes s'il vous plait aider ce debutant :D à modifier le code precedent.
Merci

ça dépend de ce que tu veux faire :

1) si on veut que la matrice mat2 ne change pas de taille :

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
public static void compareMatrices(char[][] mat1, char[][] mat2 ) {
 
                int height=mat1.length<mat2.length?mat1.length:mat2.length;
                int width;
                if ( height==0 ) {
                    width=0;
                }
                else {
                    width=mat1[0].length<mat2.length?mat1.length:mat2.length; 
                }
		ArrayList<Point> diff = new ArrayList<Point>();	
		ArrayList<Point> onlyinmat1 = new ArrayList<Point>();	
		ArrayList<Point> onlyinmat2 = new ArrayList<Point>();	
 
                int i=0;
		for (;i<height;i++) {
                        int j = 0
			for (;j<width;j++) {
				if (mat1[i][j] != mat2[i][j]) {
					diff.add(new Point(i+1,j+1));
					mat2[i][j] = mat1[i][j];
				}
			}
			for (;j<mat1[0].length;j++) {
				onlyinmat1.add(new Point(i+1,j+1));
			}
			for (;j<mat2[0].length;j++) {
				onlyinmat2.add(new Point(i+1,j+1));
			}
		}
		for (;i<mat1.length;i++) {
		      onlyinmat1.add(new Point(i+1,1));
		}
		for (;i<mat2.length;i++) {
		      onlyinmat2.add(new Point(i+1,1));
		}
		for (Point p : diff) {
			System.out.println("nouvelle valeur Matrice2("+((int)p.getX()+","+ (int)p.getY()+") = " + mat2[(int)(p.getX()-1)][(int)(p.getY()-1)]));
			System.out.println();
 
                for(Point p:onlyinmat1){
			System.out.println("valeur seulement dans Matrice1("+((int)p.getX()+","+ (int)p.getY()+") = " + mat1[(int)(p.getX()-1)][(int)(p.getY()-1)]));
			System.out.println();
                }
                for(Point p:onlyinmat2){
			System.out.println("valeur seulement dans Matrice2("+((int)p.getX()+","+ (int)p.getY()+") = " + mat2[(int)(p.getX()-1)][(int)(p.getY()-1)]));
			System.out.println();
                }

2) tu veux que ta matrice 2 prenne la taille de ta matrice 1

pour faire ça, on ne peut pas utiliser la même signature de méthode, parce que pour redimensionner un tableau en java, il faut en créer un nouveau, et donc sa référence va changer.

de plus, la nouvelle matrice peut s'agrandir, il faut donc décider de quelle valeur va être mise dans les nouvelles lignes et colonnes.

donc il faut complètement changer la solution.

je te propose donc une solution très différente, plus orientée objet.

je ne m'étale pas dans les explications, si tu as des questions, n'hésite pas. c'est une version rapidement faite, mais c'est une bonne base.

tout d'abord on va créer une classe Difference, pour représenter une différence :

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
public class Difference {
 
	public final static Comparator<Difference> DEFAULT_COMPARATOR = new Comparator<Difference>() {
 
	public int compare(Difference o1, Difference o2) {
			if ( o1.getType()==o2.getType() ) {
				return -1;
			}
			if ( o1.getType()==Type.DIFF ) {
				return -1;
			}
			if ( o2.getType()==Type.DIFF ) {
				return 1;
			}
			if ( o1.getType()==Type.MAT1 ) {
				return -1;
			}
			if ( o2.getType()==Type.MAT1 ) {
				return 1;
			}
			return -1;
		}
 
	};
 
	public enum Type {
		DIFF, // une valeur différente dans les 2 matrices
		MAT1, // une valeur n'existant que dans la matrice 1
		MAT2 // une valeur n'existant que dans la matrice 2
	}
 
	private Type type;
	private int lig;
	private int col;
	private char valeur1;
	private char valeur2;
 
	/**
         * 
         */
	public Difference(Type type, int lig, int col, char valeur1, char valeur2) {
		this.type=type;
		this.lig=lig;
		this.col=col;
		this.valeur1=valeur1;
		this.valeur2=valeur2;
	}
 
	public Type getType() {
		return type;
	}
 
	public int getLigne() {
		return lig+1;
	}
 
	public int getColonne() {
		return col+1;
	}
 
	public char getValeurMatrice1() {
		return valeur1;
	}
 
	public char getValeurMatrice2() {
		return valeur2;
	}
 
	@Override
	public String toString() {
		switch (type) {
		case DIFF:
			return "Valeur différente en ("+getLigne()+","+getColonne()+"): valeur dans matrice 1="+valeur1+", valeur dans matrice 2="+valeur2;
		case MAT1:
			return "Valeur uniquement dans matrice 1 en ("+getLigne()+","+getColonne()+"): valeur="+valeur1;
		case MAT2:
			return "Valeur uniquement dans matrice 2 en ("+getLigne()+","+getColonne()+"): valeur="+valeur2;
		default:
			break;
		}
		return super.toString();
	}
 
}

Puis une classe Matrice :

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
public class Matrice {
 
	public final static char DEFAULT_CHAR='0'; // le caractère par défaut lorsqu'on agrandit une matrice
 
	private char[][] data;
 
	/**
         * Créer une matrice à partir du tableau en argument
         * 
         * @param data
         */
	public Matrice(char[][] data) {
		this.data = new char[data.length][data.length == 0 ? 0 : data[0].length];
		for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[0].length; j++) {
				setData(i, j, data[i][j]);
			}
		}
	}
 
	/**
         * Créer une matrice de dimensions spécifiées en arguments
         * 
         * @param lig
         * @param col
         */
	public Matrice(int lig, int col) {
		if (lig < 0 || col < 0)
			throw new IllegalArgumentException(
					"Les dimensions doivent être supérieures ou égales à 0");
		if (lig == 0 && col > 0)
			throw new IllegalArgumentException(
					"Une matrice sans ligne ne peut pas avoir de colonne");
		this.data = new char[lig][col];
		for (int i = 0; i < data.length; i++) {
			for (int j = 0; j < data[0].length; j++) {
				setData(i, j, DEFAULT_CHAR);
			}
		}
	}
 
	/**
         * 
         * @param mat
         */
	public Matrice(Matrice mat) {
		this(mat.data);
	}
 
	public char getData(int lig, int col) {
		return data[lig][col];
	}
 
	public void setData(int lig, int col, char c) {
		data[lig][col] = c;
	}
 
	/**
         * Remplit la matrice avec les données du tableau, sans changer ses
         * dimensions
         * 
         * @param data
         */
	public void setData(char[][] data) {
		for (int i = 0; i < data.length && i < this.data.length; i++) {
			for (int j = 0; j < data[0].length && j < this.data[0].length; j++) {
				setData(i, j, data[i][j]);
			}
		}
	}
 
	public void setData(Matrice mat) {
		setData(mat.data);
	}
 
	public void redimensionne(int lig, int col) {
		Matrice m = new Matrice(lig, col);
		m.setData(this.data);
		this.data = m.data;
	}
 
	public int getNbLignes() {
		return data.length;
	}
 
	public int getNbColonnes() {
		return data.length == 0 ? 0 : data[0].length;
	}
 
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < data.length; i++) {
			if (i > 0)
				sb.append('\n');
			for (int j = 0; j < data[0].length; j++) {
				sb.append('[').append(data[i][j]).append(']');
			}
		}
		return sb.toString();
	}
 
	@Override
	public int hashCode() {
		return getNbLignes() << 8 + getNbColonnes(); // version simplifiée d'un
														// hashcode
	}
 
	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Matrice) {
			Matrice mat = (Matrice) obj;
			if (mat.getNbLignes() == getNbLignes()
					&& mat.getNbColonnes() == getNbColonnes()) {
				for (int i = 0; i < data.length; i++) {
					for (int j = 0; j < data[0].length; j++) {
						if (getData(i, j) != mat.getData(i, j))
							return false;
					}
				}
				return true;
			} else {
				return false;
			}
		}
		return super.equals(obj);
	}
 
	public List<Difference> getDifferences(Matrice mat2) {
		List<Difference> diff=new ArrayList<Difference>();
		int lig=Math.min(getNbLignes(),mat2.getNbLignes());
	    int col;
	    if ( lig==0 ) {
	        col=0;
	    }
	    else {
	        col=Math.min(getNbColonnes(), mat2.getNbColonnes()); 
	    }
	    int i=0;
		for (;i<lig;i++) {
	        int j = 0;
			for (;j<col;j++) {
				if (getData(i,j) != mat2.getData(i,j)) {
					diff.add(new Difference(Difference.Type.DIFF,i,j,getData(i,j),mat2.getData(i,j)));
				}
			}
			for (;j<getNbColonnes();j++) {
				diff.add(new Difference(Difference.Type.MAT1,i,j,getData(i,j),DEFAULT_CHAR));
			}
			for (;j<mat2.getNbColonnes();j++) {
				diff.add(new Difference(Difference.Type.MAT2,i,j,DEFAULT_CHAR,mat2.getData(i,j)));
			}
		}
		for (;i<getNbLignes();i++) {
			diff.add(new Difference(Difference.Type.MAT1,i,0,getData(i,0),DEFAULT_CHAR));
		}
		for (;i<mat2.getNbLignes();i++) {
			diff.add(new Difference(Difference.Type.MAT2,i,0,DEFAULT_CHAR,mat2.getData(i,0)));
		}
		// on tri les différences pour l'affichage
		Collections.sort(diff, Difference.DEFAULT_COMPARATOR);
		return diff;
	}
 
}

et enfin une classe d'éxécution :

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
public class ExempleMatrice {
 
	public static void main(String[] args) {
		System.out.println("Cas matrices de mêmes tailles");
		memesTailles();
		System.out.println("Cas matrice 1 plus petite");
		mat1PlusPetite();
		System.out.println("Cas matrice 2 plus petite");
		mat2PlusPetite();
		System.out.println("Cas de ton exemple");
		casExemple();
	}
 
	private static void casExemple() {
 
		Matrice mat1 = new Matrice(new char[][]{
				{'1', '0', '0', '0', '1', '0', '1', '1'},
				{'1', '0', '0', '1', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '1', '0', '1'},
				{'1', '0', '0', '0', '0', '1', '0', '0'}});
 
		Matrice mat2 = new Matrice(new char[][]{ 
				{'1', '0', '0', '1', '0', '0', '0', '0'},
				{'1', '0', '0', '0', '1', '0', '1', '1'},
				{'1', '0', '0', '0', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '1', '1', '1'},
				{'1', '0', '0', '0', '0', '1', '0', '0'}});
 
		diffEtModif(mat1,mat2);
 
	}
 
	private static void memesTailles() {
 
		Matrice mat1 = new Matrice(new char[][]{
				{'1', '0', '0', '0', '1', '0', '1', '1'},
				{'1', '0', '0', '1', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '1', '0', '1'},
				{'1', '0', '0', '0', '0', '1', '0', '0'}});
 
		Matrice mat2 = new Matrice(new char[][]{ 
				{'1', '0', '0', '1', '0', '0', '0', '0'},
				{'1', '0', '0', '0', '1', '0', '1', '1'},
				{'1', '0', '0', '0', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '1', '1', '1'}});
 
		diffEtModif(mat1,mat2);
 
	}
 
	private static void mat1PlusPetite() {
 
		Matrice mat1 = new Matrice(new char[][]{
				{'1', '0', '0', '0', '1', '0', '1'},
				{'1', '0', '0', '1', '1', '0', '0'},
				{'1', '0', '0', '1', '1', '0', '0'},
				{'1', '0', '0', '1', '1', '1', '0'}});
 
		Matrice mat2 = new Matrice(new char[][]{ 
				{'1', '0', '0', '1', '0', '0', '0', '0'},
				{'1', '0', '0', '0', '1', '0', '1', '1'},
				{'1', '0', '0', '0', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '1', '1', '1'}});
 
		diffEtModif(mat1,mat2);
 
	}
 
	private static void mat2PlusPetite() {
 
		Matrice mat1 = new Matrice(new char[][]{
				{'1', '0', '0', '0', '1', '0', '1', '1'},
				{'1', '0', '0', '1', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '0', '0', '1'},
				{'1', '0', '0', '1', '1', '1', '0', '1'},
				{'1', '0', '0', '0', '0', '1', '0', '0'}});
 
		Matrice mat2 = new Matrice(new char[][]{ 
				{'1', '0', '0', '1', '0', '0', '0'},
				{'1', '0', '0', '0', '1', '0', '1'},
				{'1', '0', '0', '0', '1', '0', '0'},
				{'1', '0', '0', '1', '1', '0', '0'}});
 
		diffEtModif(mat1,mat2);
 
	}
 
	private static void diffEtModif(Matrice mat1, Matrice mat2) {
		System.out.println("Matrice 1:");
		System.out.println(mat1);
		System.out.println("Matrice 2:");
		System.out.println(mat2);
		if ( mat1.equals(mat2) ) {
			System.out.println("Pas de différences");
		}
		else {
			List<Difference> differences = mat1.getDifferences(mat2);
			System.out.println("Différences entre les matrices :");
			for(Difference difference : differences) {
				System.out.println(difference);
				System.out.println();
			}
			mat2.redimensionne(mat1.getNbLignes(), mat2.getNbColonnes());
			mat2.setData(mat1);
		}
	}
 
}

11/05/2013, 09h25
proc02

Citation:

Envoyé par joel.drigo

ça dépend de ce que tu veux faire :

* Créer une matrice de dimensions spécifiées en arguments
*
* @param lig
* @param col
*/

public List<Difference> getDifferences(Matrice mat2) {
List<Difference> diff=new ArrayList<Difference>();
int lig=Math.min(getNbLignes(),mat2.getNbLignes());
[/code]

Salut
Merci à tous pour l'attention accordé à mon problème
dans le code précedent on me dit que je cite:
The type List is not generic; it cannot be parameterized with arguments <Difference>
Merci encore.
11/05/2013, 12h26
proc02
J'ai pu corriger l'erreur en remplaçant le code precedent par
Code:

1 2 3 public ArrayList<Difference> getDifferences(Matrice mat2) { ArrayList<Difference> diff=new ArrayList<Difference>();
Seulement que la taille de mat1 est tellement grande que chaque ligne de mat1 est separé par 7 ligne vide et de plus mon mat 2 ne contient aucune valeur a l'affichage.
Sinon votre code marche parfaitement avec les exemple que vous avez fournis. :ccool:
11/05/2013, 15h32
joel.drigo

salut

c'est parce que tu as dû importer java.awt.List au lieu de java.util.List.

je n'ai pas mis les imports pour ne pas surcharger le post déjà bien long, mais visiblement j'aurais dû.

Citation:

Seulement que la taille de mat1 est tellement grande que chaque ligne de mat1 est separé par 7 ligne vide et de plus mon mat 2 ne contient aucune valeur a l'affichage.

Comment ça 7 lignes vides ? Et qu'est que tu veux dire par "mat2 ne continent aucune valeur à l'affichage" ?

Voici le début de la trace de l'appel pour la comparaison même taille :

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
Cas matrices de mêmes tailles
Matrice 1:
[1][0][0][0][1][0][1][1]
[1][0][0][1][1][0][0][1]
[1][0][0][1][1][0][0][1]
[1][0][0][1][1][1][0][1]
[1][0][0][0][0][1][0][0]
Matrice 2:
[1][0][0][1][0][0][0][0]
[1][0][0][0][1][0][1][1]
[1][0][0][0][1][0][0][1]
[1][0][0][1][1][0][0][1]
[1][0][0][1][1][1][1][1]
Différences entre les matrices :
Valeur différente en (1,4): valeur dans matrice 1=0, valeur dans matrice 2=1
 
Valeur différente en (1,5): valeur dans matrice 1=1, valeur dans matrice 2=0
 
Valeur différente en (1,7): valeur dans matrice 1=1, valeur dans matrice 2=0
 
Valeur différente en (1,8): valeur dans matrice 1=1, valeur dans matrice 2=0
 
Valeur différente en (2,4): valeur dans matrice 1=1, valeur dans matrice 2=0
 
Valeur différente en (2,7): valeur dans matrice 1=0, valeur dans matrice 2=1
 
Valeur différente en (3,4): valeur dans matrice 1=1, valeur dans matrice 2=0
 
Valeur différente en (4,6): valeur dans matrice 1=1, valeur dans matrice 2=0
 
Valeur différente en (5,4): valeur dans matrice 1=0, valeur dans matrice 2=1
 
Valeur différente en (5,5): valeur dans matrice 1=0, valeur dans matrice 2=1
 
Valeur différente en (5,7): valeur dans matrice 1=0, valeur dans matrice 2=1
 
Valeur différente en (5,8): valeur dans matrice 1=0, valeur dans matrice 2=1

Citation:

Envoyé par joel.drigo

Comment ça 7 lignes vides ? Et qu'est que tu veux dire par "mat2 ne continent aucune valeur à l'affichage" ?

[/code]

salut
votre code est irreprochable c'est parfait
Au fait mon mat1.lenght=128 et mon mat2.lenght=taille d'un mot
voici lorsque j'applique ton code a mon programme voici une partie du resultat:

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
mat2size= 8
mat1size= 128
 
Matrice 1:
[1][0][0][0][0][1][0][0]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[1][0][0][1][1][1][1][1]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[1][0][0][1][1][1][0][0]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[1][0][0][1][0][1][0][1]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[1][0][0][1][1][1][1][1]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[1][0][1][0][1][0][1][0]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[1][0][1][0][0][1][0][1]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[1][0][0][0][0][0][1][0]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
Matrice 2:
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
[][][][][][][][]
Différences entre les matrices :
Valeur différente en (1,8): valeur dans matrice 1=0, valeur dans matrice 2=
 
Valeur différente en (1,7): valeur dans matrice 1=0, valeur dans matrice 2=
 
Valeur différente en (1,6): valeur dans matrice 1=1, valeur dans matrice 2=
 
Valeur différente en (1,5): valeur dans matrice 1=0, valeur dans matrice 2=
 
Valeur différente en (1,4): valeur dans matrice 1=0, valeur dans matrice 2=
 
Valeur différente en (1,3): valeur dans matrice 1=0, valeur dans matrice 2=
 
Valeur différente en (1,2): valeur dans matrice 1=0, valeur dans matrice 2=
 
Valeur différente en (1,1): valeur dans matrice 1=1, valeur dans matrice 2=
 
Valeur uniquement dans matrice 1 en (16,1): valeur=
 
Valeur uniquement dans matrice 1 en (15,1): valeur=
 
Valeur uniquement dans matrice 1 en (14,1): valeur=
 
Valeur uniquement dans matrice 1 en (13,1): valeur=
 
Valeur uniquement dans matrice 1 en (12,1): valeur=
 
Valeur uniquement dans matrice 1 en (11,1): valeur=
 
Valeur uniquement dans matrice 1 en (10,1): valeur=
 
Valeur uniquement dans matrice 1 en (9,1): valeur=1
 
Valeur uniquement dans matrice 1 en (128,1): valeur=
 
.....................................................................

Merci encore une fois

11/05/2013, 16h30
joel.drigo

ok, je vois (enfin je crois)

tu remplis les matrices avec des chaines de caractères. du coup, tu te retrouves avec des "cases" vides vu que tes chaines ne sont pas aussi grande que la largeur de ta matrice.

et que tu as une matrice 2 avec que des chaines vides.

enfin si j'ai bien capté.

la question que je me pose, c'est quel est le but d'origine de ton API : comparer des matrices (donc forcément remplies), soit faire je ne sais pas quoi avec des chaines de caractères que tu essayes de résoudre avec des matrices alors que ce n'est peut être pas le meilleur moyen.