pseudo structure de données

Version imprimable

Bonjour,

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

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:

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...

18/02/2010, 15h24
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?
18/02/2010, 15h37
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 !
18/02/2010, 16h16
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
18/02/2010, 16h44
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:

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

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

Citation:

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.? :calim2:

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

18/02/2010, 17h17
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 :mouarf: ).

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

Code:

List < List < ? > >

est-ce que cela construit une Liste contenant une Liste de type quelconque ?
18/02/2010, 17h24
Deaf

Je reprends tes couleurs:

Citation:

Envoyé par rtg57

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).

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:

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:

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

18/02/2010, 17h50
rtg57

Merci encore pour votre aide.

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

Code:

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é :mrgreen:)
Alors j'essaie:

Code:

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

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

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.

18/02/2010, 17h54
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.
18/02/2010, 18h02
Heimdal

Citation:

il faut savoir où s'arrêter pour ne pas perdre l'avantage du typage et caster à tout bout de champ.

Tout à fait d'accord. Je crois qu'il faut toujours préférer la clarté et la simplicité quitte à être verbeux.
18/02/2010, 18h46
rtg57

Merci à tous,

vous avez raison, je commence peut être un peu trop fort.
Je vais d'abord me faire la main, je découvrirai les subtilités avec l'expérience.

@ bientôt
19/02/2010, 01h21
thelvin

Citation:

Envoyé par rtg57

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

Code:

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é :mrgreen:)
Alors j'essaie:

Code:

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.

Je vais éviter de faire un cours complet sur les génériques, mais pour répondre : il n'y a pas d'intérêt à faire

Code:

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

C'est possible d'écrire ça, mais inutile.

En revanche, si un jour tu dois appeler une fonction qui prend un List<?> en paramètre, tu peux très bien lui passer un List<Object>. Voilà pourquoi c'était possible de l'écrire.

Je ne comprends pas pourquoi on t'as proposé de faire une List<List<?>>. Fondamentalement, List<?> est une Liste de quelque chose dont on ne sait pas ce que c'est. Attention à bien comprendre. Ça veut dire que quand on récupérera un élément de la liste, on ne sait pas ce que c'est, donc on récupérera un Object, la classe mère de toutes les classes. Et quand on veut y mettre quelque chose... Eh bien on ne peut pas, on n'a pas le droit. On ne sait pas ce que la liste contient, on ne sait donc pas ce qu'on a le droit d'y mettre.
Une List<?> ou une List<List<?>> est donc inadaptée si on a l'intention d'y ajouter des données. List<List<Number>> ou List<List<Object>> sont donc plus adaptés... Mais pas très pratique pour faire la distinction entre Long et Integer, par exemple. Raison pour laquelle une classe ad hoc est plus adaptée.
19/02/2010, 12h28
rtg57

Merci pour cette ultime précision.
J'en prends note.

@+