La différence entre la Liste, List<?>, List<T>, une Liste<E>, et une Liste<Object>

1) Corriger

2) Vous pouvez penser que l'on en "lecture seule" de la liste, où vous n'avez pas de soins sur le type des éléments.Pourraient par exemple être utilisés par une méthode qui retourne la longueur de la liste.

3) T, E et U sont les mêmes, mais les gens ont tendance à utiliser, par exemple, T pour type, E pour l'Élément, V pour la valeur et K de clé. La méthode qui compile dit qu'il a fallu un tableau d'un certain type, et retourne un tableau du même type.

4) Vous ne pouvez pas mélanger les oranges et les pommes. Vous serez en mesure d'ajouter un Objet à votre liste de chaînes, si vous pouvez passer une liste de chaînes à une méthode qui attend des listes d'objets. (Et pas tous les objets sont des chaînes de caractères)

La notation List<?> signifie "une liste de quelque chose (mais je ne dis pas que)". Depuis le code dans test fonctionne pour n'importe quel type d'objet dans la liste, cela fonctionne comme une méthode formelle paramètre.

À l'aide d'un paramètre de type (comme dans votre point 3), il faut que le paramètre du type d'être déclarée. La syntaxe Java pour qui est de mettre <T> devant de la fonction. C'est exactement analogue à la déclaration officielle des noms de paramètre à une méthode avant d'utiliser les noms dans le corps de la méthode.

Concernant List<Object> ne pas accepter une List<String>, qui fait sens, car un String n'est pas Object; c'est une sous-classe de Object. La solution est de déclarer public static void test(List<? extends Object> set) .... Mais alors le extends Object est redondante, car chaque classe, directement ou indirectement, s'étend Object.

Je vous conseille la lecture de Java casse-têtes. Il explique l'héritage, les génériques, les abstractions et des caractères génériques dans les déclarations assez bien.
http://www.javapuzzlers.com/

Laissez-nous parler d'eux dans le contexte de Java de l'histoire ;

1. List:

Liste signifie qu'il peut inclure n'importe quel Objet. La liste a été la libération avant de Java 5.0; Java 5.0 a introduit Liste, pour des raisons de compatibilité descendante.

List list=new  ArrayList();
list.add(anyObject);

1. List<?>:

? signifie Objet inconnu pas de tout Objet; le générique ? introduction pour résoudre le problème construite par Type Générique; voir les caractères génériques;
mais cela entraîne également un autre problème:

Collection<?> c = new ArrayList<String>();
c.add(new Object()); //Compile time error

1. List< T> List< E>

Signifie générique Déclaration à la prémisse de aucun T ou E type de votre projet, Lib.

1. List< Object> moyen générique de paramétrage.

Théorie

String[] peut être coulé à Object[]

mais

List<String> ne peut pas être lancé à List<Object>.

Pratique

Pour les listes, il est plus subtil que ça, car à moment de la compilation le type d'une Liste de paramètres passés à une méthode n'est pas cochée. La définition de la méthode pourrait tout aussi bien dire List<?> - du compilateur, du point de vue, c'est équivalent. C'est pourquoi l'OP de l'exemple n ° 2 donne des erreurs d'exécution, pas d'erreurs de compilation.

Si vous manipulez un List<Object> paramètre passé à une méthode avec soin afin de ne pas forcer une vérification du type sur n'importe quel élément de la liste, vous pouvez avoir votre méthode définie à l'aide de List<Object> mais en fait accepter un List<String> paramètre dans le code appelant.

A. Si ce code ne sera pas donner de la compilation ou de l'exécution des erreurs et sera effectivement (et peut-être étonnamment?) travail:

public static void test(List<Object> set) {
    List<Object> params = new List<>();  //This is a List<Object>
    params.addAll(set);       //A String can be added to List<Object>
    params.add(new Long(2));  //A Long can be added to List<Object>
    System.out.println(params);
}

public static void main(String[] args) {
    List<String> argsList = Arrays.asList(args);
    test(argsList);  //The object passed is a List<String>
}

B. Ce code vous donnera une erreur d'exécution:

public static void test(List<Object> set) {
    List<Object> params = set;  //Surprise!  Runtime error
    set.add(new Long(2));       //Also a runtime error
    System.out.println(set);
}

public static void main(String[] args) {
    List<String> argsList = Arrays.asList(args);
    test(argsList);
}

C. Ce code vous donnera une erreur d'exécution (java.lang.ArrayStoreException: java.util.Collections$UnmodifiableRandomAccessList Object[]):

public static void test(Object[] set) {
    Object[] params = set;    //This is OK even at runtime
    params[0] = new Long(2);  //Surprise!  Runtime error
    System.out.println(params);
}

public static void main(String[] args) {
    test(args);
}

En B, le paramètre set n'est pas typé List au moment de la compilation: le compilateur ne voit en elle qu' List<?>. Il y a une erreur d'exécution, car au moment de l'exécution, set devient l'objet même passé de main(), et c'est un List<String>. Un List<String> ne peut pas être lancé à List<Object>.

En C, le paramètre set implique un Object[]. Il n'y a pas d'erreur de compilation, et aucune erreur d'exécution lorsqu'elle est appelée avec un String[] objet en tant que paramètre. C'est parce que String[] jette à Object[]. Mais l'objet réel reçu par test() reste un String[], il n'a pas changé. Ainsi, le params objet devient aussi un String[]. Et l'élément 0 de un String[] ne peut pas être attribué à un Long!

(J'espère que j'ai tout ici, si mon raisonnement est faux, je suis sûr que la communauté va me dire.)