Como criar uma nova lista em Java

762

Criamos um Setcomo:

Set myset = new HashSet()

Como criamos um Listem Java?

user93796
fonte
1
No javadoc para List. "Todas as classes de implementação conhecidas: AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector"
KitsuneYMG
121
Esta questão é um dos hits top Google por "java criar uma lista" e tem um conjunto muito útil de respostas, então parece ser uma pergunta bastante razoável para mim :-)
Josephh
52
É uma boa pergunta com boas respostas. Um dos objetivos do Stack Overflow é criar algum tipo de resposta canônica para perguntas de programação, pelo menos de acordo com os fundadores do site. Portanto, tente evitar o voto negativo nesse tipo de post no futuro, se você puder resistir à tentação.
eggonlegs

Respostas:

977
List myList = new ArrayList();

ou com genéricos ( Java 7 ou posterior)

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

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

List<MyType> myList = new ArrayList<MyType>();
Dan Vinton
fonte
68
Observe que ArrayList não é o único tipo de lista - e, com relação à pergunta, HashSet não é o único tipo de conjunto.
magro
17
Estou surpreso que ninguém tenha mencionado que você pode consultar a interface da lista na documentação Java para obter uma lista definitiva de todas as classes que implementam a Lista: docs.oracle.com/javase/7/docs/api/java/util /List.html
David Mason
5
Se você usa um IDE, geralmente também pode visualizar uma hierarquia de tipos, o que pode ser mais conveniente. No Eclipse, o atalho padrão é F4 e, no IDEA, é Ctrl + H.
David Mason
1
Pelo que eu entendo que você não pode usar os genéricos com ArrayList em C # MSDN
JohnOsborne
5
O segundo argumento de tipo explícito <MyType> pode ser substituído por apenas <> para Java 7 e 8. #
301 Jannik
469

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

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");
Aaron Maenpaa
fonte
15
A ressalva é que esse tipo de lista (a retornada por asList ()) é imutável.
Avrom
70
@Avron - errado: ele só é tamanho fixo: você não pode alterar o tamanho, mas você pode alterar o conteúdo (ressalva da ressalva?)
user85421
Impressionante. Obrigado por ser conciso.
R Claven
1
se houver apenas uma coisa na lista, eu uso Collections.singletonList () em vez de Arrays.asList (). (Mas, eu acho, eu não sei por que.)
MikeB
@ MikeB se você não sabe por que, em seguida, manter o arrays.aslist
bharal 30/01
183

Deixe-me resumir e adicionar algo:

JDK

1. new ArrayList<String>();
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<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 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
Sergii Shevchyk
fonte
Ints.asListnão cria uma lista imutável, mas uma lista de tamanho fixo, apoiada por um determinado conjunto de entradas (isto é, suporta List.set(int, Object)). O segundo exemplo de "Lista imutável de caracteres" também não é imutável (eu removeria essa linha).
Xaerxess
9
Não usar genéricos é um exemplo realmente "bom" para qualquer desenvolvedor que leia isso.
Natix 16/04
60

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<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported

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

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

No Java 9

Usando um novo List.of(...)método estático de fábrica:

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

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

No Java 10

Usando a inferência de tipo de variável local :

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

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

var list3 = new ArrayList<String>();

E siga as práticas recomendadas ...

Não use tipos brutos

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

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

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

Programa para interfaces

Por exemplo, programe para a Listinterface:

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

Ao invés de:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!
Oleksandr Pyrohov
fonte
1
Oi, você poderia sugerir onde eu posso aprender essas diferenças e a evolução do Java? Parece muito interessante!
shiv
31

Primeiro leia isto , depois leia isto e aquilo . 9 em cada 10 vezes, você usará uma dessas duas implementações.

De fato, basta ler o Guia do Sun para a estrutura de coleções .

Adam Jaskiewicz
fonte
11
Eu até mesmo adicionar "8 vezes fora de 10" você vai usar ArrayList, só porque ele simplesmente não importa em 9,9 vezes de 10.
Joachim Sauer
1
O LinkedList é semanticamente apropriado quando você realmente se importa com os fins.
23611 Adam Jaskiewicz
As LinkedLists são excelentes se você apenas iterar sobre elas. Para mim, parece que as listas vinculadas são mais elegantes, mas talvez seja apenas porque eu aprendi o lisp antes do Java.
194 KarlP
@Karlp concordou. Eu diria que são 50/50 na maioria das vezes entre ArrayList e LinkedList, e a resposta nem sempre é sobre a complexidade das operações; mais frequentemente, é simplesmente o que parece certo para o problema em questão.
Adam Jaskiewicz
1
Eu quase sempre usei ArrayList. Se eu estiver trabalhando apenas com os fins de uma lista, é um deque (ou fila) e eu uso a ArrayDequeimplementação. O motivo é que, embora as implementações baseadas em matriz possam desperdiçar alguma memória em slots vazios (quando não posso prever a capacidade necessária), para pequenas coleções, isso é comparável à sobrecarga de todas as instâncias de nó em uma lista vinculada ( ou deque). E, em troca, recebo acesso aleatório. Que benefício exclusivo LinkedListoferece?
22613 Erickson
21
//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());
Blerta
fonte
21

Desde o Java 7, você tem inferência de tipo para criação de instância genérica , portanto, não há necessidade de duplicar parâmetros genéricos no lado direito da atribuição:

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

Uma lista de tamanho fixo pode ser definida como:

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

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

List<String> list = ImmutableList.of("foo", "bar");
Vitalii Fedorenko
fonte
Eu tenho uma pergunta sobre esta declaração List <> lista = Arrays.asList ("foo", "bar"); Gostaria de saber se a lista na declaração é um objeto?
20

A lista é apenas uma interface, assim como definido .

Como o HashSet é uma implementação de um conjunto que possui determinadas propriedades em relação à adição / pesquisa / remoção de desempenho, ArrayList é a implementação simples de uma lista.

Se você olhar a documentação para as respectivas interfaces, encontrará "Todas as classes de implementação conhecidas" e poderá decidir qual é a mais adequada para suas necessidades.

As chances são de que seja ArrayList .

Sorin Mocanu
fonte
18

Listé uma interface como Sete tem ArrayListe LinkedListcomo implementações de uso geral .

Podemos criar a lista como:

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

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

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

Quase sempre estaríamos usando ArrayListoposição à LinkedListimplementação:

  1. LinkedList usa muito espaço para objetos e apresenta um desempenho ruim quando temos muitos elementos.
  2. Qualquer operação indexada em LinkedListrequer tempo O (n) comparado a O (1) em ArrayList.
  3. Verifique este link para mais informações.

A lista criada Arrays.asListacima não pode ser modificada estruturalmente, mas seus elementos ainda podem ser modificados.

Java 8

Conforme o documento , o método Collections.unmodifiableListretorna uma visão inalterável da lista especificada. Podemos obtê-lo como:

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

Java 9

Caso esteja usando o Java 9, então:

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

Java 10

Caso estejamos no Java 10, o método Collectors.unmodifiableListretornará uma instância da lista realmente não modificável introduzida no Java 9. Verifique esta resposta para obter mais informações sobre a diferença entre Collections.unmodifiableList vs Collectors.unmodifiableListno Java 10 .

akhil_mittal
fonte
9

Às vezes - mas apenas 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ências de que a lista é o problema, e adicionar e excluir muita lista - e não antes - mude para uma LinkedList e veja se as coisas melhoram. Mas, em geral, fique com o ArrayList e tudo ficará bem.

Carl Manaster
fonte
9
List list = new ArrayList();

Ou com genéricos

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

Obviamente, você pode substituir string por qualquer tipo de variável, como Inteiro, também.

Paulo Guedes
fonte
7

Um exemplo:

List somelist = new ArrayList();

Você pode olhar para o javadoc para List e encontrar todas as classes de implementação conhecidas da Listinterface que estão incluídas na API Java.

Alex B
fonte
7

Usando o Google Collections , você pode usar os seguintes métodos na classe Lists

import com.google.common.collect.Lists;

// ...

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

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

Existem sobrecargas para a inicialização de varargs e a inicialização de um Iterable<T>.

A vantagem desses métodos é que você não precisa especificar explicitamente o parâmetro genérico, como faria com o construtor - o compilador o inferirá do tipo de variável.

Ben Lings
fonte
6
List<Object> nameOfList = new ArrayList<Object>();

Você precisa importar Liste ArrayList.

jp093121
fonte
6

Mais opções para fazer a mesma coisa com o Java 8, nem melhor nem pior, apenas diferente e, se você quiser fazer um trabalho extra com as listas, o Streams fornecerá mais alternativas (filtrar, mapear, reduzir 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));
whyem
fonte
6

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

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

List<Integer> mutableList = new ArrayList<>(immutableList);
Jacob G.
fonte
6

Como opção, você pode usar a inicialização entre chaves aqui:

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};
angry_gopher
fonte
2
Esta é uma operação cara. Você está criando uma subclasse anônima de ArrayList aqui.
Vikram Bodicherla
@VikramBodicherla Concordo. É mais sobre açúcar de sintaxe aqui.
angry_gopher
5

Existem várias maneiras de criar um conjunto e uma lista. HashSet e ArrayList são apenas dois exemplos. Também é bastante comum o uso de genéricos com coleções atualmente. Eu sugiro que você dê uma olhada no que eles são

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

Peter Lawrey
fonte
5
List arrList = new ArrayList();

É melhor usar genéricos, conforme sugerido abaixo:

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

arrList.add("one");

Caso você use o LinkedList.

List<String> lnkList = new LinkedList<String>();
Rohit Goyal
fonte
4

Usando o Eclipse Collections, você pode criar uma Lista como esta:

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

Se você deseja uma lista imutável:

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

Você pode evitar o encaixotamento automático usando listas primitivas. Veja como você criaria 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);

Existem variantes para todas as 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: Sou um colaborador das Coleções Eclipse.

Craig P. Motlin
fonte
4

A seguir, algumas maneiras de criar listas.

  • Isso criará uma lista com tamanho fixo, não é possível adicionar / remover elementos, ele exibirá um java.lang.UnsupportedOperationExceptionse você tentar fazer isso.

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


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

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


  • Isto é como criar um LinkedListem java. Se você precisar inserir / excluir com freqüência elementos na lista, use em LinkedListvez deArrayList

    List<String> linkedList = new LinkedList<>();
JoBⅈN
fonte
1
Você pode usar Arrays.asList("Male", "Female").
19419 Johny
3

Tente o seguinte:

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

Ou:

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

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

List<String> singList = Collections.singletonList("stackoverlow");
erol yeniaras
fonte
2

Como a declaração da lista de matrizes em java é como

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

Há várias maneiras de criar e inicializar a lista de matrizes em 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();
Mak
fonte