(thread antigo, mas apenas 2 centavos, como nenhum menciona Goiaba ou outras bibliotecas e alguns outros detalhes)
Se puder, use goiaba
Vale ressaltar o caminho da goiaba, que simplifica bastante essas travessuras:
Uso
Para uma lista imutável
Use a ImmutableListclasse e seus métodos of()e copyOf()factory (os elementos não podem ser nulos) :
List<String> il = ImmutableList.of("string", "elements"); // from varargs
List<String> il = ImmutableList.copyOf(aStringArray); // from array
Para uma lista mutável
Use a Listsclasse e seus newArrayList()métodos de fábrica:
List<String> l1 = Lists.newArrayList(anotherListOrCollection); // from collection
List<String> l2 = Lists.newArrayList(aStringArray); // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs
Observe também os métodos semelhantes para outras estruturas de dados em outras classes, por exemplo em Sets.
A principal atração poderia ser reduzir a desordem devido aos genéricos para a segurança do tipo, como o uso dos métodos da fábrica de goiaba permite que os tipos sejam inferidos na maioria das vezes. No entanto, esse argumento retém menos água desde que o Java 7 chegou com o novo operador de diamantes.
Mas esse não é o único motivo (e o Java 7 ainda não está em todo lugar): a sintaxe abreviada também é muito útil e os inicializadores de métodos, como visto acima, permitem escrever um código mais expressivo. Você faz em uma chamada Guava o que leva 2 com as coleções Java atuais.
Se você não pode ...
Para uma lista imutável
Use a Arraysclasse do JDK e seu asList()método de fábrica, envolvido por Collections.unmodifiableList():
List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));
Observe que o tipo retornado para asList()é Listusando uma ArrayListimplementação concreta , mas NÃO é java.util.ArrayList . É um tipo interno, que emula um, ArrayListmas na verdade faz referência direta à matriz passada e a faz "escrever" (as modificações são refletidas na matriz).
Ele proíbe modificações através de alguns dos Listmétodos da API, simplesmente estendendo um AbstractList(portanto, adicionar ou remover elementos não é suportado), mas permite que as chamadas set()substituam elementos. Portanto, esta lista não é verdadeiramente imutável e uma chamada a asList()ser cumprida Collections.unmodifiableList().
Veja o próximo passo se precisar de uma lista mutável.
Para uma lista mutável
O mesmo que acima, mas envolvido com um real java.util.ArrayList:
List<String> l1 = new ArrayList<String>(Arrays.asList(array)); // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array)); // Java 1.7+
List<String> l2 = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b")); // Java 1.7+
Para fins educacionais: o bom e velho caminho manual
// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
final List<T> l = new ArrayList<T>(array.length);
for (final T s : array) {
l.add(s);
}
return (l);
}
// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
final List l = new ArrayList(array.length);
for (int i = 0; i < array.length; i++) {
l.add(array[i]);
}
return (l);
}