Discussion :

[rtg57]

Bonjour,

est-il possible de rassembler un ensemble de tableaux de type différent, dans un tableau de type Object ?
Exemple:

Code :

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

1
2
3
4
5
6
  private ArrayList <Short> v_short = new ArrayList<Short>();
  private ArrayList <Byte> v_byte = new ArrayList<Byte>();
  private ArrayList <Long> v_long = new ArrayList<Long>();
  private ArrayList <String> v_string = new ArrayList<String>();
 
  private ArrayList <Object> structure_esoterique = new ArrayList<Object>();

puis faire à quelque part:

Code :

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

structure_esoterique.add(v_short(x), v_byte (x), v_long (x), v_string (x));

L'idée est de stocker dans un objet un ensemble de données (Un peu comme une structure créée dynamiquement en C++)

Merci et à bientôt...

[Deaf]

Bonjour!

Ce que tu fais est possible, mais après, je ne suis pas sûr de ce que tu veux faire exactement. Il existe peut-être une autre solution plus adaptée.

Peux-tu préciser ton besoin?

[Freeluvs]

Salut,

Pourquoi ne pas créer un objet qui hériterais du type Tableau, dont le constructeur demanderait les arguments suivant: v_short(x), v_byte (x), v_long (x), v_string (x) ?
Après tu pourrais redéfinir la méthode .add() pour qu'elle ajoute ça à la suite de ton objet !

[rtg57]

Merci pour votre soutien...

l'idée est d'avoir des listes de type différent, pouvant être augmentées ou diminuées dynamiquement.
Mais je voudrais pouvoir créer une espèce de tableau regroupant tous ces listes. Cela me permettrait de gérer individuellement chaque liste, mais aussi de pouvoir éventuellement traiter l'ensemble dans sa globalité.

Si l'on imagine que chaque liste représente une colonne (d'une feuille EXCEL par exemple (C'est pour l'image )), l'assemblage de ces colonnes les unes à coté des autres donnerait une table à 2 dimensions (une espèce de JTable (C'est pour l'image )).

Evidemment, je pourrais créer une classe avec des variables internes v_short, v_byte, v_long, v_string... et ensuite créer dynamiquement des instances de cette classe...

Mais pour le cas, cela ne m'intéresse pas. C'est pour cela que je voulais savoir si l'on pouvait rassembler des tableaux de différent type dans une espèce de conteneur général. (J'espère que ce n'est pas trop confus comme explication)

Merci et @ bientôt

[Deaf]

Tu peux toujours créer une List<List<?>>.
Ainsi, tu peux avoir l'élément à la ligne X et colonne Y (de ta feuille EXCEL, pour l'exemple ) de la manière suivante:

Code :

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

maStructure.get(Y).get(X);

Par contre, tu devras caster à chaque fois que tu récupèreras un élément...

[Heimdal]

C'est pour cela que je voulais savoir si l'on pouvait rassembler des tableaux de différent type dans une espèce de conteneur général

Une classe fera parfaitement l'affaire. J'ai peur de ne pas comprendre.?

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
public class Conteneur {
 
	private final List<Short> v_short;
	private final List<Byte> v_byte;
	private final List<Long> v_long;
	private final List<String> v_string;
 
	public Conteneur() {
		this.v_short = new ArrayList<Short>();
		this.v_byte = new ArrayList<Byte>();
		this.v_long = new ArrayList<Long>();
		this.v_string = new ArrayList<String>();
	}
 
	//autres constructeurs si tu veux
 
	public void add(short s) {
		v_short.add(s);
	}
 
	public void add(byte b) {
		v_byte.add(b);
	}
 
	//etc...
 
	public void add(short s, byte b) {
		v_short.add(s);
		v_byte.add(b);
	}
 
	//etc...
 
	public List<Short> getShorts() {
		return Collections.unmodifiableList(v_short);
	}
 
	public List<Byte> getBytes() {
		return Collections.unmodifiableList(v_byte);
	}
 
	//etc...
}

[rtg57]

Merci beaucoup pour ces bribes de codes,

Le code proposé par Heimdal est très intéressant, je n'avais pas pensé à ce type d'architecture (C'est pour ça que je poste chez les débutants ).

Quant au code proposé par Deaf, ça a l'air d'être du concentré.

Code :

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

 List  < List < ? > >

est-ce que cela construit une Liste contenant une Liste de type quelconque ?

[Deaf]

Je reprends tes couleurs:

List < List < ? > >

La List contient plusieurs List (ça reste une liste après tout) mais n'impose aucune contrainte quand au type de ces List. Après, rien n'empêche que les List soient typées (types différents si tu le souhaites).

[Heimdal]

Le code de Deaf m'a peut-être aidé à comprendre ce que tu recherchais...

Tu peux donc faire un truc très générique mais niveau utilisabilité je ne suis pas certain du truc. Je pense aussi que c'est largement améliorable (cf les pros des génériques)

Le conteneur:

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 GenericConteneur {
 
	private final Map<Class<?>, List<?>> map;
 
	public GenericConteneur() {
		map = new HashMap<Class<?>, List<?>>();
	}
 
	public <T> void add(T t) {
		if (map.containsKey(t.getClass())) {
			((List<T>) map.get(t.getClass())).add(t);
		} else {
			List<T> list = new ArrayList<T>();
			list.add(t);
			map.put(t.getClass(), list);
		}
	}
 
	public <T> void add(Object... objects) {
		for (Object obj : objects) {
			add(obj);
		}
	}
 
	public <T> List<T> getList(Class<T> objClass) {
		return map.get(objClass) != null ? Collections
				.unmodifiableList((List<T>) map.get(objClass))
				: new ArrayList<T>();
	}
 
	@Override
	public String toString() {
		StringBuilder builder = new StringBuilder();
		for(Map.Entry<Class<?>, List<?>> entry: map.entrySet()) {
			builder.append(entry.getKey().getSimpleName()).append("[");
			for(Object obj: entry.getValue()) {
				builder.append(obj).append(", ");
			}
			builder.replace(builder.length()-2, builder.length(), "");
			builder.append("]\n");
		}
		return builder.toString();
	}
 
}

Un ti exemple d'utilisation:

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
public static void main( String[] args )
    {
        GenericConteneur c = new GenericConteneur();
 
		c.add(4);
		c.add(8);
		c.add(7f);
		c.add("toto", "titi", "tata", 12, 0.4f);
		c.add(true, false, false);
		c.add(BigDecimal.ONE, BigDecimal.ZERO, BigInteger.TEN, Byte.decode(
				"077").byteValue(), 0xFFL);
 
		System.out.println(c);
 
		int sommeEntier = 0;
		for (Integer i : c.getList(Integer.class)) {
			sommeEntier += i;
		}
		System.out.println("Somme des entiers :"+sommeEntier);
    }

[rtg57]

Merci encore pour votre aide.

Il y a un truc que je ne pige pas:
j'ai essayé ce code:

Code :

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

private List<?> m_quelconque = new ArrayList<?>();

Le compilateur n'est pas d'accord sur le second "?". (Je le comprends un peu, en C++ je me serai fait insulté )
Alors j'essaie:

Code :

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

private final List<?> m_quelconque = new ArrayList<Object>();

C'est accepté, mais là, je me pose la question de l'intérêt du 1er "?", puisque je définis m_quelconque comme étant une 'ArrayList' d'objets. Ce n'est donc pas un type indéfini ça.

On dévie un peu du sujet de départ, mais la syntaxe Java m'intrigue parfois

[Deaf]

Oui, on peut aller très loin dans la généricité, mais il faut savoir où s'arrêter pour ne pas perdre l'avantage du typage et caster à tout bout de champ.

Je pense qu'honnêtement, si la première solution d'Heimdal répond à ton besoin, ce sera de loin la meilleure solution. Sinon, tu risque de te perdre, surtout si tu n'est pas encore tout à fait à l'aise avec les Generics.

Avant de vouloir faire trop générique, le mieux est de définir précisément ce que l'on veut et fixer des limites.

[professeur shadoko]

euh... j'a pas tout à fait compris...
t'es sûr que tu ne veux pas une simple liste de tuples

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class MonTuple { // data object
   short leShort ;
   byte leByte ;
   long leLong ;
   String laString ;
    // éventuellement constructeur
   // éventuellement membres final
 
}
 
List<MonTuple> laListe  = new ArrayList<MonTuple>(); // etc.
laListe.add(new MontUple(32,3,76876549890, "coucou")) ;

(entre parentèses utiliser des bytes et des shorts n'est pas d'un grand intérêt -sauf dans des cas très particuliers-)
bon je suppose que c'est pas le cas et que tu veux pouvoir gérer des listes de longueurs différentes.