Comment initialiser une Liste<E> dans vide le constructeur de la classe?

Le code suivant n'est évidemment pas de travail parce que List<E> est abstraite:

public class MyList {
    private List<E> list;

    public MyList() {
        this.list = new List<E>();
    }
}

Comment puis-je initialiser MyList classe avec un constructeur vide si j'ai besoin de la list variable à un LinkedList ou un ArrayList en fonction de mes besoins?

la liste n'est pas marqué comme final. A-t-elle être initialisée dans le ctor?
Oui, il doit être initialisé dans le constructeur.
Est un utilitaire usine de classe acceptable? D'après les commentaires, j'ai l'impression que vous voulez que la mise en œuvre de type configurable, et qui suggère une Usine utilisée par MyList.
Je ne sais pas vraiment savoir ce que va enquêter sur...
Peut-être vous avez besoin de clarifier CE que vous avez besoin et nous allons trouver la FAÇON de l'obtenir. Nous savons que vous avez besoin d'une liste. Mais pourquoi, parfois, vous avez besoin d'un Liés les uns et les autres un ArrayList? Si vous souhaitez ajouter un grand nombre d'éléments peut-être qu'un lien est ok et quand elle est terminée, vous voulez le transformer... Essayez de trouver le comportement réel de votre classe...

OriginalL'auteur Ricardo Amaral | 2010-05-21

3

Il existe de meilleures alternatives pour ce que vous essayez d'atteindre:
- Créer une classe de base (résumé?) et de la remplacer par deux fois, une fois pour ArrayList et un pour LinkedList
- Injecter la liste appropriée à votre classe (dependency injection)
J'avais une question à ce sujet il y a quelques heures et quelqu'un m'a recommandé cette solution au lieu de cela, regardez ici: stackoverflow.com/questions/2881684/...

OriginalL'auteur kgiannakakis
7

Je ne suis pas sûr de savoir si c'est ce que vous demandez...
```
public class MyList {
    private List<E> list;

    public MyList() {
        if (myNeeds)
            this.list = new LinkedList<E>();
        else
            this.list = new ArrayList<E>();
    }
}
```
Sorte de... je l'ai bien une solution mais je demande ici parce que je pensais peut-être il y a une meilleure façon, en quelque sorte. N'est-elle pas besoin myNeeds à être passé comme argument dans le constructeur? À l'encontre de l'objectif de la "constructeur vide".
Eh bien, sinon comment est l'objet va savoir quel type d'utilisation? Il aurait besoin d'être transmis au constructeur, ou être disponible par le biais de l'environnement (par exemple, certains classe singleton).
C'est exactement pourquoi j'ai posté la question sur SO...

OriginalL'auteur Thomas

Pourquoi ne pas utiliser un protégé (et éventuellement abstract méthode) comme:

public abstract class MyList<T> {

    protected final List<T> list;

    public MyList() {
        list = createList();
    }

    public MyList(boolean preferLinked) {
        list = preferLinked? new LinkedList<T>() : new ArrayList<T>();
    }

    //Allows client code which subclasses from MyList to override the
    //default behaviour

    protected List<T> createList() {
        return new ArrayList<T>();
    }
}

OriginalL'auteur Dirk

1
```
boolean shouldThisBeAnArrayList=true; //Set to false to use LinkedList
if(shouldThisBeAnArrayList) {
   this.list = new ArrayList<E>();

}
else {
   this.list=new LinkedList<E>();
}
```
Comme je l'ai dit dans un autre commentaire, qui irait à l'encontre de l'objectif d'un "constructeur vide" ne serait-il pas? Je veux dire, j'aurais besoin de passer la valeur de shouldThisBeAnArrayList en quelque sorte...

OriginalL'auteur Martin Tilsted
1

Vous devez déterminer ce que "vos besoins" sont par défaut dans le cas LinkedList ou ArrayList. Si vous ne pouvez pas dire, si le besoin s'en fonction des changements de quelque chose qui se passe sur l'objet de la durée de vie, puis la liste des besoins de changement, trop.

Il ne peut pas être un cas par défaut...
Puis le laisser nulle et de le créer à la demande, ou de faire sans le constructeur par défaut.

OriginalL'auteur Carl Manaster
1

Liste est une interface et en tant que tel, ne peut pas être construit. Uniquement des implémentations de ladite interface peut être construit (par exemple, liste de tableaux). Aussi, vous devez connaître le type (E) à la construction.

Cela devrait fonctionner:
```
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class MyList<E> {
    private List<E> list;

    public MyList(boolean linked) {
        if (linked) {
            list = new LinkedList<E>();
        } else {
            list = new ArrayList<E>();
        }
    }
}
```
Cette fois, quelqu'un m'a suggéré ça, mais comme je l'ai dit, n'est-elle pas à l'encontre du but de "constructeur vide"? Mais peut-être qu'il n'y a pas d'autre moyen... 😐
Vous pouvez construire une LinkedList par défaut et avoir une méthode setListType qui serait de construire une nouvelle liste de tableaux et de copier des données à partir de LinkedList.

OriginalL'auteur Robert Kovačević
0

Je pense que vous pourriez faire ce qui suit:
```
public class MyList<T> {
    private List<T> list;

    public MyList() {
        this.list = new ArrayList<T>();
    }
}
```
Comment cela fonctionne quand j'ai besoin d'un LinkedList au lieu d'un ArrayList?
où voulez-vous configurer le type de liste? Par objet ou peut-être à certains de démarrage des propriétés de fichier?
J'ai besoin d'elle pour être par objet...

OriginalL'auteur El Guapo
0

Que je comprends, vous ne pouvez pas utiliser simplement un constructeur vide, parce que vous avez une décision nœud dans votre modèle, lorsque vous devez choisir entre le type de la liste, donc, vous devrez dire au programme de toute façon ce genre de liste sera.
Cela semble être la meilleure solution à mon avis:
```
public class MyList {
    private List<E> list;

    public MyList() {
        this.list = new LinkedList<E>();
    }

    //an overload for another type,
    public MyList(bool INeedArray) {
      if (INeedArray)
        this.list = new ArrayList<E>();
    }
}
```
OriginalL'auteur Rbacarin
0
```
public class MyList<T> {
    private List<T> list = new ArrayList<T>();
}
```
C'est ce que j'utilise dans les classes.. j'ai une longue initialisé ce que j'ai pu lors de la définition de la variable privée elle-même.

OriginalL'auteur Ethode

Vous devez vous connecter pour publier un commentaire.