Tableau à deux dimensions de Listes

Je suis dans le besoin de une matrice en deux dimensions de liste, par exemple, ArrayList, et je me demande ce qui est le plus préférable dans ce cas. Il ne doit être de taille 4x4.

Dois-je utiliser quelque chose comme

    ArrayList[][] foo = new ArrayList[4][4];

ou

    ArrayList<SomeClass>[][] foo = new ArrayList[4][4];

et initialiser tous les éléments avec le bon type dans une boucle for ou

    ArrayList<ArrayList<ArrayList<SomeClass>>> foo = ArrayList<ArrayList<ArrayList<SomeClass>>>();

La première méthode génère des avertissements, comme il devrait être paramétrées et si j'ajoute l'utilisation de la deuxième-je obtenir unchecked conversion des avertissements. Mais si je boucle sur les éléments et les initialiser, il ne devrait pas y avoir de problème, même si j'ai toujours l'avertissement? La dernière méthode ne permet pas de générer des avertissements et fonctionne probablement très bien, mais il se sent un peu en désordre.

EDIT: j'Ai quelques belles réponses à ma question, même si elle était un peu floue. Mais c'était essentiellement de la façon de faire un tableau de Listes. Créer une classe personnalisée pour gérer les lignes/colonnes, il fait un beaucoup plus facile.

  • La deuxième méthode devrait lire: ArrayList<SomeClass>[][] foo = new ArrayList<SomeClass>[4][4];, cependant, ayant un tableau de listes semble un peu bizarre. Avez-vous vraiment besoin d'un tableau en 2 dimensions? Si oui, pourriez-vous préciser un peu plus d'informations sur la raison?
  • Ayant ArrayList<SomeClass>[][] foo = new ArrayList<SomeClass>[4][4]; Est produit le message d'erreur "Impossible de créer un générique de tableau de ArrayList<SomeClass>, c'est pourquoi je l'ai laissée 🙂
  • Et la raison pour laquelle j'ai besoin c'est que j'ai une table contenant des "résultats". En fonction du résultat d'une opération, je veux ajouter ces objets à l'une de ces listes dans le tableau 2D. Ne fait que rendre les choses plus claires? 🙂
InformationsquelleAutor Mattias | 2011-07-18
  1. 5

    Fixer la première méthode comme suit:

    Liste[][] foo = new ArrayList[4][4];

    La deuxième méthode n'est pas ce dont vous avez besoin. Vous essayez de créer 4 dimensions tableau au lieu de 2 dimensions de la matrice de 4*4 éléments.

    En outre, je voudrais vous donner un conseil: ne jamais utiliser de la classe de béton dans la partie gauche d'une affectation, c'est à dire ArrayList list = .... Utilisation List list = ...

    Et éviter d'utiliser trop compliqué structures de données. 2 dimensions tableau de listes est trop compliqué. Créez votre propre classe qui encapsule certaines fonctionnalités, puis de créer une collection ou un tableau (mieux 1 dimensions) d'objets de votre classe.

    • Okey, merci pour l'astuce! Pourriez-vous expliquer pourquoi vous ne voulez pas utiliser un béton de classe de la gauche de cession? Avec la classe personnalisée, j'avais encore envie de quelque chose qui ressemble à un tableau 2D. Mais au lieu de mettre en œuvre comme un tableau 1D et de créer des méthodes comme la getRow() et getColumn()?
    • Dans la plupart des cas vous souhaitez utiliser l'interface à la place d'un béton de classe, car ensuite, vous pouvez échanger le ArrayList avec un LinkedList si nécessaire. Si vous avez besoin de plus d'informations sur les capacités (comme triés ou non) que vous pourriez avoir des interfaces supplémentaires (pensez à Set vs SortedSet) mais sachant que des implémentations concrètes est rarement utile à l'utilisateur d'une méthode.
    • Ah, je vois. Merci pour l'explication! Je pense que j'ai trié maintenant, fait une classe personnalisée définition de chaque colonne et une méthode pour insérer le résultat dans la position correcte. Il a fait tout beaucoup plus facile.
    InformationsquelleAutor AlexR
  2. 1

    Ici l'exemple de matrice 2x2 avec l'initialisation explicite.

    Liste<Maclasse>[][] matr = new List<Maclasse>[][] { 
new List<Maclasse> { new ArrayList<Maclasse>(), new ArrayList<Maclasse>() }, 
new List<Maclasse> { new ArrayList<Maclasse>(), new ArrayList<Maclasse>() } 
}
    InformationsquelleAutor setec
  3. 0

    Comme Alex l'a déjà dit, avoir un 2 dimensions tableau de listes est assez compliqué et facile de se tromper ou être utilisé dans une wron façon.

    Depuis votre tableau doit représenter un tableau, vous pouvez créer des classes pour les lignes ou les colonnes, selon ce qui est le plus important.

    Alternativement, vous pouvez créer une classe pour chaque cellule de la table et de gérer un tableau 2D de cellules, si vous savez exactement quel est le nombre de cellules que vous auriez:

    class Cell {
  private List<SomeClass> content = new ArrayList<SomeClass>();
  ...
}

Cell[][] matrix = new Cell[4][4];  //don't forget to initialize each cell
    InformationsquelleAutor Thomas
  4. 0
        public static class Grid<T> {
public interface TFactory<T> {
T create();
}
private T[] data;
private int d1;
private int d2;
public Grid(int d1,
int d2,
Class<T> clazz,
TFactory<T> fac) {
this.d1 = d1;
this.d2 = d2;
data = (T[]) Array.newInstance(clazz, d1 * d2);
for (int i = 0; i < data.length; i++) {
data[i] = fac.create();
}
}
public T get(int c1,
int c2) {
return data[c1 * d2 + c2];
}
}
public static class ArrayListFactory<X> implements Grid.TFactory<ArrayList<X>> {
public ArrayList<X> create() {
return new ArrayList();
}
}
public static void main(String[] args) throws RTXException, ParseException {
//cannot use new new ArrayList<String>[4][4];, because of generic array creation error
List<String>[][] a2d = new ArrayList[4][4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
a2d[i][j] = new ArrayList<String>();
}
}
Grid g = new Grid(4, 4, ArrayList.class, new ArrayListFactory<String>());
}

    Voici deux approches. D'abord est ce que vous avez demandé, la seconde est encapsulé version (avec tableau 2d transformé en 1d tableau pour faciliter interne de manipulation).

    Comme l'a dit avant, vous devez déclarer des variables comme les interfaces autant que possible (mais pas plus).
    Que dire, si tout ce que vous voulez dire, c'est, à ses une Liste et ne pas attendre que quelqu'un se comporter différemment en fonction de la mise en œuvre concrète, il suffit d'utiliser la Liste, pas de liste de tableaux comme type de variable.
    Mais si vous utilisez par exemple. LinkedSet il peut être une bonne idée d'utiliser LinkedSet comme type de variable (et en tant que valeur de retour de fonctions), si vous voulez la "promesse" qu'il énumère tous les éléments rapidement et dans l'ordre d'insertion. Si vous utilisez Set, l'utilisateur ne dépend d'aucun ordre particulier de l'itération.

    btw. méfiez-vous de l'initialisation explicite. Il est agréable de syntaxe, mais il crée anonyme intérieur de la classe et elle peut conduire à inintended la rétention de la classe parent. Mais si vous savez ce que vous faites et qu'il n'est pas possible de se passer (aucune référence) il n'y a rien de mal à l'utiliser.

    InformationsquelleAutor Alpedar