Discussion :

[avia767]

bonjour, je veux coder un tableau d'objet a plusieurs diemension, lequel suggerer vous HashMap ou Arraylist, avez vous des exemples simples ?

[boijea]

Salut,

Cela dépend de ce que tu veux faire!
Tu peux avoir de simple tableaux comme:

Code :

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

1
2
int tabl1[] = {1, 2, 3, 5, 8, 13};
String tabl2[] = {"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"};

et les référencer avec leurs indexes (ici pour samedi tu as 13).

Tu peux aussi créer une classe avec des attributs et créer un tableau d'objet de cette classe et avoir des méthodes de recherche et d'accès.

Il y a plein de "collections" dans les APIs de Java ... et encore une fois ... cela dépend de ce que tu veux faire! Il faudra peut-être aussi considérer les tris ou les insertions!

Cordialement

[avia767]

Merci boijea, au faite j'aimerai utiliser Arraylist pour ces avantage mais je ne trouve pas comment le declarer de la meme facon que l'exemple suivant avec Hashage

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
public class MyGrids {
 
	private HashMap gridList;
	private HashMap gridMap;
 
	public HashMap getGridMap() {
		if (gridMap == null)
			initGridMap();
 
		return gridMap;
	}
 
 
	public void initGridMap() {
		gridList = new HashMap();
		Map row;
 
		row = new HashMap();
		row.put("colonne1", "value-ligne1");
		row.put("colonne2", "value-ligne1");
		row.put("colonne3", "value-ligne1");
		row.put("colonne4", "value-ligne1");
		row.put("colonne5", "value-ligne1");
		gridList.put("value-ligne1", row);        
 
		row = new HashMap();
		row.put("colonne1", "value-ligne2");
		row.put("colonne2", "value-ligne2");
		row.put("colonne3", "value-ligne2");
		row.put("colonne4", "value-ligne2");
		row.put("colonne5", "value-ligne2");
		gridList.put("value-ligne2", row);
 
                gridMap = new HashMap();
		gridMap.put("totalSize", new Integer(gridList.size()));
		gridMap.put("data", gridList.values().toArray());
	}

[CyberChouan]

Les tableaux à plusieurs dimensions sont gérés nativement en java...
Tu n'as pas besoin d'utiliser des List ou des Map, qui ne sont pas forcément bien adaptées à ce problème.

Code :

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

int[][] matriceEntiers = new int[3][3];

Maintenant, si tu veux vraiment passer par des objets, tu as la solution des listes de listes de listes... Pour une matrice à 3 dimensions:

Code :

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

List<List<List<Integer>>>

La permière liste contenant la première coordonnée, la deuxième liste la deuxième coordonnée, etc.
Mathématiquement, on casse la symétrie du problème: tu n'as accès à la deuxième coordonnée qu'après avoir fixée la première, etc.

Une approche plus mathématique (et à mon avis plus jolie) serait de passer par un objet "Coordonnees", qui serait la clé permettant d'accéder à la valeur correspondante dans une Map:

Code :

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

1
2
3
4
5
6
7
8
9
10
public class Coordonnees {
   private int x;
   private int y;
   private int z;
   // ...
}
 
public class TableauTroisDim extends Map<Coordonnees, Integer> {
   // ...
}

Attention dans ce cas à bien redéfinir les méthodes "equals", "hashcode", etc. de la classe Coordonnees, voire à définir un ordre sur les coordonnées (en implémentant l'interface "Comparable").

[philippe6]

Bonjour,
je relance une discussion bien ancienne, il me semble.
J'y ajoute une question thorique.
Cyberchouan y a dit que pour une "liste de liste de liste"
on pouvait écrire

Code :

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

1
2
 
List<List<List<Integer>>>

.
Je souhaite creer non pas une liste de 3 dimensions mais de cinquante.

Je ne comprend pas la ligne
Public class TableauTroisDim extends Map<Coordonnees, Integer>
je suppose que c'est elle qui méviterait d'écrire un code absurde (entre autre).
Pourquoi créer une telle liste de cinquante listes :

les listes seront de longueur inégales :

si j'utilise add.element pour une liste, elle s'allongera par rapport aux autres.

En langage C je peux le faire avec des pointeurs sur pointeurs :

Code :

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

1
2
 
int ***pointeur

(cinquante * s'il le faut aberrant mais theoriquement possible)
Pourrais-je obtenir le même résultat en java qui est le langage que j'utilise maintenant et assez maladroitement. Ais-je intérêt a maitriser cette fameuse ligne plus haut (si je ne cours pas après des chimères).
Il y a peut être beaucoup plus simple ex :int [][] tab = new int[50][50].

Merci,

Philippe

[joel.drigo]

Salut,

tout d'abord

Code :

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

int [][] tab = new int[50][50]

n'est pas la définition d'un tableau à 50 dimensions mais d'un tableau à 2 dimensions dont la taille est 50 x 50.

Gérer un tableau à 50 dimensions sous forme de liste de liste de liste de ... serait carrément lourdingue.

Quant au code suivant

Code :

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

1
2
3
public class TableauTroisDim extends Map<Coordonnees, Integer> {
   // ...
}

indique qu'on veut définir une nouvelle classe représentant un tableau à 3 dimensions en "étendant" l'interface Map, et en indiquant que les clefs sont des instances de classe Coordonnees et les valeurs de classe Integer.

Premièrement, Map étant une interface, on extends pas, on implémente : on devrait donc écrire :

Code :

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

1
2
3
public class TableauTroisDim impléments Map<Coordonnees, Integer> {
   // ...
}

Mais ceci pose un autre petit problème : il est nécessaire d'implémenter l'ensemble des méthodes de l'interface Map, ce qui fait un travail conséquent et pas forcément utile pour la question à résoudre.

On pourrait étendre HashMap à la place, pour éviter cette implémentation, mais personnellement, je trouve qu'offrir des méthodes de gestion de Map, sans rapport avec l'aspect tableau à n dimension, n'est pas très utiles et risque de rendre la gestion de la classe erratique. J'encapsulerais plutôt la map, et j'implémenterais uniquement les méthodes propres à l'aspect tableau à n dim (lire une valeur, écrire un valeur, toString() pour afficher, l'égalité, et éventuellement des méthodes standard de gestion de matrice si nécessaire)

Ensuite pour gérer l'aspect dimension quelconque, plutôt que de créer n variables dans la classe Coordonnees, on pourrait gérer un tableau de coordonnées dont la taille serait le nombre de dimensions, mais ça pose un petit souci pour gérer la cohérence (on pourrait manipuler des coordonnées de dimensions différentes sur la même matrice, à gérer donc pour éviter les problèmes).
En plus, pour un tableau, la taille est important également (à déterminer si on veut faire des matrices, donc la taille de chaque dimension est la même, ou des tableaux de dimensions différentes)


Donc pour résumer, on peut faire une classe coordonnées :

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
public class Coordonnees {
 
      private int[] coordonnees;
 
    public Coordonnees(int dim) {
         this(new int[dim]);
    }
    public Coordonnees(int[] coordonnees) {
         this.coordonnees=coordonnees;
    }
 
    public int getNombreDimensions() {
       return coordonnes.length;
   }
 
    public void setCoordonnee(int dim, int valeur) {
        coordonnees[dim]=valeur;
    }
 
    public int getCoordonnee(int dim) {
      return coordonnes[dim];
}
 
    ...
 
    // il est nécessaire d'écrire les méthodes hashCode() et equals(Object) pour rendre efficace la map.
 
}

Et pour le tableau :

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
public class TableauNDimensions<V> {
 
      private Map<Coordonnees, V> valeurs = new HashMap<Coordonnees, V>();
private final int dim;
private final int[] sizes;
     /**
       * @param dimension le nombre de dimensions du tableau
          @param sizes les tailles de chaques dimensions
       */
     public TableauNDimensions(int dimension, int[] sizes) {
        if( sizes.length!= sizes) throw new IllegalArgumentException();
        this.dim=dimension;
        this.sizes=sizes;
     }
 
     public TableauNDimensions(int dimension, int size) {
        this(dimension, createTabSizes(dimension,size));
}
 
    private static int[] createTabSizes(int dimension,int size) {
int[] tab = new int[dimension];
Arrays.fill(tab, size);
return tab;
}
 
    /** verifie que les coordonnées sont valides */
    public final boolean verifie(Coordonnee xyz) {
if (xyz.getNombreDimensions() !=dim) return false;
          for(int i=0; i<dim; i++) {
              if ( xyz.getCoordonnee(i)<0 || xyz.getCoordonnee(i)>= sizes[i] )  return false;
          }
           return true;
    }
 
     public void setValeur(Coordonnees xyz, V valeur) {
         if ( verifie(xyz) ) {
               valeurs.put(xyz,valeur);
         }
         else throw new IllegalArgumentException("Coordonnees de mauvaise dimension");
     }
 
     ...
 
 
}

Et pour faire par exemple un tableau d'entiers à 50 dimensions :

Code :

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

1
2
3
4
5
6
7
8
9
10
public class Tableau50Dimensions extends TableauNDimensions<Integer> {
 
       public Tableau50Dimensions(int[] sizes) {
           super(50,sizes);
       }
       public Tableau50Dimensions(int size) {
           super(50,size);
       }
 
}

PS : j'ai tapé directement dans le forum, il y'a peut être quelques erreurs de frappe

[philippe6]

Merci,

j'apprécie ta réponse qui est complète, et qui me confirme que mon intention n'était pas accessible très facilement.
Je vais chercher à progresser lentement mais surement sur ce cas et je te remercie à nouveau

aurevoir

Philippe

[hwoarang]

Pour faire un tableau d'Integer de N dimensions avec des objets, il suffit de List<List<Integer>>. Ensuite, il faut ajouter un objet List<Integer> par dimension. S'il y en a 1, on a un tableau à 1 dimension, s'il y en a 2, on a un tableau à 2 dimensions, ...
Eventuellement, on peut vouloir surclasser la liste principale afin de s'assurer que les liste de chaque dimension possedent bien le bon nombre d'elements (50 par exemple pour un tableau 50x50).