Discussion :

[proc02]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[ludomacho]

Re bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[joel.drigo]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

mais pour des matrices de String, il faut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[proc02]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Avec le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[joel.drigo]

si tu continues à avoir une erreur d'index hors bornes dans la ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
if ( mat1.length!=mat2.length || mat1[0].length!=mat2[0].length ){
  throw new IllegalArgumentException();
}

pour t'en assurer...

[proc02]

pour t'en assurer...

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

[joel.drigo]

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[proc02]

ç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.

[proc02]

J'ai pu corriger l'erreur en remplaçant le code precedent par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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û.

[joel.drigo]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[proc02]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.