Eu queria criar uma lista de opções para fins de teste. No começo, eu fiz isso:

ArrayList<String> places = new ArrayList<String>();
places.add("Buenos Aires");
places.add("Córdoba");
places.add("La Plata");

Em seguida, refatorei o código da seguinte maneira:

ArrayList<String> places = new ArrayList<String>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Existe uma maneira melhor de fazer isso?

Na verdade, provavelmente a melhor "maneira" de inicializar ArrayListé o método que você escreveu, pois não precisa criar um novo de Listforma alguma:

ArrayList<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");

O problema é que há bastante digitação necessária para se referir a essa listinstância.

Existem alternativas, como criar uma classe interna anônima com um inicializador de instância (também conhecido como "inicialização entre chaves"):

ArrayList<String> list = new ArrayList<String>() {{
    add("A");
    add("B");
    add("C");
}};

No entanto, não gosto muito desse método, porque o que você acaba ArrayListcriando é uma subclasse com um inicializador de instância e essa classe é criada apenas para criar um objeto - isso me parece um pouco exagerado.

O que seria bom seria se a proposta da Collection Literals para o Project Coin fosse aceita (ela deveria ser introduzida no Java 7, mas também não é provável que faça parte do Java 8).

List<String> list = ["A", "B", "C"];

Infelizmente, não o ajudará aqui, pois inicializará um imutável em Listvez de um ArrayListe, além disso, ainda não está disponível, se for o caso.

Seria mais simples se você o declarasse apenas como List- precisa ser um ArrayList?

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Ou se você tiver apenas um elemento:

List<String> places = Collections.singletonList("Buenos Aires");

Isso significa que placesé imutável (tentar alterá-lo fará com que uma UnsupportedOperationExceptionexceção seja lançada).

Para criar uma lista mutável que seja concreta, ArrayListvocê pode criar uma a ArrayListpartir da lista imutável:

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

A resposta simples

No Java 9 ou posterior, depois List.of()foi adicionado:

List<String> strings = List.of("foo", "bar", "baz");

Com o Java 10 ou posterior, isso pode ser reduzido com a varpalavra - chave.

var strings = List.of("foo", "bar", "baz");

Isso lhe dará um imutável List , por isso não pode ser alterado.
Qual é o que você deseja na maioria dos casos em que está pré-preenchendo-o.

Java 8 ou anterior:

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

Isso lhe dará um Listrespaldo por uma matriz, portanto, não pode alterar o comprimento.
Mas você pode ligar List.set, por isso ainda é mutável .

Você pode Arrays.asListdiminuir ainda mais com uma importação estática:

List<String> strings = asList("foo", "bar", "baz");

A importação estática:

import static java.util.Arrays.asList;  

O que qualquer IDE moderno sugerirá e fará automaticamente por você.
Por exemplo, no IntelliJ IDEA, você pressiona Alt+Entere seleciona Static import method....

No entanto, eu não recomendo encurtar o List.ofmétodo para of, porque isso se torna confuso.
List.ofjá é curto o suficiente e lê bem.

Usando Streams

Por que tem que ser um List?
Com o Java 8 ou posterior, você pode usar um Streamque seja mais flexível:

Stream<String> strings = Stream.of("foo", "bar", "baz");

Você pode concatenar Streams:

Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
                                       Stream.of("baz", "qux"));

Ou você pode ir de a Streampara List:

import static java.util.stream.Collectors.toList;

List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());

Mas de preferência, basta usar o Streamsem coletá-lo para a List.

Se você realmente precisa especificamente de umjava.util.ArrayList

(Você provavelmente não.)
Para citar JEP 269 (ênfase minha):

Há um pequeno conjunto de casos de uso para inicializar uma instância de coleção mutável com um conjunto predefinido de valores. Geralmente, é preferível ter esses valores predefinidos em uma coleção imutável e, em seguida, inicializar a coleção mutável por meio de um construtor de cópia.

Se você quer tanto um pré-popular ArrayList e adicionar a ele posteriormente (por quê?), Uso

ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");

ou no Java 8 ou anterior:

ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");

ou usando Stream:

import static java.util.stream.Collectors.toCollection;

ArrayList<String> strings = Stream.of("foo", "bar")
                             .collect(toCollection(ArrayList::new));
strings.add("baz");

Mas, novamente, é melhor usar o Streamdiretamente em vez de coletá-lo para a List.

Programa para interfaces, não para implementações

Você disse que declarou a lista como ArrayListno seu código, mas você só deve fazer isso se estiver usando algum membro do ArrayListqual não esteja List.

O que você provavelmente não está fazendo.

Normalmente, você deve apenas declarar variáveis pela interface mais geral que você está indo para uso (por exemplo Iterable, Collectionou List), e inicialize-los com a aplicação específica (por exemplo ArrayList, LinkedListou Arrays.asList()).

Caso contrário, você está limitando seu código a esse tipo específico, e será mais difícil mudar quando você desejar.

Por exemplo, se você está passando um ArrayListpara um void method(...):

// Iterable if you just need iteration, for (String s : strings):
void method(Iterable<String> strings) { 
    for (String s : strings) { ... } 
}

// Collection if you also need .size(), .isEmpty(), or .stream():
void method(Collection<String> strings) {
    if (!strings.isEmpty()) { strings.stream()... }
}

// List if you also need .get(index):
void method(List<String> strings) {
    strings.get(...)
}

// Don't declare a specific list implementation
// unless you're sure you need it:
void method(ArrayList<String> strings) {
    ??? // You don't want to limit yourself to just ArrayList
}

Outro exemplo seria sempre declarar a variável an InputStreammesmo que seja geralmente uma FileInputStreamou a BufferedInputStream, porque um dia em breve você ou outra pessoa desejará usar algum outro tipo de InputStream.

Se você precisar de uma lista simples de tamanho 1:

List<String> strings = new ArrayList<String>(Collections.singletonList("A"));

Se você precisar de uma lista de vários objetos:

List<String> strings = new ArrayList<String>();
Collections.addAll(strings,"A","B","C","D");

Com o Goiaba, você pode escrever:

ArrayList<String> places = Lists.newArrayList("Buenos Aires", "Córdoba", "La Plata");

Na Goiaba também existem outros construtores estáticos úteis. Você pode ler sobre eles aqui .

Literais de coleção não chegaram ao Java 8, mas é possível usar a API Stream para inicializar uma lista em uma linha bastante longa:

List<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toList());

Se você precisa garantir que você Listé um ArrayList:

ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new));

Com java-9e acima, conforme sugerido no JEP 269: Métodos de conveniência para coleções , isso pode ser alcançado usando literais de coleção agora com -

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

Set<String> set = Set.of("A", "B", "C");

Uma abordagem semelhante se aplicaria a Map-

Map<String, String> map = Map.of("k1", "v1", "k2", "v2", "k3", "v3")

que é semelhante à proposta Literais de coleções, conforme declarado por @coobird. Mais esclarecido também no JEP -

Alternativas

As alterações de idioma foram consideradas várias vezes e rejeitadas:

Proposta de Moeda do Projeto, 29 de março de 2009

Proposta de Moeda do Projeto, 30 de março de 2009

Discussão do JEP 186 sobre lambda-dev, janeiro-março de 2014

As propostas de idioma foram separadas em preferência a uma proposta baseada em biblioteca, conforme resumido nesta mensagem.

Relacionado: Qual é o objetivo dos Métodos de Fábrica de Conveniência sobrecarregados para Coleções em Java 9

import com.google.common.collect.ImmutableList;

....

List<String> places = ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");

Você pode criar um método de fábrica:

public static ArrayList<String> createArrayList(String ... elements) {
  ArrayList<String> list = new ArrayList<String>();
  for (String element : elements) {
    list.add(element);
  }
  return list;
}

....

ArrayList<String> places = createArrayList(
  "São Paulo", "Rio de Janeiro", "Brasília");

Mas não é muito melhor do que sua primeira refatoração.

Para maior flexibilidade, pode ser genérico:

public static <T> ArrayList<T> createArrayList(T ... elements) {
  ArrayList<T> list = new ArrayList<T>();
  for (T element : elements) {
    list.add(element);
  }
  return list;
}

No Java 9, podemos inicializar facilmente um ArrayListem uma única linha:

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

ou

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Essa nova abordagem do Java 9 tem muitas vantagens sobre as anteriores:

1. Eficiência espacial
2. Imutabilidade
3. Discussão segura

Consulte esta publicação para obter mais detalhes -> Qual é a diferença entre List.of e Arrays.asList?

A maneira mais compacta de fazer isso é:

Double array[] = { 1.0, 2.0, 3.0};
List<Double> list = Arrays.asList(array);

Basta usar o código abaixo da seguinte maneira.

List<String> list = new ArrayList<String>() {{
            add("A");
            add("B");
            add("C");
}};

Com o Eclipse Collections, você pode escrever o seguinte:

List<String> list = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");

Você também pode ser mais específico sobre os tipos e se eles são Mutáveis ​​ou Imutáveis.

MutableList<String> mList = Lists.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableList<String> iList = Lists.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Você também pode fazer o mesmo com conjuntos e bolsas:

Set<String> set = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableSet<String> mSet = Sets.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet<String> iSet = Sets.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Bag<String> bag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
MutableBag<String> mBag = Bags.mutable.with("Buenos Aires", "Córdoba", "La Plata");
ImmutableBag<String> iBag = Bags.immutable.with("Buenos Aires", "Córdoba", "La Plata");

Nota: Sou um colaborador das Coleções Eclipse.

Aqui está outra maneira:

List<String> values = Stream.of("One", "Two").collect(Collectors.toList());

(Deve ser um comentário, mas muito longo, para uma nova resposta). Como outros já mencionaram, o Arrays.asListmétodo é de tamanho fixo, mas esse não é o único problema. Também não lida muito bem com herança. Por exemplo, suponha que você tenha o seguinte:

class A{}
class B extends A{}

public List<A> getAList(){
    return Arrays.asList(new B());
}

O resultado acima resulta em um erro do compilador, porque List<B>(que é retornado por Arrays.asList) não é uma subclasse de List<A>, mesmo que você possa adicionar objetos do tipo B a um List<A>objeto. Para contornar isso, você precisa fazer algo como:

new ArrayList<A>(Arrays.<A>asList(b1, b2, b3))

Esta é provavelmente a melhor maneira de fazer isso, esp. se você precisar de uma lista ilimitada ou usar herança.

Você pode usar as instruções abaixo:

Fragmento de código:

String [] arr = {"Sharlock", "Homes", "Watson"};

List<String> names = Arrays.asList(arr);

Como Tom disse :

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Mas desde que você se queixou de querer um ArrayList, primeiro você deve saber que ArrayList é uma subclasse de List e você pode simplesmente adicionar esta linha:

ArrayList<String> myPlaces = new ArrayList(places);

Embora isso possa fazer você reclamar de 'desempenho'.

Nesse caso, não faz sentido para mim, por que, como sua lista é predefinida, ela não foi definida como uma matriz (já que o tamanho é conhecido no momento da inicialização). E se essa é uma opção para você:

String[] places = {"Buenos Aires", "Córdoba", "La Plata"};

Caso você não se importe com as pequenas diferenças de desempenho, você também pode copiar uma matriz para um ArrayList de maneira muito simples:

ArrayList<String> myPlaces = new ArrayList(Arrays.asList(places));

Ok, mas no futuro você precisa um pouco mais do que apenas o nome do local, também precisa de um código de país. Supondo que ainda seja uma lista predefinida que nunca será alterada durante o tempo de execução, é adequado usar um enumconjunto, o que exigiria uma recompilação se a lista precisar ser alterada no futuro.

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

se tornaria:

enum Places {
    BUENOS_AIRES("Buenos Aires",123),
    CORDOBA("Córdoba",456),
    LA_PLATA("La Plata",789);

    String name;
    int code;
    Places(String name, int code) {
      this.name=name;
      this.code=code;
    }
}

Os enum têm um valuesmétodo estático que retorna uma matriz que contém todos os valores do enum na ordem em que são declarados, por exemplo:

for (Places p:Places.values()) {
    System.out.printf("The place %s has code %d%n",
                  p.name, p.code);
}

Nesse caso, acho que você não precisaria da sua ArrayList.

PS Randyaa demonstrou outra maneira interessante de usar o método utilitário estático Collections.addAll .

O Java 9 possui o seguinte método para criar uma lista imutável :

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

que é facilmente adaptado para criar uma lista mutável, se necessário:

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", "La Plata"));

Métodos semelhantes estão disponíveis para Sete Map.

List<String> names = Arrays.asList("2","@2234","21","11");

Sim, com a ajuda de matrizes, você pode inicializar a lista de matrizes em uma linha,

List<String> strlist= Arrays.asList("aaa", "bbb", "ccc");

Você pode usar StickyListdo Cactoos :

List<String> names = new StickyList<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

Tente com esta linha de código:

Collections.singletonList(provider)

Em Java, você não pode fazer

ArrayList<String> places = new ArrayList<String>( Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Como foi apontado, você precisaria fazer uma inicialização entre chaves:

List<String> places = new ArrayList<String>() {{ add("x"); add("y"); }};

Mas isso pode forçá-lo a adicionar uma anotação @SuppressWarnings("serial")ou gerar um UUID serial que é irritante. Além disso, a maioria dos formatadores de código o desempacotará em várias instruções / linhas.

Alternativamente, você pode fazer

List<String> places = Arrays.asList(new String[] {"x", "y" });

mas então você pode querer fazer um @SuppressWarnings("unchecked").

Também de acordo com o javadoc, você deve ser capaz de fazer isso:

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

Mas não consigo compilar com o JDK 1.6.

Collections.singletonList(messageBody)

Se você precisa ter uma lista de um item !

Collections é do pacote java.util .

A melhor maneira de fazer isso:

package main_package;

import java.util.ArrayList;


public class Stackkkk {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<Object>();
        add(list, "1", "2", "3", "4", "5", "6");
        System.out.println("I added " + list.size() + " element in one line");
    }

    public static void add(ArrayList<Object> list,Object...objects){
        for(Object object:objects)
            list.add(object);
    }
}

Basta criar uma função que possa ter quantos elementos quiser e chamá-la para adicioná-los em uma linha.

Aqui está o código de AbacusUtil

// ArrayList
List<String> list = N.asList("Buenos Aires", "Córdoba", "La Plata");
// HashSet
Set<String> set = N.asSet("Buenos Aires", "Córdoba", "La Plata");
// HashMap
Map<String, Integer> map = N.asMap("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// Or for Immutable List/Set/Map
ImmutableList.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", "Córdoba", "La Plata");
ImmutableSet.of("Buenos Aires", 1, "Córdoba", 2, "La Plata", 3);

// The most efficient way, which is similar with Arrays.asList(...) in JDK. 
// but returns a flexible-size list backed by the specified array.
List<String> set = Array.asList("Buenos Aires", "Córdoba", "La Plata");

Declaração: Sou o desenvolvedor do AbacusUtil.

Para mim, o Arrays.asList () é o melhor e mais conveniente. Eu sempre gosto de inicializar dessa maneira. Se você é iniciante em Java Collections, gostaria que você referisse a inicialização ArrayList

Por que não criar uma função utilitária simples que faça isso?

static <A> ArrayList<A> ll(A... a) {
  ArrayList l = new ArrayList(a.length);
  for (A x : a) l.add(x);
  return l;
}

" ll" significa "lista literal".

ArrayList<String> places = ll("Buenos Aires", "Córdoba", "La Plata");

Curiosamente, nenhum one-liner com o outro método sobrecarregado Stream::collect está listado

ArrayList<String> places = Stream.of( "Buenos Aires", "Córdoba", "La Plata" ).collect( ArrayList::new, ArrayList::add, ArrayList::addAll );

Na verdade, é possível fazer isso em uma linha:

Arrays.asList(new MyClass[] {new MyClass("arg1"), new MyClass("arg2")})