créer une matrice à partir d'un fichier txt

Version imprimable

Bonjour, j'ai un fichier texte fichier.txt qui contient des données sous cette forme

Code:

1
2
3
4
5
6
7
8
9
10
1 7 11 13 14 16          
0 1 4 7 8 11 15         
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13

je veux lire ce fichier dans java sous forme d'une matrice, comment je dois procéder?

Salut,

Je t'ai déjà donné une méthode pour lire un csv avec en paramètre le caractère séparateur :

Code:

1
2
3
4
5
public static String[][] readCSV(String nomFichier, char c, Charset charset) throws IOException {
		return Files.lines(Paths.get(nomFichier), charset)
			     .map(ligne-> ligne.split(String.valueOf(c)))
			     .toArray(String[][]::new);
	}

Tu peux en faire une en repartant de cette méthode pour obtenir un tableau de nombre :

Code:

1
2
3
4
5
6
7
	public static int[][] readIntMatrix(String nomFichier, char c) throws IOException {
		return Files.lines(Paths.get(nomFichier))
			     .map(ligne-> Arrays.stream(ligne.split(String.valueOf(c)))
		                            .mapToInt(Integer::parseInt)
		                            .toArray())
			     .toArray(int[][]::new);
	}

Et pour l'utiliser, par exemple si la classe où se trouve cette méthode est Util :

Code:

1
2
3
4
5
6
7
8
 
try {
   int[][] matrix = Util.readIntMatrix("testmatrix.txt", ' ');
 
   System.out.println(Arrays.deepToString(matrix));
}catch(IOException e) {
  e.printStackTrace();
}

Attention, ton exemple de fichier n'est pas une matrice rectangulaire (il y a des lignes avec 6 valeurs et d'autres avec 8). C'est normal ?

oui le nombre de colonne est variable, voici tout le fichier

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
5
1 7 11 13 14 16          
0 1 4 7 8 11 15         
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
0 1 3 4 5 7 11 13        
1 3 4 5 8 11 13 15        
1 3 4 5 8 11 13 15        
1 3 4 5 8 11 13 15        
1 3 4 5 8 11 13 15        
1 3 4 5 8 11 13 15        
1 3 4 5 8 11 13 15        
1 3 4 5 8 11 13 15        
1 3 4 5 11 13 14 15        
1 3 4 5 11 13 14 15        
1 3 4 5 11 13 14 15        
1 3 4 5 11 13 14 15        
1 3 4 5 11 13 14 15        
1 3 4 5 11 13 14 15        
1 4 5 7 11 13 14 15        
1 4 5 7 11 13 14 15        
1 4 5 7 11 13 14 15        
1 4 5 7 11 13 14 15        
1 4 5 7 11 13 14 15        
1 4 5 7 11 13 14 15        
1 4 5 7 8 11 14 15        
1 4 5 7 8 11 14 15        
1 4 5 7 8 11 14 15        
1 3 5 7 11 13 14 15        
1 3 5 7 11 13 14 15        
1 4 5 7 8 11 13 15        
1 4 5 7 8 11 13 15        
1 4 5 7 8 11 13 15        
1 4 5 7 8 11 13 15        
0 1 3 4 5 11 13 15        
0 1 3 4 5 11 13 15        
1 3 4 5 7 11 13 15        
1 3 4 5 7 11 13 15        
0 1 4 5 7 8 11 15        
0 1 4 5 7 8 11 15        
1 3 4 5 7 13 14 15        
0 1 2 4 7 8 11 15        
0 1 3 4 5 7 11 13 16       
0 1 3 4 5 8 11 13 15       
0 1 3 4 5 8 11 13 15       
4 5 6 7 8 10 11 12 15       
1 4 5 7 8 11 13 14 15       
1 4 5 7 8 11 13 14 15       
1 4 5 7 8 11 13 14 15       
0 1 3 4 5 7 11 13 15       
0 1 4 5 7 8 11 14 15       
0 1 4 5 7 8 11 14 15       
1 3 4 5 6 11 13 14 15       
0 1 3 7 8 9 11 14 15       
0 1 3 7 8 9 11 14 15       
1 3 4 5 7 11 13 14 15       
1 3 4 5 7 11 13 14 15       
1 3 4 5 7 11 13 14 15       
1 3 4 5 7 11 13 14 15       
1 3 4 5 7 8 11 13 14       
1 4 5 7 8 11 13 14 15       
1 2 3 4 5 6 11 13 14       
1 2 3 4 5 6 11 13 14       
0 1 3 4 5 7 8 11 13       
0 1 3 4 5 7 8 11 13       
0 1 3 4 5 7 8 11 13       
0 1 3 4 5 7 8 11 13       
0 1 3 4 5 7 8 11 13       
0 1 3 4 5 7 11 13 14       
0 1 3 4 5 7 11 13 14       
0 1 3 4 5 7 8 11 13 15      
0 1 3 4 5 7 8 9 11 15      
0 1 3 4 5 7 8 9 11 15      
1 3 4 5 6 7 11 12 13 15      
1 3 4 5 6 7 8 9 11 14 15     
1 2 3 4 5 6 7 11 12 14 15     
1 2 3 4 5 6 7 11 12 14 15     
0 1 2 3 4 5 6 8 9 13 14 15    
0 1 2 3 4 5 6 8 9 13 14 15    
1 2 3 4 5 6 7 8 9 13 14 15    
0 1 3 4 5 6 7 8 9 13 14 15    
1 2 3 4 5 6 7 11 12 14 15 16    
1 2 3 4 5 6 7 11 12 14 15 16    
0 1 3 4 5 6 7 8 9 11 14 15 16   
0 1 3 4 5 6 7 8 9 11 14 15 16   
0 1 2 3 4 5 6 7 8 11 13 14 15   
0 1 2 3 4 5 6 7 8 11 13 14 15   
0 1 2 3 4 5 6 7 8 11 13 14 15 16  
0 1 3 4 5 6 7 8 9 11 12 13 14 15 16 
0 1 2 3 4 5 6 7 8 10 11 12 13 14 15 16
0 1 2 3 4 5 6 7 8 10 11 12 13 14 15 16
0 1 2 3 4 5 6 7 8 10 11 12 13 14 15 16
0 1 2 3 4 5 6 7 8 10 11 12 13 14 15 16
0 1 2 3 4 5 6 7 8 10 11 12 13 14 15 16
0 1 2 3 4 5 6 7 8 10 11 12 13 14 15 16

Citation:

Envoyé par sel.chayma

oui le nombre de colonne est variable

Attention, donc pour le parcourir par des boucles for :
Code:

1 2 3 4 5 6 7 8 9 int[][] matrix = Util.readIntMatrix("testmatrix.txt", ' '); for(int i=0; i<matrix.length; i++) { for(int j=0; j<matrix[i].length; j++) { int val = matrix[i][j]; } }

18/04/2018, 09h55
student student

merciii

et si j'ai un fichier dont les données sont de cette forme
Code:

1 2 3 4 5 6 7 8 9 10 11 12 106, 203, 207, 102 103 104 205, 103, 102 103 104 205, 104, 102 103 104 205, 205 110, 102 103 104 205, 205 107, 102 103 104 205 206, 102 103 104 205, 201 202 205 206, 102 205 110, 102 205 107, 201 202 205, 205, 202,
à chaque virgule trouvé c'est une colonne, je veux par exemple que 102 103 104 205 soient dans le même colonne

On peut procéder en deux temps. Lire le fichier :

Code:

1
2
3
4
5
6
7
8
9
10
public static int[][] readIntMatrix(String nomFichier, char c, char endOfLine) throws IOException {
		return Files.lines(Paths.get(nomFichier))
			     .flatMap(ligne-> Arrays.stream(ligne.split(String.valueOf(endOfLine))))
			     .filter(line->line.trim().length()>0)
			     .map(String::trim) 
			     .map(ligne-> Arrays.stream(ligne.split(String.valueOf(c)))
		                            .mapToInt(Integer::parseInt)
		                            .toArray())
			     .toArray(int[][]::new);
	}

Puis transposer :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static int[][] transpose(int[][] matrix) {
		int lcount = 0;
		for(int[] line : matrix) {
			if ( line.length>lcount ) lcount = line.length;
		}
		int ccount = matrix.length;
		int[][] transposed = new int[lcount][ccount];
		for(int i=0; i<matrix.length; i++) {
			for(int j=0; j<matrix[i].length; j++) {
				transposed[j][i]=matrix[i][j];
			}
		}
		return transposed;
	}

Lecture :

Code:

1
2
3
4
5
int[][] matrix = Util.transpose(Util.readIntMatrix("testmatrixcol.txt", ' ', ','));
 
		for(int i=0; i<matrix.length; i++) {
			System.out.println(Arrays.stream(matrix[i]).mapToObj(String::valueOf).collect(Collectors.joining("\t")));
		}

Forcément, il y aura des 0 pour combler les "trous" (les colonnes n'ont pas la même longueur), la matrice donnera

106	203	207	102	103	102	104	102	205	102	205	102	102	201	102	102	201	205	202
0	0	0	103	0	103	0	103	110	103	107	103	103	202	205	205	202	0	0
0	0	0	104	0	104	0	104	0	104	0	104	104	205	110	107	205	0	0
0	0	0	205	0	205	0	205	0	205	0	205	205	206	0	0	0	0	0
0	0	0	0	0	0	0	0	0	0	0	206	0	0	0	0	0	0	0

Pour qu'il n'y ait pas de "trou", il faut conserver la matrice non transposée et traiter les lignes comme des colonnes et les colonnes comme des lignes (c'est une simple inversion des coordonnées). Les lignes peuvent avoir des longueurs différentes, mais pas les colonnes évidemment.

c'est pas l'affichage que je cherche ici, je veux par exemple dans la 4ème ligne

Code:

102 103 104 205, 103,

102 103 104 205 dans la 1ère colonne et 103 dans la 2ème colonne . il faut que la matrice reste de cette forme
Code:

1 2 3 4 5 6 7 8 9 10 11 106, 203, 207, 102 103 104 205, 103, 102 103 104 205, 104, 102 103 104 205, 205 110, 102 103 104 205, 205 107, 102 103 104 205 206, 102 103 104 205, 201 202 205 206, 102 205 110, 102 205 107,

18/04/2018, 11h46
joel.drigo

Je ne comprends pas : tu as plusieurs lignes dans ton fichier, qui contiennent plusieurs colonnes, pas le même nombre. Comment est foutue cette matrice au final ? Parce que tu me montres en disant que c'est une matrice ce n'est pas une matrice, c'est une liste de lignes de listes de nombres en gros. Et tu parles de 4^ème ligne. C'est la seule ligne que tu veux extraire, ou c'est un tableau à trois dimensions ?

Si le but est de prendre la n^ième ligne du fichier et d'en faire une matrice, tu as déjà tout ce qui te faut pour faire çà (je t'ai donné des codes exemple). Lire par ligne, avec skip et limit, tu obtiens la ligne que tu veux et tu convertis cette ligne en matrice, sur la base de ce que je viens de te montrer. A un moment donné, il faut que tu te serves de ce que je t'ai déjà donné et que tu composes avec.

vous m'avez pas compris, la 4ème ligne c'est juste un exemple que j'ai donné, c'est ça le fichier texte, pour chaque ligne lue le virgule c'est le séparateur, vous avez transposé la matrice mais moi je veux la garder comme elle est
Code:

1 2 3 4 5 6 7 8 9 10 11 12 106, 203, 207, 102 103 104 205, 103, 102 103 104 205, 104, 102 103 104 205, 205 110, 102 103 104 205, 205 107, 102 103 104 205 206, 102 103 104 205, 201 202 205 206, 102 205 110, 102 205 107, 201 202 205, 205, 202,
je vais essayer de la tracer pour mieux comprendre
Code:

1 2 3 4 |102 103 104 205|103| |102 103 104 205| 104| |102 103 104 205| 205 110| |102 103 104 205| 205 107|
c'est ça l'affichage que je cherche et j'arrive pas à le trouver

18/04/2018, 11h59
joel.drigo

Donc, en gros, c'est ce qui a déjà été fait, sauf qu'au lieu de séparer par des espaces, on sépare par des virgules, et on obtient une "matrice" de String. J'ai déjà répondu à cette question et j'ai déjà donné le code pour (j'ai même déjà dit que j'avais déjà répondu à cette question).