ejemplo - java sort list by field

Cómo hacer una nueva lista en Java

Question

Creamos un Set como:

Set myset = new HashSet()

¿Cómo creamos una List en Java?

Answer 1

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 una nueva List.of(...) métodos de fábrica estáticos:

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

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, programa a la interfaz de List :

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

En lugar de:

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

Answer 2

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 ​​agregue y elimine esa lista, entonces, no antes, cambie a una Lista vinculada y vea si las cosas mejoran. Pero en general, quédate con ArrayList y todo estará bien.

Answer 3

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

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

Answer 4

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

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

Answer 5

Con Java 9, puedes hacer lo siguiente para crear una List inmutable :

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

Answer 6

Déjame resumir y añadir algo:

JDK

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

Guava

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

Answer 7

Desde Java 7, tiene inferencia de tipo 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 puedes usar la librería de Guava :

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

Answer 8

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 incorporadas de java. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

Answer 9

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, lanzará una java.lang.UnsupportedOperationException si 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<>();

• Así es como se crea una LinkedList en java. Si necesita realizar una inserción / eliminación frecuente de elementos en la lista, debe usar LinkedList lugar de ArrayList

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

Answer 10

Más opciones para hacer lo mismo con Java 8, no mejor, ni peor, solo diferentes y si desea realizar 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));

Answer 11

Primero lee this , luego lee this y this . 9 de cada 10 veces usarás una de esas dos implementaciones.

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

Answer 12

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");

Answer 13

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

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

Answer 14

Un ejemplo:

List somelist = new ArrayList();

Puede consultar el List y encontrar todas las clases de implementación conocidas de la interfaz de la List que se incluyen con la java api.

Answer 15

Usando Google Collections , puede usar los siguientes métodos en la clase Lists

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> iterable.

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, ya que el compilador lo deducirá del tipo de variable.

Answer 16

Usando 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");

Puedes evitar el boxeo automático usando 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 comendador de Eclipse Collections.

Answer 17

List es solo una interfaz tal como Set .

Al igual que HashSet es una implementación de un conjunto que tiene ciertas propiedades en lo que respecta a agregar / buscar / eliminar rendimiento, ArrayList es la implementación de una lista.

Si consulta 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 .

Answer 18

List es una interfaz como Set y tiene ArrayList y LinkedList como implementaciones de propósito general .

Podemos crear la 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 ArrayList oposición a la implementación de LinkedList :

1. LinkedList usa mucho espacio para los objetos y se desempeña mal cuando tenemos muchos elementos.
2. Cualquier operación indexada en LinkedList requiere tiempo O (n) en comparación con O (1) en ArrayList .
3. Revisa este link para más información.

La lista creada por Arrays.asList anterior no se puede modificar estructuralmente, pero sus elementos aún se pueden modificar.

Java 8

Según el doc , el método Collections.unmodifiableList devuelve una vista no modificable de la lista especificada. Podemos conseguirlo 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 el caso de que estemos en Java 10, el método Collectors.unmodifiableList devolverá una instancia de la lista realmente no modificable introducida en Java 9. Verifique esta answer para obtener más información sobre la diferencia en Collections.unmodifiableList vs Collectors.unmodifiableList en Java 10 .

Answer 19

//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());

Answer 20

List arrList = new ArrayList();

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

List<String> arrList = new ArrayList<String>();
arrList.add("one");

En caso de que utilice LinkedList.

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

Answer 21

List list = new ArrayList();

O con genéricos

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

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

Answer 22

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>();

Answer 23

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

Necesitas importar List y ArrayList .