tableau à x dimensions

**benoitdegaridel** · 16/02/2018, 23h47

Bonsoir,

j'ai un souci pour créer mon tableau multidimensionnel...

En fait, j'aimerais qu'en fonction d'une variable x, le tableau ai x dimensions, avec 2 tableaux de x-1 dimensions.

Le tableau de base aurai donc 50 ou 100 chiffres et l'écrire sur 4 ou 5 dimentions serait lourd...

Pour exemple: je veux un tableau à 5 dimensions, le tableau unidimensionnel se crée, un tableau à deux dimensions se crée ensuite avec deux tableaux unidimensionnel auparavant créé, et cela 5 fois.

Je vais pas vous passer mon code parce qu'il est trop lourd mais j'attends vos retour avec impatience!

**joel.drigo** · 17/02/2018, 02h35

Salut,

Tu n'es pas obligé de nous montrer tout ton code. Juste celui où tu as ton problème, c'est à dire la construction à priori.

En tout cas, comme tu le dis, un tableau de n dimensions, c'est un tableau de tableau de tableau...etc, n fois. Donc à l'évidence, on peut gérer ça par récursivité pour commencer. Il sera plus aisé de gérer ce genre de tableau via une classe d'encapsulation. Donc reprogrammer quasiment toutes les méthodes (mutateur, parcours, accesseur, etc.). Pour la représentation en String, tu peux utiliser directement Arrays.deepToString() puisque c'est sur ce principe de récursivité que c'est implémenté pour représenter n'importe quel tableau de tableau. Pour faire des méthodes souples à utiliser utilise des var-args. Avec une classe paramétrée tu pourras gérer le type de données stockées facilement.

Exemple (un début, avec quelques méthodes) :

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
import java.util.Arrays;
 
public class NDimArray<T> {
 
	private int dim;
	private Object[] array;
 
	public NDimArray(int length, int...lengths) {
		dim = 1+lengths.length;
		array = new Object[length];
		create(array, 0, lengths); // création par récursivité
	}
 
	private void create(Object[] array, int n, int[] lengths) {
		if ( n<lengths.length ) {
			for(int i=0; i<array.length; i++) {
				array[i]=new Object[lengths[n]];
				create((Object[])array[i], n+1, lengths); // appel récursif
			}
		}
	}
 
	private NDimArray(T[] array, int dim) {
		this.dim=dim;
		this.array=array;
	}
 
	public NDimArray<T> getSubArray(int i) {
		if ( dim>1 ) {
			return new NDimArray<T>((T[])array[i], dim-1);
		}
		else {
			throw new IllegalStateException();
		}
	}
 
	public int getDimensions() {
		return dim;
	}
 
	public void fill(T value) {
		fill(array, 0, value);
	}
 
	private void fill(Object[] array, int n, T value) {
		if ( n<dim-1 ) {
			for(Object subarray : array) {
				fill((Object[])subarray, n+1, value); // récursivité
			}
		}
		else {
			Arrays.fill(array, value);
		}
	}
 
	public void setValue(T value, int...x) {
		if ( x.length!=dim ) throw new IllegalArgumentException();
		setValue(value, array, 0, x);
	}
 
	private void setValue(T value, Object[] array, int n, int...x) {
		if ( n<dim-1 ) {
			setValue(value, (Object[])array[x[n]], n+1, x); // récursivité
		}
		else {
			array[x[n]]= value;
		}
	}
 
	@Override
	public String toString() {
		return Arrays.deepToString(array);
	}
 
	public static void main(String[] args) {
 
		NDimArray<Integer> array = new NDimArray<>(3, 2, 4); // tableau de 3 x 2 x 4
		System.out.println("Dimensions : " + array.getDimensions());
		array.fill(0);
 
		System.out.println(array);
 
		array.setValue(1, 0, 0, 0); // mettre 1 dans [0][0][0]
		array.setValue(2, 1, 1, 1); // mettre 2 dans [1][1][1]
		array.setValue(42, 0, 1, 3); // mettre 42 dans [0][1][3]
 
		System.out.println(array);
 
		System.out.println(array.getSubArray(1).getSubArray(1));
 
		NDimArray<String> stringArray = new NDimArray<>(2, 2, 2, 2, 2); // tableau de 2 x 2 x 2 x 2 String
		System.out.println("Dimensions : " + stringArray.getDimensions());
		stringArray.fill(".");
		stringArray.setValue("X", 1, 1, 1, 1, 1); // mettre X dans [1][1][1][1][1]
		System.out.println(stringArray);
 
	}
 
}

Il ne reste plus qu'à ajouter d'autres méthodes utiles, comme T getValue(int..x), par exemple, pour lire la valeur de coordonnées x, par exemple. Le principe est le même.

**benoitdegaridel** · 17/02/2018, 16h43

Bonjour,
l'utilité du tableau est de contenir l'ensemble des cases d'un tableau à double entrées, mais est ce qu'il ne serait pas plus simple d'utiliser des arraylists ou tout simplement une map pour ajouter les cases remplies et les vérifier avec les clés correspondantes... je ne les utilises pas trop ces deux là!
Je pense que je vais tout de même essayer la méthode par récurrence merci!

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
package Utils;
 
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
 
public class Panneau extends JPanel {
 
    public int posX = 0;
    public int posY = 0;
    public int x =-10,y = -10;
    private Image img;
//initialisation du tableau bidimensionnel ici de 40 tableaux de 120 chiffres (tous remplis de 0 pour le moment) et est celui à remplacer
    private int pixel1 [][] = {...............................................}
 
public Panneau(){
        this.setBackground(Color.WHITE);
 
 
    }
 
    public void slap(Pixel pixel){
        this.x = pixel.getPlace()*5;
        this.y = pixel.getLigne()*5;
        this.pixel1[pixel.getLigne()][pixel.getPlace()] = 1;
 
    }
 
    public void paintComponent(Graphics g){
        for (int i =0;i<40;i++){
            for (int j=0;j<120;j++){
                if(this.pixel1[i][j] == 1){
                    g.fillRect(j*5,i*5,5,5);
                    System.out.println(i + " " + j);
                }
            }
        }
    }
    public void rep(){
        for(int i =0;i<40;i++){
            for(int j=1;j<119;j++){
                int k = this.pixel1[i][j];
                if(k == 1){
                    try{
                        if(this.pixel1[i][j-1] != 1 && this.pixel1[i][j-2] != 1){
                            this.pixel1[i+1][j-1] = 1;
                            System.out.println(1);
                        }
                        if(this.pixel1[i][j+1] != 1 && this.pixel1[i][j+2] != 1){
                            this.pixel1[i+1][j+1] = 1;
                            System.out.println(1);
                        }
                    }catch(ArrayIndexOutOfBoundsException e) {
                        e.printStackTrace();
                    }
 
                }
            }
        }
        repaint();
 
 
    }
 
    public int getPosX() {
        return posX;
    }
 
    public void setPosX(int posX) {
        this.posX = posX;
    }
 
    public int getPosY() {
        return posY;
    }
 
    public void setPosY(int posY) {
        this.posY = posY;
    }
 
 
 
}

**joel.drigo** · 17/02/2018, 17h57

Envoyé par benoitdegaridel

l'utilité du tableau est de contenir l'ensemble des cases d'un tableau à double entrées,

Tu as demandé initialement comment construire un tableau de dimension n (à n entrées donc). Si ton tableau est à 2 dimensions, pourquoi chercher à faire autre chose.

Envoyé par benoitdegaridel

mais est ce qu'il ne serait pas plus simple d'utiliser des arraylists ou tout simplement une map pour ajouter les cases remplies et les vérifier avec les clés correspondantes... je ne les utilises pas trop ces deux là!

Le plus simple est de définir un objet qui représente tes informations à gérer et qui permet de les manipuler facilement et efficacement, et de manière logique par rapport à ce qu'elles représentent, pas de chercher à faire coller des structures génériques au besoin, qui est la démarche inverse. On a le droit de faire des objets en Java. On n'est pas obligé d'utiliser que des structures standards dans des structures standards.
Une List est un stockage d'éléments de nombre déterminable (mais variable) et à accès direct : la différence avec un tableau est la taille variable. L'implémentation influe sur les performances, un tableau restant le plus performant. En tout cas, qu'on utilise un tableau de tableau de tableau ou une liste de liste de liste, aucune différence structurelle, et l'un n'est pas plus simple que l'autre pour gérer un nombre de dimension paramétrable.
Une Map est un moyen d'indexer des valeurs sur des clefs : utiliser une Map pour simuler un tableau est possible mais contre-productif. A moins peut-être d'avoir beaucoup de cellules vides.

En regardant ton code, je ne vois rien qui soit en rapport avec une notion de tableau de dimension paramétrable. Je vois que tu as marqué :

Code :

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

//initialisation du tableau bidimensionnel ici de 40 tableaux de 120 chiffres (tous remplis de 0 pour le moment) et est celui à remplacer

un tableau de 40 tableaux de 120 chiffres n'est pas un tableau de nombre de dimension variable. C'est un tableau à 2 dimensions, point. Pourquoi alors parler de dimension variable ?

Par ailleurs, pour ce genre de choses :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
    public void paintComponent(Graphics g){
        for (int i =0;i<40;i++){
            for (int j=0;j<120;j++){
                if(this.pixel1[i][j] == 1){
                    g.fillRect(j*5,i*5,5,5);
                    System.out.println(i + " " + j);
                }
            }
        }
    }

le plus efficace et le plus performant est d'utiliser une image. Par ailleurs un tableau à une dimension est plus efficace qu'un tableau à 2 dimensions, et pas beaucoup plus complexe à manipuler.

**benoitdegaridel** · 17/02/2018, 18h11

Merci de ta réponse,
Le fait que j'utilisais un tableau bidimensionnel était justement mon problème...
J'utilisais les deux paramètres du tableau comme coordonées dans le "tableau".
Bref, la méthode par récurrence est ici un peu démesurée comparée à son utilisation. En effet, il n'y a que peu de cases remplies et j'ai donc utilisé une ArrayList mais j'ai maintenant un problème dans le paintComponent; ma List est constamment vide et je ne sais pas pourquoi...

ma classe fenetre:

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
package Utils;
 
import javax.swing.*;
import java.awt.*;
 
 
public class Fenetre1 extends JFrame {
 
 
 
 
 
 
    public Fenetre1(Panneau content){
        this.setContentPane(content);
        this.setTitle("arbre");
        this.setSize(825,400);
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
        content.rep(content.create(content.ar),0);
 
 
    }
 
 
 
 
}

et ma classe panneau:

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
package Utils;
 
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
 
 
public class Panneau extends JPanel {
 
    public int posX = 0;
    public int posY = 0;
    public int x =-10,y = -10;
    private Image img;
    private int exposant = 2;
    public ArrayList ar = new ArrayList();
    public int max = 60;
 
    public Panneau(){
        this.setBackground(Color.WHITE);
 
 
    }
    public ArrayList create(ArrayList ar){
        ar.add(new int[]{0, 20});
        return ar;
    }
 
 
 
    public void paintComponent(Graphics g){
        try {
 
            for (int i = 0; i < this.max; i++) {
                int[] s = (int[]) this.ar.get(i);
                g.fillRect(s[0] * 5, s[1] * 5, 5, 5);
                System.out.println(s[0] + " " + s[1]);
 
            }
        }catch(IndexOutOfBoundsException i){
            System.out.println("aïe");
        }
 
    }
    public void rep(ArrayList ar,int i){
        repaint();
        ArrayList ar1 = new ArrayList();
        System.out.println(i);
        for(int j=0;j<40;j++){
            int[] li = {i,j};
            if(ar.contains(li)){
                System.out.println(i + " " + j);
                if(!ar.contains(new int[]{i,j-1}) && !ar.contains(new int[]{i,j-2})){
                    ar1.add(new int[]{i+1,j-1});
                }
                if(!ar.contains(new int[]{i,j+1}) && !ar.contains(new int[]{i,j+2})){
                    ar1.add(new int[]{i+1,j+1});
                }
            }
 
 
        }
        this.ar = ar;
        if(i<5) {
            rep(ar1, i + 1);
        }
 
    }
 
    public int getPosX() {
        return posX;
    }
 
    public void setPosX(int posX) {
        this.posX = posX;
    }
 
    public int getPosY() {
        return posY;
    }
 
    public void setPosY(int posY) {
        this.posY = posY;
    }
 
 
 
}

**joel.drigo** · 17/02/2018, 19h06

Déjà, ça, ça ne peut pas fonctionner :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
int[] li = {i,j};
            if(ar.contains(li)){
```
La liste ar ne peut pas contenir le tableau li si tu n'as pas fait ar.add(li). Parce que contains se base sur equals() et que la méthode equals() d'un tableau ne compare que les références d'objets, pas les valeurs dans le tableau. Autrement dit,
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
3
int[] a={0,1};
int[] b={0,1};
System.out.println(a.equals(b));
```
Affiche false.

Si ton but est de manipuler des points (2 coordonnées), utilise la classe Point au lieu d'un tableau de deux int.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
    private List<Point> ar = new ArrayList<>();
```
C'est à cause de ce contains principalement que ton affichage reste vide (ta liste ar est vide après l'appel de rep).

Et pour l'affichage :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
    public void paintComponent(Graphics g){
        try {
            for (int i = 0; i < this.max; i++) {
                int[] s = (int[]) this.ar.get(i);
                g.fillRect(s[0] * 5, s[1] * 5, 5, 5);
                System.out.println(s[0] + " " + s[1]);
 
            }
        }catch(IndexOutOfBoundsException i){
            System.out.println("aïe");
        }
 
    }

Parcourir plus d'éléments qu'il y a dans la liste et attraper les exceptions est absurde.

Faire plutôt

Code :

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

1
2
3
4
5
6
7
    public void paintComponent(Graphics g){
            for (int i = 0; i < this.ar.size(); i++) {
                int[] s = (int[]) this.ar.get(i);
                g.fillRect(s[0] * 5, s[1] * 5, 5, 5); 
            }
 
    }

Si vraiment tu veux afficher au maximum max points même s'il y'en a plus, tu peux faire :

Code :

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

1
2
3
4
5
6
7
    public void paintComponent(Graphics g){
            for (int i = 0; i < max && i<this.ar.size(); i++) {
                int[] s = (int[]) this.ar.get(i);
                g.fillRect(s[0] * 5, s[1] * 5, 5, 5); 
            }
 
    }

Sinon, autant faire même, en utilisant des Point

Code :

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

1
2
3
4
5
6
    public void paintComponent(Graphics g){
            for (Point s : this.ar) {
                g.fillRect(s.x * 5, s.y * 5, 5, 5); 
            }
 
    }

C'est carrément plus simple, non ?
Et même si tu veux limiter à max points tu peux faire :

Code :

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

1
2
3
4
5
public void paintComponent(Graphics g){
    this.ar.stream().limit(max).forEach( {s->
                g.fillRect(s.x * 5, s.y * 5, 5, 5); 
    });
}

Ensuite, ça ne sert à rien et ça complique tout de faire :

Code :

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

1
2
3
4
    public ArrayList create(ArrayList ar){
        ar.add(new int[]{0, 20});
        return ar;
    }

La liste est un attribut de la classe, inutile de la passer en argument.

Code :

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

1
2
3
4
    public void  create(){
    	ar.clear();
        ar.add(new Point(0, 20));
    }

Pour la méthode rep, il y a plusieurs points douteux. Je ferais plutôt :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
3
4
public void start() {
     create();
     rep(ar,0);
}
```
et appeler start() dans Fenêtre1. Pas besoin de récupérer la liste dans le panneau pour la repasser en argument de l'appel.

Ensuite, repaint() c'est pour repeindre après une modification, pas avant. Donc;, au lieu du repaint() au début de rep() :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
3
 
this.ar=ar;
repaint();
```
Alors c'est vrai qu'au premier appel ça sert à rien puisque ar c'est this.ar (enfin, c'est un raccourci sémantique pour dire que la liste référencée par ar est celle référencée aussi par this.ar), mais ça ne coûte pas grand chose (on peut faire un petit test éventuellement pour optimiser, mais ça ne me semble pas utile).

Sinon j'ai un doute justement sur le ar à droite. Tu crées une nouvelle liste (variable ar1) et ensuite tu fais un appel récursif avec cette liste. Elle n'est donc utilisée que l'autre de l'appel récursif. Si i>=5 tu ne fais pas l'appel récursif. Donc tu as créer une liste qui n'est jamais utilisée. Donc tu as consommé des ressources pour rien.

En plus, ça ressemble bien à un système de dessin fractal et j'ai comme l'ipression que tu cherches à obtenir un dessin progressif (une sorte d'animation), ce qui ne risque pas de fonctionner comme tu le fais.

tableau à x dimensions

avec Java

Vue hybride

Discussions similaires

Partager

Partager