Cómo hacer una nueva lista en Java

Creamos un Setcomo:

Set myset = new HashSet()

¿Cómo creamos un Listen Java?

List myList = new ArrayList();

o con genéricos ( Java 7 o posterior)

List<MyType> myList = new ArrayList<>();

o con genéricos (versiones antiguas de Java)

List<MyType> myList = new ArrayList<MyType>();

Además, si desea crear una lista que contenga elementos (aunque será de tamaño fijo):

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");

Déjame resumir y agregar algo:

JDK

1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")

Guayaba

1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});

Lista inmutable

1. Collections.unmodifiableList(new ArrayList<String>(Arrays.asList("A","B")));
2. ImmutableList.builder()                                      // Guava
            .add("A")
            .add("B").build();
3. ImmutableList.of("A", "B");                                  // Guava
4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     // Guava

Lista inmutable vacía

1. Collections.emptyList();
2. Collections.EMPTY_LIST;

Lista de personajes

1. Lists.charactersOf("String")                                 // Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  // Guava

Lista de enteros

Ints.asList(1,2,3);                                             // Guava

En Java 8

Para crear una lista no vacía de tamaño fijo (no se admiten operaciones como agregar, eliminar, etc.):

List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported

Para crear una lista mutable no vacía:

List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));

En Java 9

Usando nuevos List.of(...)métodos estáticos de fábrica:

List<Integer> immutableList = List.of(1, 2);

List<Integer> mutableList = new ArrayList<>(List.of(3, 4));

En Java 10

Uso de la inferencia de tipo de variable local :

var list1 = List.of(1, 2);

var list2 = new ArrayList<>(List.of(3, 4));

var list3 = new ArrayList<String>();

Y siga las mejores prácticas ...

No uses tipos crudos

Desde Java 5, los genéricos han sido parte del lenguaje; debe usarlos:

List<String> list = new ArrayList<>(); // Good, List of String

List list = new ArrayList(); // Bad, don't do that!

Programa para interfaces

Por ejemplo, programe en la Listinterfaz:

List<Double> list = new ArrayList<>();

En vez de:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!

Primero lea esto , luego lea esto y esto . 9 de cada 10 veces usará una de esas dos implementaciones.

De hecho, solo lea la Guía de Sun para el marco de Colecciones .

//simple example creating a list form a string array

String[] myStrings = new String[] {"Elem1","Elem2","Elem3","Elem4","Elem5"};

List mylist = Arrays.asList(myStrings );

//getting an iterator object to browse list items

Iterator itr= mylist.iterator();

System.out.println("Displaying List Elements,");

while(itr.hasNext())

  System.out.println(itr.next());

Desde Java 7, tiene inferencia de tipos para la creación de instancias genéricas , por lo que no es necesario duplicar parámetros genéricos en el lado derecho de la asignación:

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

Una lista de tamaño fijo se puede definir como:

List<String> list = Arrays.asList("foo", "bar");

Para listas inmutables, puede usar la biblioteca Guava :

List<String> list = ImmutableList.of("foo", "bar");

List es solo una interfaz como Set .

Al igual que HashSet es una implementación de un conjunto que tiene ciertas propiedades con respecto a agregar / buscar / eliminar el rendimiento, ArrayList es la implementación básica de una lista.

Si echa un vistazo a la documentación de las interfaces respectivas, encontrará "Todas las clases de implementación conocidas" y podrá decidir cuál es la más adecuada para sus necesidades.

Lo más probable es que sea ArrayList .

Listes una interfaz como Sety tiene ArrayListy LinkedListcomo implementaciones de propósito general .

Podemos crear Lista como:

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

También podemos crear una lista de tamaño fijo como:

List<String> list = Arrays.asList("A", "B", "C");

Casi siempre estaríamos usando ArrayListopuestos a la LinkedListimplementación:

1. LinkedList usa mucho espacio para objetos y funciona mal cuando tenemos muchos elementos.
2. Cualquier operación indexada en LinkedListrequiere tiempo O (n) en comparación con O (1) en ArrayList.
3. Consulte este enlace para más información.

La lista creada Arrays.asListanteriormente no puede modificarse estructuralmente, pero sus elementos aún pueden modificarse.

Java 8

Según el documento , el método Collections.unmodifiableListdevuelve una vista no modificable de la lista especificada. Podemos obtenerlo como:

Collections.unmodifiableList(Arrays.asList("A", "B", "C"));

Java 9

En caso de que estemos usando Java 9, entonces:

List<String> list = List.of("A", "B");

Java 10

En caso de que estemos en Java 10, el método Collectors.unmodifiableListdevolverá una instancia de lista verdaderamente inmodificable introducida en Java 9. Verifique esta respuesta para obtener más información sobre la diferencia entre Collections.unmodifiableList vs Collectors.unmodifiableListen Java 10 .

A veces, pero muy raramente, en lugar de una nueva ArrayList, es posible que desee una nueva LinkedList. Comience con ArrayList y si tiene problemas de rendimiento y evidencia de que la lista es el problema, y ​​si agrega y elimina mucho a esa lista, luego, no antes, cambie a LinkedList y vea si las cosas mejoran. Pero en general, quédate con ArrayList y todo estará bien.

List list = new ArrayList();

O con genéricos

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

Por supuesto, puede reemplazar la cadena con cualquier tipo de variable, como Integer, también.

Un ejemplo:

List somelist = new ArrayList();

Puede consultar la lista de javadoc y encontrar todas las clases de implementación conocidas de la Listinterfaz que se incluyen con la API de Java.

Con Google Collections , puede usar los siguientes métodos en la clase Listas

import com.google.common.collect.Lists;

// ...

List<String> strings = Lists.newArrayList();

List<Integer> integers = Lists.newLinkedList();

Hay sobrecargas para la inicialización de varargs y la inicialización de un Iterable<T>.

La ventaja de estos métodos es que no necesita especificar el parámetro genérico explícitamente como lo haría con el constructor; el compilador lo inferirá del tipo de la variable.

List<Object> nameOfList = new ArrayList<Object>();

Necesitas importar Listy ArrayList.

Más opciones para hacer lo mismo con Java 8, no mejor, no peor, solo diferente y si desea hacer un trabajo adicional con las listas, Streams le proporcionará más alternativas (filtro, mapa, reducción, etc.)

List<String> listA = Stream.of("a", "B", "C").collect(Collectors.toList());
List<Integer> listB = IntStream.range(10, 20).boxed().collect(Collectors.toList());
List<Double> listC = DoubleStream.generate(() -> { return new Random().nextDouble(); }).limit(10).boxed().collect(Collectors.toList());
LinkedList<Integer> listD = Stream.iterate(0, x -> x++).limit(10).collect(Collectors.toCollection(LinkedList::new));

Con Java 9, puede hacer lo siguiente para crear un elemento inmutable List :

List<Integer> immutableList = List.of(1, 2, 3, 4, 5);

List<Integer> mutableList = new ArrayList<>(immutableList);

Como opción, puede usar la inicialización de doble llave aquí:

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};

Hay muchas formas de crear un Conjunto y una Lista. HashSet y ArrayList son solo dos ejemplos. También es bastante común usar genéricos con colecciones en estos días. Te sugiero que eches un vistazo a lo que son

Esta es una buena introducción para las colecciones integradas de Java. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

List arrList = new ArrayList();

Es mejor que use genéricos como se sugiere a continuación:

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

arrList.add("one");

En caso de que use LinkedList.

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

Con Eclipse Collections puedes crear una lista como esta:

List<String> list1 = Lists.mutable.empty();
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

Si quieres una lista inmutable:

ImmutableList<String> list3 = Lists.immutable.empty();
ImmutableList<String> list4 = Lists.immutable.of("One", "Two", "Three");

Puede evitar el auto-boxeo utilizando listas primitivas. Así es como crearías listas int:

MutableIntList list5 = IntLists.mutable.empty();
MutableIntList list6 = IntLists.mutable.of(1, 2, 3);

ImmutableIntList list7 = IntLists.immutable.empty();
ImmutableIntList list8 = IntLists.immutable.of(1, 2, 3);

Hay variantes para las 8 primitivas.

MutableLongList longList       = LongLists.mutable.of(1L, 2L, 3L);
MutableCharList charList       = CharLists.mutable.of('a', 'b', 'c');
MutableShortList shortList     = ShortLists.mutable.of((short) 1, (short) 2, (short) 3);
MutableByteList byteList       = ByteLists.mutable.of((byte) 1, (byte) 2, (byte) 3);
MutableBooleanList booleanList = BooleanLists.mutable.of(true, false);
MutableFloatList floatList     = FloatLists.mutable.of(1.0f, 2.0f, 3.0f);
MutableDoubleList doubleList   = DoubleLists.mutable.of(1.0, 2.0, 3.0);

Nota: Soy un committer para Eclipse Collections.

Las siguientes son algunas formas en que puede crear listas.

• Esto creará una lista con un tamaño fijo, no es posible agregar / eliminar elementos, arrojará un java.lang.UnsupportedOperationExceptionsi intenta hacerlo.

  List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});

• La siguiente versión es una lista simple donde puede agregar / eliminar cualquier número de elementos.

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

• Esta es la forma de crear un LinkedListarchivo in java. Si necesita hacer una inserción / eliminación frecuente de elementos en la lista, debe usar en LinkedListlugar deArrayList

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

Prueba esto:

List<String> messages = Arrays.asList("bla1", "bla2", "bla3");

O:

List<String> list1 = Lists.mutable.empty(); // Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

Si necesita una lista inmutable serializable con una sola entidad que puede usar:

List<String> singList = Collections.singletonList("stackoverlow");

Como la declaración de la lista de matriz en java es como

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable  

Hay muchas formas de crear e inicializar la lista de matrices en Java.

 1) List list = new ArrayList();

 2) List<type> myList = new ArrayList<>();

 3) List<type> myList = new ArrayList<type>();

 4) Using Utility class

    List<Integer> list = Arrays.asList(8, 4);
    Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

 5) Using static factory method

    List<Integer> immutableList = List.of(1, 2);


 6) Creation and initializing at a time

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});



 Again you can create different types of list. All has their own characteristics

 List a = new ArrayList();
 List b = new LinkedList();
 List c = new Vector(); 
 List d = new Stack(); 
 List e = new CopyOnWriteArrayList();