Como criar uma nova lista em Java

Criamos um Setcomo:

Set myset = new HashSet()

Como criamos um Listem Java?

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

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

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

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!

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 .

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

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 .

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 .

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

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.

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.

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.

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

Você precisa importar Liste ArrayList.

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

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

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

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

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

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

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.

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

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

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

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

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