Como fazer uma nova lista em Java

Nós criamos um Set como:

 Set myset = new HashSet() 

Como criamos uma List em Java?

 List myList = new ArrayList(); 

ou com genéricos ( Java 7 ou posterior)

 List myList = new ArrayList<>(); 

ou com genéricos (versões antigas do java)

 List myList = new ArrayList(); 

Além disso, se você deseja criar uma lista com itens (embora seja um tamanho fixo):

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

Deixe-me resumir e adicionar algo:

JDK

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

Goiaba

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

Lista imutável

 1. Collections.unmodifiableList(new ArrayList(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 imutável vazia

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

Lista de Personagens

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

Lista de inteiros

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

Primeiro leia isto , então leia isto e isto . 9 de 10 vezes você usará uma dessas duas implementações.

Na verdade, basta ler o Guia do Sun para a estrutura de Coleções .

 //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 o Java 7, você tem inferência de tipos para a criação de instâncias genéricas , portanto, não há necessidade de duplicar parâmetros genéricos no lado direito da atribuição:

 List list = new ArrayList<>(); 

Uma lista de tamanho fixo pode ser definida como:

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

Para listas imutáveis, você pode usar a biblioteca Guava :

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

List é apenas uma interface, assim como Set .

Como o HashSet é uma implementação de um conjunto que tem certas propriedades em relação a adicionar / procurar / remover o desempenho, ArrayList é a implementação nua de uma lista.

Se você der uma olhada na documentação das respectivas interfaces, você encontrará “Todas as Classes de Implementação Conhecidas” e poderá decidir qual delas é mais adequada às suas necessidades.

As chances são de que é ArrayList .

No Java 8

Para criar uma lista não vazia de tamanho fixo (operações como adicionar, remover, etc., não são suportadas):

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

Para criar uma lista mutável não vazia:

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

No Java 9

Usando um novo List.of(...) fábrica estática:

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

E siga as melhores práticas …

Não use tipos brutos

Desde o Java 5, os genéricos fazem parte da linguagem – você deve usá-los:

 List list = new ArrayList<>(); // Good, List of String List list = new ArrayList(); // Bad, don't do that! 

Programa para interfaces

Por exemplo, programe para a interface List :

 List list = new ArrayList<>(); 

Ao invés de:

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

List é uma interface como Set e tem ArrayList e LinkedList como implementações de propósito geral .

Podemos criar lista como:

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

Também podemos criar uma lista de tamanho fixo como:

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

Nós quase sempre estaríamos usando ArrayList oposição à implementação de LinkedList :

  1. LinkedList usa muito espaço para objects e executa mal quando temos muitos elementos.
  2. Qualquer operação indexada em LinkedList requer tempo O (n) comparado a O (1) em ArrayList .
  3. Confira este link para mais informações.

A lista criada por Arrays.asList acima não pode ser modificada estruturalmente, mas seus elementos ainda podem ser modificados. Se queremos uma lista verdadeira e imutável, podemos envolvê-la como:

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

Ou no caso de estarmos usando o Java 9, então:

 List list = List.of("A", "B"); 
 List list = new ArrayList(); 

Ou com genéricos

 List list = new ArrayList(); 

Você pode, naturalmente, replace string por qualquer tipo de variável, como Integer, também.

Às vezes – mas muito raramente – em vez de uma nova ArrayList, você pode querer uma nova LinkedList. Comece com ArrayList e se você tiver problemas de desempenho e evidência de que a lista é o problema, e muitos adicionando e excluindo a lista – então – não antes – mude para LinkedList e veja se as coisas melhoram. Mas no geral, fique com ArrayList e tudo ficará bem.

Um exemplo:

 List somelist = new ArrayList(); 

Você pode examinar o javadoc para List e localizar todas as classs de implementação conhecidas da interface List que estão incluídas na API java.

Usando o Google Collections , você pode usar os seguintes methods na class Lists

 import com.google.common.collect.Lists; // ... List strings = Lists.newArrayList(); List integers = Lists.newLinkedList(); 

Existem sobrecargas para boot varargs e boot de um Iterable .

A vantagem desses methods é que você não precisa especificar o parâmetro genérico explicitamente como faria com o construtor – o compilador o inferirá do tipo da variável.

 List nameOfList = new ArrayList(); 

Você precisa importar List e ArrayList .

Existem muitas maneiras de criar um conjunto e uma lista. HashSet e ArrayList são apenas dois exemplos. Também é bastante comum usar genéricos com collections nos dias de hoje. Eu sugiro que você dê uma olhada no que eles são

Esta é uma boa introdução para as collections incorporadas do java. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

Como opção, você pode usar a boot de chave dupla:

 List list = new ArrayList(){{ add("a"); add("b"); }}; 
 List arrList = new ArrayList(); 

É melhor você usar genéricos como sugerido abaixo:

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

Caso você use LinkedList.

 List lnkList = new LinkedList(); 

Mais opções para fazer a mesma coisa com o Java 8, não melhor, nem pior, apenas diferente, e se você quiser fazer algum trabalho extra com as listas, o Streams fornecerá mais alternativas (filtro, mapa, redução, etc.)

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

Com o Java 9, você pode fazer o seguinte para criar uma List imutável :

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

Usando collections do Eclipse, você pode criar uma lista como esta:

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

Se você quiser uma lista imutável:

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

Você pode evitar o auto-boxing usando listas primitivas. Aqui está como você criaria int listas:

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

Existem variantes para todos os 8 primitivos.

 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: Eu sou um committer para collections do Eclipse.

A seguir estão algumas maneiras de criar listas.

  • Isso criará uma lista com tamanho fixo, não é possível adicionar / remover elementos, ele lançará uma java.lang.UnsupportedOperationException se você tentar fazer isso.

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

  • A seguinte versão é uma lista simples onde você pode adicionar / remover qualquer número de elementos.

    List list = new ArrayList<>();

  • Isto é como criar um LinkedList em java, Se você precisar fazer inserção / exclusão frequente de elementos na lista, você deve usar LinkedList invés de ArrayList

    List linkedList = new LinkedList<>();

Tente isto:

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

Ou:

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

Se você precisar de uma lista serializável e imutável com uma única entidade, poderá usar:

 List singList = Collections.singletonList("stackoverlow");