tableau à x dimensions

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

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, 01h35

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, 15h43

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, 16h57

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, 17h11

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, 18h06

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.

**benoitdegaridel** · 17/02/2018, 22h08

Bonsoir, oui c'est mon but, un petit exercice de changement de règles mais pour ça je dois définir la progression de l'affichage.

Après, les Arraylists, je ne les ai jamais vraiment utilisées, ni les points, d'ailleurs mais je vais essayer comme ça merci!

**benoitdegaridel** · 18/02/2018, 12h42

Salut, j'ai juste un problème de code, je ne vois pas comment le régler...
Nom : 11.PNG
Affichages : 115
Taille : 5,1 Ko

**benoitdegaridel** · 18/02/2018, 15h36

C'est bon voila le résultat...
Nom : arbre.PNG
Affichages : 118
Taille : 92,1 Ko

Je pense que la notion d'exposant est plus claire à présent...
J'ai toujours des erreurs à cause du repaint, qui doit je pense, se faire automatiquement lors d'une mise à jour de la fenetre ,pendant la modif de la List...
Merci encore pour tes conseils!

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
package Utils;
 
import javax.swing.*;
import java.awt.*;
import java.awt.Point;
import java.util.*;
import java.util.List;
import java.lang.Math;
 
 
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;
    private List<Point> ar = new ArrayList<>();
    public int max = 60;
 
    public Panneau(){
        this.setBackground(Color.WHITE);
 
 
    }
 
    public void start() {
        create();
        rep(ar,0,9);
    }
 
    public void  create(){
        ar.clear();
        ar.add(new Point(0, 750));
    }
 
 
 
    public void paintComponent(Graphics g){
 
        try {
            this.ar.forEach(s -> {
 
                g.fillRect(s.y , s.x , 1, 1);
            });
        }catch(ConcurrentModificationException c){
            System.out.println("---------------------");
            System.out.println("Aïe");
            System.out.println("---------------------");
        }
    }
 
 
    private void rep(List<Point> ar, int i,int k){
        if(i<Math.pow(2,(double)k)-1) {
            List<Point> ar1 = new ArrayList<>();
            System.out.println(i+2);
            ar.forEach(s -> {
 
                if(s.y<1500 && s.y>0 && s.x==i){
                    if(!ar.contains(new Point(s.x,s.y-1)) && !ar.contains(new Point(s.x,s.y-2))){
                        ar1.add(new Point(s.x+1,s.y-1));
                    }
                    if(!ar.contains(new Point(s.x,s.y+1)) && !ar.contains(new Point(s.x,s.y+2))){
                        ar1.add(new Point(s.x+1,s.y+1));
                    }
                }
            });
            for(Point p : ar1){
                ar.add(p);
            }
            this.ar = ar;
            repaint();
            rep(ar, i + 1,k);
        }
        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** · 19/02/2018, 10h29

Envoyé par benoitdegaridel

J'ai toujours des erreurs à cause du repaint, qui doit je pense, se faire automatiquement lors d'une mise à jour de la fenetre ,pendant la modif de la List...

C'est le cas. Tu peux éviter ça :

si tu n'as pas besoin d'effet d'animation (le dessin se fait seulement à la fin en une seule fois), tu peux forcer l'exécution dans le thread de Swing. Ainsi, la construction de la liste n'est pas concurrente au dessin.
L'autre solution est d'affecter la variable à la fin du processus. C'est probablement le mieux ici, puisque ça évitera de bloquer le thread de Swing.

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 start() {
        List<Point> ar = create();
        rep(ar,0,9);
        this.ar = ar;
        repaint();
    }
 
    public List<Point>  create(){
    	List<Point> ar = new ArrayList<>();
        ar.add(new Point(0, 750));
        return ar;
    }

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
private void rep(List<Point> ar, int i,int k){
        if(i<Math.pow(2,(double)k)-1) {
            List<Point> ar1 = new ArrayList<>();
            System.out.println(i+2);
            ar.forEach(s -> {
 
                if(s.y<1500 && s.y>0 && s.x==i){
                    if(!ar.contains(new Point(s.x,s.y-1)) && !ar.contains(new Point(s.x,s.y-2))){
                        ar1.add(new Point(s.x+1,s.y-1));
                    }
                    if(!ar.contains(new Point(s.x,s.y+1)) && !ar.contains(new Point(s.x,s.y+2))){
                        ar1.add(new Point(s.x+1,s.y+1));
                    }
                }
            });
            for(Point p : ar1){
                ar.add(p);
            }
            //this.ar = ar;
            //repaint();
            rep(ar, i + 1,k);
        }
        //repaint();
    }

Si tu veux avoir un affichage progressif, on peut utiliser un timer, mais ça oblige à transformer la récursivité en boucle à plat, ce qui est très facile dans ton cas, parce que la condition d'arrêt est du type i<max.

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
public void start() {
        create();
 
        new Timer(33, new ActionListener() {
 
        	final int max = (int)Math.pow(2,9)-1;
			int i=0;
 
			@Override
			public void actionPerformed(ActionEvent e) {
	        	rep(ar, i++);
	        	if (i >=max ) {
	        		((Timer)e.getSource()).stop(); 
	        	}
			}
 
 
		}).start(); 
    }
 
    public void  create(){
        ar.add(new Point(0, 750));
    }

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
private void rep(List<Point> ar, int i ){
            List<Point> ar1 = new ArrayList<>();
            System.out.println(i+2);
            ar.forEach(s -> {
 
                if(s.y<1500 && s.y>0 && s.x==i){
                    if(!ar.contains(new Point(s.x,s.y-1)) && !ar.contains(new Point(s.x,s.y-2))){
                        ar1.add(new Point(s.x+1,s.y-1));
                    }
                    if(!ar.contains(new Point(s.x,s.y+1)) && !ar.contains(new Point(s.x,s.y+2))){
                        ar1.add(new Point(s.x+1,s.y+1));
                    }
                }
            });
            for(Point p : ar1){
                ar.add(p);
            }
            //this.ar = ar;
            repaint()

A noter plusieurs choses, non exhaustivement.

Evite de boucler sur l'ensemble d'une liste surtout si c'est pour ne traiter que certains éléments de la liste
Au lieu de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 ar.forEach(s -> {
 
                if(s.y<1500 && s.y>0 && s.x==i){
                    if(!ar.contains(new Point(s.x,s.y-1)) && !ar.contains(new Point(s.x,s.y-2))){
                        ar1.add(new Point(s.x+1,s.y-1));
                    }
                    if(!ar.contains(new Point(s.x,s.y+1)) && !ar.contains(new Point(s.x,s.y+2))){
                        ar1.add(new Point(s.x+1,s.y+1));
                    }
                }
            });

Code :

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

1
2
3
4
5
6
7
8
9
10
11
ar.stream().filter(s-> s.y<1500 && s.y>0 && s.x==i).forEach(s -> {
 
                //if(s.y<1500 && s.y>0 && s.x==i){
                    if(!ar.contains(new Point(s.x,s.y-1)) && !ar.contains(new Point(s.x,s.y-2))){
                        ar1.add(new Point(s.x+1,s.y-1));
                    }
                    if(!ar.contains(new Point(s.x,s.y+1)) && !ar.contains(new Point(s.x,s.y+2))){
                        ar1.add(new Point(s.x+1,s.y+1));
                    }
                //}
            });

Évite de calculer plusieurs fois un résultat invariable. Au lieu de passer k=9, et de comparer à Math.pow(2,k)-1, tu peux simplement directement passer max=Math.pow(2,k)-1 et faire i<max pour la condition d'arrêt.

Au lieu de

Code :

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

1
2
3
for(Point p : ar1){
                ar.add(p);
            }

Tu peux faire :

Code :

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

ar.addAll(ar);

Ta première idée de créer des tableaux au fur et à mesure aurait donner un programme plus performant. Simplement, ce n'était pas un tableau à n dimension, c'était un tableau de List de Point, le premier tableau étant de taille maximal définie dès le départ (max = 2^k-1). Simplement, à la première récursion on a qu'un seul élément, puis 2, puis 3, donc une taille variable : pour gérer ça il suffit simplement de créer un tableau de la taille maximal, et de gérer avec int le nombre d'éléments (ce qui permet en plus de ne pas avoir de souci avec la concurrence d'accès entre le dessin et la construction, puisqu'on construit toujours une nouvelle liste au delà du nombre de listes à dessiner. On peut probablement déterminer le nombre maximal de points dans chaque liste, et donc faire un tableau à 2 dimensions. Ce qui serait probablement le plus performant.

tableau à x dimensions

avec Java

Discussions similaires

Partager

Partager