java - tutorial - para que se usa elastic search

Diferencia entre un comodín sin unir y un tipo sin procesar

Question

Estaba leyendo sobre genéricos y no entendía la necesidad de comodines sin unir y en qué se diferencian de los tipos sin procesar. Leí esta pregunta pero todavía no lo entendí claramente. En la página del tutorial de Java para comodines no enlazados obtuve dos puntos por debajo y no entendí el primer punto:

• Si está escribiendo un método que puede implementarse utilizando la funcionalidad proporcionada en la clase de Object .
• Cuando el código utiliza métodos en la clase genérica que no dependen del parámetro de tipo. Por ejemplo, List.size() o List.clear() . De hecho, la Class<?> Se usa con frecuencia porque la mayoría de los métodos de la Class<T> no dependen de T

¿Alguien puede explicar la diferencia entre un comodín no unido y un tipo sin formato en lenguaje lego?

¿En List<?> diferencia la List<?> De la List<Object> ?

Answer 1

¿Alguien puede explicar la diferencia entre un comodín no unido y un tipo sin formato en lenguaje lego?

El tipo de comodín sin unir puede mantener el tipo de colección invariante , y el tipo sin procesar no puede. Como dice Joshua Bloch en su Java efectiva ,

Puede colocar cualquier elemento en una colección con un tipo en bruto, corrompiendo fácilmente el tipo invariante de la colección (como lo demuestra el método unsafeAdd en la página 112); no puede poner ningún elemento (que no sea nulo) en una Colección <?>.

Por lo tanto, siempre que asigne una lista de tipo parametrizado a una lista de tipo comodín no enlazado, se mantendrá el tipo invariante de la colección .

List<String> list1 = new ArrayList();
list1.add("foo");
list1.add("bar");
List<?> list2 = list1;

Si asigna una lista de tipo sin procesar cuyos elementos son de diferentes tipos, el tipo de comodín no unido no mantendrá el tipo de colección invariante , ya que la lista es originalmente de tipo variante.

List list1 = new ArrayList();
list1.add(1);
list1.add("foo");
List<?> list2 = list1;

Answer 2

¿En List<?> diferencia la List<?> De la List<Object>

La principal diferencia es que la primera línea se compila, pero la segunda no:

List<?> list = new ArrayList<String> ();
List<Object> list = new ArrayList<String> ();

Sin embargo, debido a que no sabe cuál es el tipo genérico de List<?> , No puede usar sus métodos parametrizados:

List<?> list = new ArrayList<String> ();
list.add("aString"); //does not compile - we don''t know it is a List<String>
list.clear(); //this is fine, does not depend on the generic parameter type

En cuanto a la diferencia con los tipos sin formato (no genéricos), el siguiente código compila y funciona bien:

List list = new ArrayList<String> ();
list.add("aString");
list.add(10);

Answer 3

¿En List<?> diferencia la List<?> De la List<Object> ?

    List<Object> l1 = new ArrayList();
    List<?> l2 = new ArrayList();
    l1.add("Object");
    //l2.add("Object");   incorrect
    l2.add(null);

Solo puede agregar un valor nulo a la List<?>

Answer 4

La lista es útil en una firma de método para llamar a métodos que nunca requieren el parámetro de tipo, es decir, leer de la lista o rotarlo, por ejemplo.

void someMethod(List<?> list) {
  list.clear();  // I will never add anything to the list in here
}

Nunca agregará nada ni modificará la lista con respecto al tipo que contiene, ya que no puede agregar nada a la lista, excepto el método nulo con esta firma, por lo que nunca romperá la seguridad de tipos. Por otro lado, la Lista de materias primas puede hacer cualquier cosa, lo cual, como todos sabemos, puede resultar en una violación de seguridad de tipo.

void someMethod2(List list) {
 list.add(new WeaselFurBrush());  
}
List list1 = new ArrayList<String>();
someMethod2(list1);// oops

Answer 5

Personalmente, encontré útil este enlace adicional del tutorial de Java sobre comodines .

Una de las principales diferencias que veo entre la List<?> Y la List es que la primera solo puede ser útil para leer sus elementos (a menos que realmente quiera agregar un null ), la última permite (no verificada) agregar objetos tipificados arbitrariamente a con posibles efectos secundarios inesperados.