tableau à x dimensions

Version imprimable

16/02/2018, 22h47
benoitdegaridel

tableau à x dimensions

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!

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:

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.

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:

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

Citation:

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.

Citation:

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:

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

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.

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:

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:

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

Déjà, ça, ça ne peut pas fonctionner :
Code:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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.

17/02/2018, 22h08
benoitdegaridel

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!
18/02/2018, 12h42
benoitdegaridel

1 pièce(s) jointe(s)

Salut, j'ai juste un problème de code, je ne vois pas comment le régler...
Pièce jointe 352187

1 pièce(s) jointe(s)

C'est bon voila le résultat...
Pièce jointe 352214

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:

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

Citation:

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:

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:

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:

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:

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:

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:

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:

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

Tu peux faire :

Code:

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.