español - ArrayList o declaración de lista en Java

lista de enteros en java

Question

¿Cuál es la diferencia entre estas dos declaraciones?

Declaración 1:

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

Declaración 2:

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

Answer 1

Básicamente le permite a Java almacenar varios tipos de objetos en una implementación de estructura, por declaración de tipo genérico (como class MyStructure<T extends TT> ), que es una de las características principales de Javas.

Los enfoques orientados a objetos se basan en modularidad y reutilización por separación de preocupaciones: la capacidad de utilizar una estructura con cualquier tipo de objeto (siempre que obedezca unas pocas reglas).

Podrías simplemente crear una instancia de las cosas como sigue:

ArrayList list = new ArrayList();

en lugar de

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

Al declarar y usar tipos genéricos, está informando una estructura del tipo de objetos que administrará y el compilador podrá informarle si está insertando un tipo ilegal en esa estructura, por ejemplo. Digamos:

// 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 desea ver algunos ejemplos, consulte la documentación de 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; }
}

Entonces podrías instanciar cosas como:

class Paper { ... }
class Tissue { ... }
// ...
Box<Paper> boxOfPaper = new Box<>();
boxOfPaper.set(new Paper(...));
Box<Tissue> boxOfTissues = new Box<>();
boxOfTissues.set(new Tissue(...));

Lo principal a extraer de esto es que estás especificando qué tipo de objeto deseas encasillar.

En cuanto a usar el Object l = new ArrayList<>(); , no está accediendo a la implementación de List o ArrayList , por lo que no podrá hacer mucho con la colección.

Answer 2

Es fácil cambiar la implementación a List to Set :

Collection<String> stringList = new ArrayList<String>();
//Client side
stringList = new LinkedList<String>();
stringList = new HashSet<String>();
//stringList = new HashSet<>(); java 1.7 and 1.8

Answer 3

Hay algunas situaciones en las que puede preferir que el primero mejore (ligeramente) el rendimiento, por ejemplo, en algunas JVM sin un compilador JIT .

Fuera de ese tipo de contexto muy específico, debes usar el primero.

Answer 4

La diferencia es que la variante 1 obliga a usar una ArrayList mientras que la variante 2 solo garantiza que tiene algo que implemente List<String> .

Más tarde, podría cambiar eso a List<String> arrayList = new LinkedList<String>(); sin mucha molestia. La Variante 1 podría requerir que cambie no solo esa línea, sino también otras partes si confían en trabajar con una ArrayList<String> .

Por lo tanto, utilizaría List<String> en casi cualquier caso, excepto cuando necesite llamar a los métodos adicionales que proporciona ArrayList (que nunca fue el caso hasta ahora): ensureCapacity(int) y trimToSize() .

Answer 5

La primera declaración tiene que ser una ArrayList, la segunda se puede cambiar fácilmente a otro tipo de lista. Como tal, se prefiere el segundo ya que deja en claro que no requiere una implementación específica. (A veces realmente necesitas una implementación, pero eso es raro)

Answer 6

List es la interfaz y ArrayList se implementa en la clase concreta. Siempre se recomienda usar.

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

Porque aquí la lista de referencia es flexible. También puede contener LinkedList or Vector objeto LinkedList or Vector .

Answer 7

Posiblemente pueda consultar este enlace http://docs.oracle.com/javase/6/docs/api/java/util/List.html

List es una interfaz.ArrayList, LinkedList, etc. son clases que implementan list.Whenyou using List Interface, tiene que itearte elementos usando ListIterator y puede moverse hacia adelante y hacia atrás, en la Lista donde como en ArrayList Iterar usando Iterator y sus elementos pueden ser se accede de forma unidireccional.

Answer 8

Siempre que haya visto codificación de una comunidad de código abierto como Guava y de Google Developer (Android Library) utilizaron este enfoque

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

porque es ocultar los detalles de implementación del usuario. Usted precisamente

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

es enfoque genérico y este enfoque especializado

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

Para referencia: Effective Java 2nd Edition: Elemento 52: consulte los objetos por sus interfaces

Answer 9

List es una interfaz y ArrayList es una implementación de la interfaz List. La clase ArrayList tiene solo unos pocos métodos (ie clone(), trimToSize(), removeRange() and ensureCapacity()) además de los métodos disponibles en la interfaz de la Lista. No hay mucha diferencia en esto.

 1. List<String> l = new ArrayList<>();
2. ArrayList<String> l = new ArrayList<>();

Si usa el primero, podrá llamar a los métodos disponibles en la interfaz de Lista y no podrá hacer llamadas a los nuevos métodos disponibles en la clase ArrayList . Mientras que, puede usar todos los métodos disponibles en ArrayList si usa el segundo.

Yo diría que el primer enfoque es mejor porque, cuando estás desarrollando aplicaciones Java, cuando se supone que debes pasar los objetos del framework de recolección como argumentos a los métodos, entonces es mejor ir con el primer enfoque.

List<String> l = new ArrayList<>();
doSomething(l);

En el futuro, debido a restricciones de rendimiento, si está cambiando la implementación para usar LinkedList u otras clases que implementan la interfaz de List , en lugar de ArrayList , debe cambiar solo en un punto (la parte de creación de instancias).

List<String> l = new LinkedList<>();

De lo contrario, se supondrá que debes cambiar en todos los lugares, donde sea, has utilizado la implementación de clase específica como argumentos de método.

Answer 10

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

Es genérico en el que desea ocultar detalles de implementación mientras lo devuelve al cliente, en un momento posterior puede cambiar la implementación de ArrayList a LinkedList transparente.

Este mecanismo es útil en casos en los que diseñe bibliotecas, etc., que pueden cambiar los detalles de implementación en algún momento con cambios mínimos en el lado del cliente.

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

Esto exige que siempre tenga que devolver ArrayList . En algún momento, si desea cambiar los detalles de implementación a LinkedList , también debe haber cambios en el lado del cliente para usar LinkedList lugar de ArrayList .