Liste de tableaux ou de déclaration de la Liste en Java

List<String> arrayList = new ArrayList<String>();

Est générique où vous souhaitez masquer les détails d'implémentation, tout en les retournant au client, au plus tard au cours de l'heure vous pouvez changer la mise en œuvre de ArrayList à LinkedList de manière transparente.

Ce mécanisme est utile dans les cas où la conception de bibliothèques, etc., qui peuvent changer leurs détails de mise en œuvre à un certain point dans le temps, avec un minimum de changements sur le côté client.

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

Cette mandats vous avez toujours besoin de retourner ArrayList. À un certain point dans le temps, si vous souhaitez modifier les détails d'implémentation de LinkedList, il devrait y avoir des changements sur le côté client de l'utiliser également LinkedList au lieu de ArrayList.

La différence est que la variante 1 vous oblige à utiliser un ArrayList tandis que la variante 2 ne garantit que vous avez quelque chose qui implémente List<String>.

Plus tard, vous pouvez modifier que pour List<String> arrayList = new LinkedList<String>(); sans trop de tracas. Variante 1 pourrait vous obliger à modifier non seulement la ligne, mais d'autres pièces si elles s'appuient sur le travail avec un ArrayList<String>.

Donc je ne l'utiliserais List<String> dans presque tous les cas, sauf quand j'avais besoin d'appeler les méthodes supplémentaires qui ArrayList offre (qui n'a jamais été le cas jusqu'à présent): ensureCapacity(int) et trimToSize().

Fondamentalement, il permet de Java pour stocker plusieurs types d'objets dans une structure de mise en œuvre, par le générique de la déclaration de type (comme class MyStructure<T extends TT>), qui est l'un des Javas principales caractéristiques.

Orientée objet approches sont basées dans la modularité et la réutilisabilité par séparation des préoccupations, - la capacité à utiliser une structure avec toute sorte de types d'objet (tant qu'elle obéit à quelques règles).

Vous pourrait-il vous suffit d'instancier les choses comme suit:

ArrayList list = new ArrayList();

au lieu de

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

Par la déclaration et l'utilisation de types génériques vous informer d'une structure, de la nature des objets qu'il faudra gérer et le compilateur sera en mesure de vous informer si vous êtes l'insertion d'illégal dans ce type de structure, par exemple. Disons:

//this works
List list1 = new ArrayList();
list1.add(1);
list1.add("one");

//does not work
List<String> list2 = new ArrayList<>();
list2.add(1); //compiler error here
list2.add("one");

Si vous voulez voir quelques exemples, consultez la documentation la documentation:

/**
 * Generic version of the Box class.
 * @param <T> the type of the value being boxed
 */
public class Box<T> {
    //T stands for "Type"
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

Ensuite, vous pouvez instancier des choses comme:

class Paper  { ... }
class Tissue { ... }

//...
Box<Paper> boxOfPaper = new Box<>();
boxOfPaper.set(new Paper(...));

Box<Tissue> boxOfTissues = new Box<>();
boxOfTissues.set(new Tissue(...));

La principale chose à tirer de ceci est que vous êtes en précisant le type d'objet que vous souhaitez boîte.

Comme pour l'utilisation de Object l = new ArrayList<>();, vous n'êtes pas accès à la List ou ArrayList mise en œuvre de sorte que vous ne serez pas en mesure de faire beaucoup avec la collection.

Il ya quelques situations où vous pourriez préférer la première à (légèrement) améliorer les performances, par exemple sur certaines machines virtuelles sans un compilateur JIT.

De ce genre de contexte très spécifique, vous devez utiliser la première.

Liste est l'interface et l'ArrayList est mis en œuvre concrète de la classe.
Il est toujours recommandé d'utiliser.

List<String> arrayList = new ArrayList<String>();

Car ici la liste de référence est flexible. Il peut également tenir LinkedList or Vector objet.