Stockage de différents types d'éléments dans une liste en Java
J'essaie de développer un chargeur de table général dont le schéma est connu à l'exécution. Cela nécessite d'avoir une classe qui contient une liste des différents types d'éléments et prend en charge diverses méthodes get et set comme getInt(int index), asString(int index), asStringList(int index). Les types d'éléments que je considère sont Integer, Double, String, et List<Integer>, List<Double> et List<String>. Le type réel de chaque élément est connu au moment de l'exécution, et je les stockerai dans une liste décrivant son schéma pour un traitement ultérieur.
Ma question est: devrais-je magasin cette liste d'éléments dans List<Object> ou List<? extends Object>? ou existe-t-il un meilleur moyen d'implémenter une telle classe?
2 answers
Puisque l'ancêtre commun de vos classes est Object, et parce que List<? extends Object> ne rend pas les choses plus propres (après tout, tout s'étend Object), il semble que List<Object> serait un choix CORRECT.
Cependant, une telle liste serait un sac mixte: vous devrez vérifier le type d'exécution de l'objet à l'intérieur et prendre des décisions en fonction de cela. Ce n'est certainement pas une bonne chose.
Une meilleure alternative serait de créer votre propre classe qui implémente des opérations sur les éléments de la liste de manière uniforme, et créez une sous-classe pour chaque sous-type qui implémente ces opérations différemment. Cela vous permettrait de traiter la liste de manière uniforme, en poussant la différenciation par objet dans vos wrappers.
public interface ItemWrapper {
int calculateSomething();
}
public abstract class IntWrapper implements ItemWrapper {
private int value;
public IntWrapper(int v) {
value=v;
}
public int calculateSomething() {
return value;
}
}
public abstract class DoubleListWrapper implements ItemWrapper {
private List<Double> list;
public DoubleListWrapper (List<Double> lst) {
list = lst;
}
public int calculateSomething() {
int res;
for (Double d : list) {
res += d;
}
return res;
}
}
// ...and so on
Maintenant, vous pouvez faire une liste de ItemWrapper objets, et calculateSomething sans vérification de leur type:
List<ItemWrapper> myList = new ArrayList<ItemWrapper>();
for (ItemWrapper w : myList) {
System.out.println(
w.calculateSomething());
}
Vous devez utiliser List<Object>, ou quelle que soit la super classe la plus proche. Une fois, j'ai posé une question similaire qui a amassé quelques très bonnes réponses qui a beaucoup d'informations pertinentes pour vous. Je vérifierais. Fondamentalement, tout se résume àPECS - Producer Extends, Consumer Super .