Instanciation d'un ArrayList

Bonjour,

Je ne comprends pas quelle est la différence entre :

Code:

---

ArrayList maListe = new ArrayList();

---

et

Code:

---

Collection maListe = new ArrayList();

---

Quels sont les avantages/désavantages de chaque méthode ?

Merci d'avance pour vos éclaircissements !

Citation:

---

Envoyé par aliasjcdenton

Code:

---

ArrayList maListe = new ArrayList();

---

---

En faisant ainsi ta variable est de type ArrayList, et tu peux appeler les méthodes ArrayList dessus.
Mais tout le code qui se sert de cette variable, exige que cette variable soit un ArrayList et ne marchera pas, par exemple avec une LinkedList ou un HashSet.

Citation:

---

Envoyé par aliasjcdenton

Code:

---

Collection maListe = new ArrayList();

---

---

En faisant ainsi ta variable est de type Collection. Tu ne peux pas appeler la méthode trimToSize() dessus, parce que c'est une méthode fournie uniquement par ArrayList.
Par contre, le code qui se sert de ta variable, se fiche à partir de maintenant, que cet objet soit un ArrayList, un LinkedList, un HashSet ou n'importe quelle Collection. Il marche avec absolument toutes les Collection, sans rien changer.

Par ailleurs :

En réalité de nos jours il faut utiliser les génériques. Quelque chose comme :

Code:

---

ArrayList<String> list = new ArrayList<String>();

---

ou

Code:

---

Collection<String> list = new ArrayList<String>();

---

Désolé pour ma réponse tardive.

Mais je ne comprends pas pourquoi ne pas utiliser

Code:

---

Collection<String> list = new Collection<String>();

---

puisqu'en utilisant

Code:

---

Collection<String> list = new ArrayList<String>();

---

, on ne peut de toute façon pas utiliser les méthodes propres à ArrayList.

Quel intérêt ?

Merci d'avance pour la réponse !

Bonjour,

Tu ne peux pas parce que Collection est une interface et non pas une classe (On ne peut pas instancier aussi une classe abstraite) mais la classe instanciée doit obligatoirement implémenté l'interface. Pour l'intérêt, tu peux voir ici.

A+.

Bonjour,
l'intérêt est également de donner la possibilité de faire évoluer, sans nouvelle modification de code.

Si tu déclares une classe composée d'une Collection de la façon suivante :

Code:

---

1 2 3 4 5 6 7 8

public class MaClasse{ private Collection<String> strings;   public MaClasse(Collection<String> strings) { this.strings=strings; } }

---

Tu as la possibilité, dans des programmes, d'utiliser MaClasse des façons suivantes :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

//Instance avec des strings dans un tableau dynamique MaClasse instance1=new MaClasse(new ArrayList<String>());   //Instance avec des strings dans une liste chaînée MaClasse instance2=new MaClasse(new LinkedList<String>());   //Instance avec des strings uniques MaClasse instance3=new MaClasse(new HashSet<String>());   //Instance avec des strings triés MaClasse instance4=new MaClasse(new ArrayList<String>());

---

Tu auras donc la possibilité d'utiliser ta classe et d'en obtenir des comportements différents, sans modifier son code, ce qui permet la réutilisabilité.

Avec la déclaration :
ArrayList strings = new ArrayList();

pas possible !

Pour faire les choses simplement.

Si ta variable est utilisée uniquement en interne, utilise le type explicite.

Par contre, si ta variable doit être exposée à d'autres classes, utilise les interfaces, ça permet de ne pas forcer l'appelant à utiliser un type déterminé alors qu'il voudrait en utiliser un autre.

Citation:

---

Envoyé par tchize_

Pour faire les choses simplement.

Si ta variable est utilisée uniquement en interne, utilise le type explicite.

Par contre, si ta variable doit être exposée à d'autres classes, utilise les interfaces, ça permet de ne pas forcer l'appelant à utiliser un type déterminé alors qu'il voudrait en utiliser un autre.

---

Je pense que tu voulais dire private local d'une méthode avec "en interne". Mais dans ce cas, c'est la même chose de déclarer une interface qui défini tous les besoins et de déclarer une classe.

A+.

En ce qui me concerne, c'est juste une habitude ui me semble raisonnable.

Si j'ai besoin de faire ceci:

Code:

---

1 2 3 4 5 6 7

public void maMethode(){ //... X x = ... x.add(...); x.add(...); //... }

---

Je trouve inutile d'aller jouer avec deux types, je me contente de directement mettre ArrayList, ou LinkedList dans X. Le jour ou je change d'avis, ca n'influence rien, j'ai juste le type interne à la méthode à change.

Par contre si je fait ceci

Code:

---

1 2 3

public void maMethode(X x){ //... }

---

Alors X est une interface pour ne pas forcer un type du coté de l'appelant.
Après tout, pour revenir à la uestion initiale du pourquoi. Si je fais ceci:

Code:

---

public void maMethode(ArrayList<Integer> liste)

---

L'appelant, si il a une LinkedList<Integer>, ou une List<Integer> dont l'implémentation concretes est indéterminée, il sera obligé de faire ça

Code:

---

1 2	LinkedList<Integer> l = .....; unTruc.maMethode(new ArrayList<Integer>(l));

---

ce qui est moche :)

Pareil si je m'en fou de l'ordre, je vais faire un

Code:

---

public void maMethode(Collection<Integer> liste)

---

Histoire de ne pas me retrouver à devoir faire un jour

Code:

---

1 2	Set<Integer> set = .....; unTruc.maMethode(new ArrayList<Integer>(set));

---

Merci à tous pour vos réponses ! J'ai bien compris maintenant.