Ecrire et parcourir un tableau à plusieurs dimensions

Version imprimable

Bonjour à vous,

Dans le cadre d'un projet pour la spécialité ISN en terminale, je me suis lancé dans la programmation d'un jeu.
Je suis confronté à un problème qui est le suivant:
J'aimerais pouvoir inscrire les coordonnées d'une zone dans un tableau: c'est pourquoi j'ai pensé à utiliser un tableau à plusieurs dimensions.
J'ai pour le moment écris le code suivant:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 ... int[][] tabcp= new int [1][]; int coord=0; ... while (cpg1 == cppd) { Color cpgg = new Color(image.getRGB(xg1, xg2)); int pr22=cpgg.getRed(); int pg22=cpgg.getGreen(); int pb22=cpgg.getBlue(); int cpg11 = new Color(pr22,pg22,pb22).getRGB(); if (cpg11 != cppd) { break; } g.setColor(new Color(pr2,pg2,pb2)); g.fillRect(xpg1, xpg2, 24, 24); g.fillRect(xg1, xg2, 24, 24); tabcp[0][coord]= xg1; tabcp[1][coord]= xg2; coord++; xpg1-=25; xg1-=25; cpg1=cpg11; }
Ici, je souhaiterais inscrire xg1 et xg2 dans le tableau avec xg1 dans une première colonne et xg2 dans une seconde, seulement j'obtient l'erreur:
-Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException.

Je ne suis pas très à l'aise avec les tableaux, mais je n'ai pas trouvé d'autres solutions, c'est pourquoi j'aurais besoins de conseils.

Merci d'avance

Salut,

Quand tu écris int[][] tabcp= new int [1][];, tu indiques que le tableau a 1 ligne, mais chaque ligne n'est pas encore initialisée, d'où la NullPonterException.
C'est exactement comme si tu écrivais :
Code:

1 2 3 4 5 6 public class Truc { private int[] tableau; public void machin() { tableau[0]=1; // NullPointerException ici } }
Il est indispensable d'indiquer le nombre d'élements de chaque dimension avant de mettre des valeurs dans le tableau. Il te faut donc connaitre le nombre d'élements d'avance, ou savoir le calculer. Tu peux bien sûr procéder en 2 temps :
Code:

1 2 3 4 5 6 7 8 9 10 11 public class Truc { private int[][] tableau=new int[10][]; public void machin() { for(int i=0; i<tableau.length; i++) { tableau[i]=new int[i+1]; // là on peut mettre des valeurs dans le tableau } } }
Si tu ne peux pas facilement déterminer la taille du tableau d'avance, il te faudra utiliser une List, et la transformer en tableau après l'avoir remplie. Ou utiliser un tableau de List.

Merci pour ta réponse, j'ai donc modifié mon programme en ajoutant le nombre de ligne et un compteur coord:

Code:

1
2
int[][] tabcp= new int [1][100];
	  int coord=0;

J'ai ensuite voulu écrire dans le tableau xg1 et xg2:

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
 if (xg1 >=0) {
			 Color cpg = new Color(image.getRGB(xg1, xg2));
			 int pr2=cpg.getRed();
			 int pg2=cpg.getGreen();
			 int pb2=cpg.getBlue();
			 int cpg1 = new Color(pr2,pg2,pb2).getRGB();
 
		 while (cpg1 == cppd) {
		 Color cpgg = new Color(image.getRGB(xg1, xg2));
		 int pr22=cpgg.getRed();
		 int pg22=cpgg.getGreen();
		 int pb22=cpgg.getBlue();
		 int cpg11 = new Color(pr22,pg22,pb22).getRGB();
		 if (cpg11 != cppd) {
			 break;
		 }
	 	 g.setColor(new Color(pr2,pg2,pb2));
	 	 g.fillRect(xpg1, xpg2, 24, 24);
	 	 g.fillRect(xg1, xg2, 24, 24);
		 for(int i=0; i<tabcp.length; i++) {
             tabcp[i]=new int[i+1];
             tabcp[i][coord]= xg1;
             tabcp[i][coord]= xg2;
		 }
		 coord++;
	 	 xpg1-=25;
	 	 xg1-=25;
	 	 cpg1=cpg11;
		 }
		 }

J'ai voulu ensuite afficher le contenu du tableau:

Code:

1
2
3
4
5
6
7
8
for(int i = 0; i < tabcp.length; i++)
        {    
          for(int j = 0; j < tabcp[i].length; j++)
          {
            System.out.print(tabcp[i][j]);       
          }
          System.out.println("");     
        }

Seulement si ma boucle while tourne plus d'une fois, j'obtient l'erreur "java.lang.ArrayIndexOutOfBoundsException" et si la boucle tourne une fois, une seule des deux coordonnées sont inscrites.

26/02/2016, 14h41
joel.drigo
1)
Retire le tabcp[i]=new int[i+1]; : c'était pour l'exemple que j'ai montré ça. Dans ton cas, tu dimensionnes le tableau par int[][] tabcp= new int [1][100];, ce qui fait un tableau d'une ligne de 100 colonnes.

Ensuite, lorsque tu écris dans le tableau, tu fais :
Code:

1 2 tabcp[i][coord]= xg1; tabcp[i][coord]= xg2;
Donc tu mets (la valeur de) xg1 dans tabcp[i][coord], puis tu mets xg2 aussi dans tabcp[i][coord], qui remplace donc xg1.

Il faut que tu dimensionnes ton tableau par int[][] tabcp= new int [2][100]; : 2 lignes de 100 colonnes. Et que tu fasses :
Code:

1 2 tabcp[0][coord]= xg1; tabcp[1][coord]= xg2;
à la place de
Code:

1 2 3 4 5 for(int i=0; i<tabcp.length; i++) { // à supprimer tabcp[i]=new int[i+1]; tabcp[i][coord]= xg1; tabcp[i][coord]= xg2; }
Remarque qu'il serait plus logique de faire (même si ça ne change pas grand chose) int[][] tabcp= new int [100][2]; et donc
Code:

1 2 tabcp[coord][0]= xg1; tabcp[coord][1]= xg2;
Tu pourrais également utiliser un tableau de Point :
Point[] tabcp = new Point[100];et faire

Code:

tabcp[coord]= new Point( xg1, xg2 );

2)Ensuite le second problème vient du fait que tu fais évoluer coord de manière indépendant de la taille du tableau (au lieu de faire une incrémentation entre 0 et la taille du tableau).
La première conséquence que ça a, c'est que, comme tu as oublié de réinitialiser coord à 0 lorsque tu appelles la boucle une seconde fois, je suppose que coord atteint 100 et donc tu tentes d'écrire en dehors du tableau, et donc tu obtiens une IndexOutOutBoundException (Index en dehors des limites).
La second conséquence c'est que si dans une boucle tu avais plus de 100 paires de coordonnées tu obtiendrais la même exception. C'est là toute la limite dans l'usage des tableaux : avoir une taille finie qu'il ne faut pas dépasser. Il faut donc éviter de faire ce que tu fais, ou alors prendre les précautions qui s'imposent : mémoriser le nombre d'éléments écrits dans le tableau (s'il y en a moins que sa taille, tu as des cellules avec des données incohérentes, il ne faut donc pas les prendre en compte), et empêcher tout dépassement, ou "agrandir" le tableau le cas échéant : créer un nouveau tableau plus grand, copier le premier dedans, et remplacer le premier par le nouveau, ce que fait tout seule une ArrayList pour toi.

Ainsi, pour la déclaration, tu peux écrire List<Point> tabcp = new ArrayList<>();Pour écrire dedans, au début de chaque boucle tabcp.clear(); pour vider le tableau, puis :
Code:

1 2 tabcp.add( new Point(xg1, xg2) );[/c]
Pour afficher ensuite, tu peux faire :
Code:

1 2 3 4 for(int i=0; i<tabcp.size(); i++) { System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" "); } System.out.println();
Ou encore (l'index ne sert à rien pour cet affichage) :
Code:

1 2 3 4 for(Point p : tabcp) { System.out.print(p.x+" "+p.y+" "); } System.out.println();

J'ai en fait fait une erreur, quand j'ai mis 100 colonnes, je pensais ne pas avoir à toutes les remplir.
Le problème étant que le nombre de coordonnées à inscrire dans le tableau tient de l'aléatoire. J'ai fait une arrayList comme tu l'a expliqué, mais je n'ai rien qui sort, j'ai donc du faire une autre erreur..

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 class ListenerBleuC extends JPanel{
 
    private final BufferedImage image;
	  int xp1=1, xp2=1;
	  int xpg1=1, xph1=1, xpb1=1, xpd1=1, xpg2=1, xpd2=1, xph2=1, xpb2=1;
	  int xg1=xpg1-25, xg2=xpg2;
	  int xd1=xpd1+25, xd2=xpd2;
	  int xh1=xph1, xh2=xph2-25;
	  int xb1=xpb1, xb2=xpb2+25;
	  List<Point> tabcp = new ArrayList<>();
	  int cppd = -16776961;
 
    public ListenerBleuC(BufferedImage image) {
        this.image=image;
        System.out.println("HelloB");
        eerc();
        for(int i=0; i<tabcp.size(); i++) {
            System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" ");       
        }
        System.out.println();
	}
public void eerc() {
 
if (xg1 >=0) {
			 Color cpg = new Color(image.getRGB(xg1, xg2));
			 int pr2=cpg.getRed();
			 int pg2=cpg.getGreen();
			 int pb2=cpg.getBlue();
			 int cpg1 = new Color(pr2,pg2,pb2).getRGB();
 
		 while (cpg1 == cppd) {
		 tabcp.clear();
		 Color cpgg = new Color(image.getRGB(xg1, xg2));
		 int pr22=cpgg.getRed();
		 int pg22=cpgg.getGreen();
		 int pb22=cpgg.getBlue();
		 int cpg11 = new Color(pr22,pg22,pb22).getRGB();
		 if (cpg11 != cppd) {
			 break;
		 }
	 	 g.setColor(new Color(pr2,pg2,pb2));
	 	 g.fillRect(xpg1, xpg2, 24, 24);
	 	 g.fillRect(xg1, xg2, 24, 24);
		 tabcp.add(new Point(xg1, xg2));
	 	 xpg1-=25;
	 	 xg1-=25;
	 	 cpg1=cpg11;
		 }
		 }

Code:

1 2 3 while (cpg1 == cppd) { tabcp.clear(); /*...*/
Tu vides la liste à chaque itération de la boucle, puis que le clear() est exécuté dans la boucle.

Fais comme ça :
Code:

1 2 3 4 5 6 tabcp.clear(); // on vide la liste while (cpg1 == cppd) { /*... on remplit la liste dans la boucle ...*/ } /*... la liste est remplie ...*/

En fait, le problème est que j'ai plusieurs instructions qui se suivent comme ça, ça donne ça à la fin:

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
import javax.swing.*;
import java.awt.Point;
import java.io.*;
import java.util.ArrayList;
import java.awt.Color;
import java.awt.Graphics;
import java.util.List;
import java.awt.image.BufferedImage;
 
public class ListenerBleuC extends JPanel{
 
    private final BufferedImage image;
	  int xp1=1, xp2=1;
	  int xpg1=1, xph1=1, xpb1=1, xpd1=1, xpg2=1, xpd2=1, xph2=1, xpb2=1;
	  int xg1=xpg1-25, xg2=xpg2;
	  int xd1=xpd1+25, xd2=xpd2;
	  int xh1=xph1, xh2=xph2-25;
	  int xb1=xpb1, xb2=xpb2+25;
	  List<Point> tabcp = new ArrayList<>();
	  int cppd = -16776961;
 
    public ListenerBleuC(BufferedImage image) {
        this.image=image;
        System.out.println("HelloB");
        eerc();
        for(int i=0; i<tabcp.size(); i++) {
            System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" ");       
        }
        System.out.println();
	}
 
	public void paintComponent(Graphics g) {
        g.drawImage(image, 0, 0, null);
	}
 
	public static int detectB; {
 
	}
 
	public void eerc() {
        Graphics g = (Graphics)image.getGraphics();
 
        Color cpp= new Color(image.getRGB(xp1, xp2));
		 int pr=cpp.getRed();
	     int pg=cpp.getGreen();
	     int pb=cpp.getBlue();
		 int cpp1 = new Color(pr,pg,pb).getRGB();
 
		 if (xg1 >=0) {
			 Color cpg = new Color(image.getRGB(xg1, xg2));
			 int pr2=cpg.getRed();
			 int pg2=cpg.getGreen();
			 int pb2=cpg.getBlue();
			 int cpg1 = new Color(pr2,pg2,pb2).getRGB();
 
	     tabcp.clear();
		 while (cpg1 == cppd) {
		 Color cpgg = new Color(image.getRGB(xg1, xg2));
		 int pr22=cpgg.getRed();
		 int pg22=cpgg.getGreen();
		 int pb22=cpgg.getBlue();
		 int cpg11 = new Color(pr22,pg22,pb22).getRGB();
		 if (cpg11 != cppd) {
			 break;
		 }
	 	 g.setColor(new Color(pr2,pg2,pb2));
	 	 g.fillRect(xpg1, xpg2, 24, 24);
	 	 g.fillRect(xg1, xg2, 24, 24);
		 tabcp.add(new Point(xg1, xg2));
	 	 xpg1-=25;
	 	 xg1-=25;
	 	 cpg1=cpg11;
		 }
		 }
 
		 if (xh2 >=0) {
			 Color cph = new Color(image.getRGB(xh1, xh2));
			 int pr3=cph.getRed();
			 int pg3=cph.getGreen();
			 int pb3=cph.getBlue();
			 int cph1 = new Color(pr3,pg3,pb3).getRGB();
 
		     tabcp.clear();
			 while (cph1 ==cppd) {
				 Color cphh = new Color(image.getRGB(xh1,xh2));
				 int pr33=cphh.getRed();
				 int pg33=cphh.getGreen();
				 int pb33=cphh.getBlue();
				 int cph11 = new Color(pr33,pg33,pb33).getRGB();
 
				 if (cph11 != cppd) {
					 break;
				 }
			 		g.setColor(new Color(pr3,pg3,pb3));
			 		g.fillRect(xph1, xph2, 24, 24);
			 		g.fillRect(xh1, xh2, 24, 24);
					tabcp.add(new Point(xg1, xg2));
			 		xph2-=25;
			 		xh2-=25;
			 		cph1=cph11;
			 }
		 }
 
		 if (xb2 >=0) {
			 Color cpb = new Color(image.getRGB(xb1, xb2));
			 int pr4=cpb.getRed();
			 int pg4=cpb.getGreen();
			 int pb4=cpb.getBlue();
			 int cpb1 = new Color(pr4,pg4,pb4).getRGB();
 
		     tabcp.clear();
			 while (cpb1== cppd) {
				 Color cpbb = new Color(image.getRGB(xb1, xb2));
				 int pr44=cpbb.getRed();
				 int pg44=cpbb.getGreen();
				 int pb44=cpbb.getBlue();
				 int cpb11 = new Color(pr44,pg44,pb44).getRGB();
 
				 if (cpb11 != cppd) {
					 break;
				 }
					 g.setColor(new Color(pr4,pg4,pb4));
					 g.fillRect(xpb1, xpb2, 24, 24);
					 g.fillRect(xb1, xb2, 24, 24);
					 tabcp.add(new Point(xg1, xg2));
					 xpb2+=25;
					 xb2+=25;
					 cpb1=cpb11;
			 }
		 }
 
		 Color cpd = new Color(image.getRGB(xd1, xd2));
		 int pr1=cpd.getRed();
	     int pg1=cpd.getGreen();
	     int pb1=cpd.getBlue();
		 int cpd1 = new Color(pr1,pg1,pb1).getRGB();
 
	     tabcp.clear();
		 while (cpd1==cppd) {
			 Color cpdd = new Color(image.getRGB(xd1, xd2));
			 int pr11=cpdd.getRed();
		     int pg11=cpdd.getGreen();
		     int pb11=cpdd.getBlue();
			 int cpd11 = new Color(pr11,pg11,pb11).getRGB();
 
			 if (cpd11 != cppd) {
				 break;
			 }
				 g.setColor(new Color(pr1,pg1,pb1));
				 g.fillRect(xp1, xpd2, 24, 24);
				 g.fillRect(xd1, xd2, 24, 24);
				 tabcp.add(new Point(xg1, xg2));
				 xpd1+=25;
				 xd1+=25;
				 cpd1=cpd11;
		 }
	}
 
}

Donc je ne peux pas clear à chaque fin de boucle

Ok. En gros, si je comprends bien, tu appelles la méthode eerc() pour générer un truc (une image à priori), et pendant que tu génères cette image tu collectes des données que tu veux afficher après (on le voit ici :
Code:

1 2 3 4 5 6 7 8 // 1. on génère eerc(); // 2. on affiche for(int i=0; i<tabcp.size(); i++) { System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" "); } System.out.println();
Les quatre boucles génèrent des données dans eerc(). A chaque fois qu'on appelle eerc() on veut avoir après uniquement les points générés pendant cet appel. Donc il suffit de vider la liste avant de faire l'appel ou au début de l'appel.
Code:

1 2 3 4 5 6 7 8 9 10 // 1. on vide tabcp.clear(); // 2. on génère eerc(); // 3. on affiche for(int i=0; i<tabcp.size(); i++) { System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" "); } System.out.println();
Une autre solution serait de vider la liste quand tu ne veux plus rien en faire, donc après l'affichage ici.

Si la liste ne sert que à cet endroit, le mieux est encore de faire une variable locale, ce qui évite non seulement de se trimbaler en mémoire avec des trucs qui ne servent à rien, mais en plus évite d'avoir à se préoccuper qu'il reste des trucs dedans de l'appel d'avant (Accessoirement, ça simplifie les choses lorsqu'on travaille avec plusieurs processus parallèles, mais tu verras ça plus tard). Mais si tu as besoin de la liste ailleurs plus tard (je veux dire dans un autre objet en particulier), bien sûr, cette solution ne fonctionnera pas.
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 public class ListenerBleuC extends JPanel{ /*...*/ // List<Point> tabcp = new ArrayList<>(); // plus besoin de ça public ListenerBleuC(BufferedImage image) { this.image=image; System.out.println("HelloB"); List<Point> = tabcp.eerc(); // on récupère la liste comme résultat de l'appel for(int i=0; i<tabcp.size(); i++) { System.out.print(tabcp.get(i).x+" "+tabcp.get(i).y+" "); } System.out.println(); } /*...*/ public List<Point> eerc() { // la méthode retourne la liste des points générés List<Point> tabcp = new ArrayList<>(); // on créé la variable tabcp localement à la méthode - c'est une nouvelle liste, donc vide, donc sans les trucs d'avant /* ... là ton code ne change pas, sauf les tabcp.clear() qu'il faut enlever ... */ return tabcp; // on retourne à l'appelant la liste remplie }
En général, il vaut mieux toujours faire des variables locales aux méthodes, quitte à les passer en paramètre à d'autres méthodes si elles en ont aussi besoin. Les variables de classe sont utiles lorsque la donnée persiste, sur plusieurs appels, et doit éventuellement être récupérer par (ou donnée à) une autre classe. Éventuellement, si une valeur est longue à calculer et qu'on n'est pas obligé de la calculer à chaque fois, on pourra aussi utiliser une variable de classe. Mais pour une variable dont la valeur change à chaque appel d'une méthode, autant la laisser locale à la méthode. Après, il y a toujours des exceptions. Dans ton cas, il peut être intéressant de laisser tabcp comme variable de classe pour des questions d'optimisations : en particulier, si cette méthode est très souvent appelée, on gagnera par rapport aux instanciations et aux copies de tableaux.

26/02/2016, 20h06
KoupaXII

Citation:

Ok. En gros, si je comprends bien, tu appelles la méthode eerc() pour générer un truc (une image à priori), et pendant que tu génères cette image tu collectes des données que tu veux afficher après (on le voit ici):

Oui, exactement, et vu que je compte l'utiliser à de nombreuses reprises je vais plutôt utiliser une variable de classe.

Merci beaucoup pour toutes les réponses apportées !