Я хотел создать список опций для целей тестирования. Сначала я сделал это:

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

Затем я изменил код следующим образом:

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

Есть лучший способ сделать это?

На самом деле, вероятно, «лучший» способ инициализации ArrayList- это метод, который вы написали, так как он не должен создавать новый Listспособ:

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

Подвох в том, что для ссылки на этот listэкземпляр требуется довольно много печатания .

Есть альтернативы, такие как создание анонимного внутреннего класса с инициализатором экземпляра (также известный как «инициализация двойной скобки»):

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

Тем не менее, я не слишком люблю этот метод, потому что в конечном итоге у вас есть подкласс, в ArrayListкотором есть инициализатор экземпляра, и этот класс создается только для создания одного объекта, что кажется мне немного излишним.

Было бы неплохо, если бы предложение Collection Literals для Project Coin было принято (оно должно было быть представлено в Java 7, но вряд ли оно будет частью Java 8).

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

К сожалению, это не поможет вам, так как будет инициализировать неизменяемый, Listа не ArrayList, и, более того, он еще не доступен, если он когда-либо будет.

Было бы проще, если бы вы просто объявили его как List- это должен быть ArrayList?

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

Или, если у вас есть только один элемент:

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

Это будет означать, что оно placesявляется неизменным (попытка изменить его вызовет UnsupportedOperationExceptionисключение).

Чтобы создать конкретный изменяемый список, ArrayListвы можете создать его ArrayListиз неизменяемого списка:

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

Простой ответ

В Java 9 или более поздней версии List.of()было добавлено:

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

В Java 10 или более поздней версии это можно сократить с помощью varключевого слова.

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

Это даст вам неизменность List , поэтому его нельзя изменить.
Это то, что вы хотите в большинстве случаев, когда вы его предварительно заполняете.

Java 8 или более ранняя версия:

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

Это обеспечит вам Listмассив, поэтому он не может изменить длину.
Но вы можете позвонить List.set, так что он все еще изменчив .

Вы можете сделать Arrays.asListеще короче с помощью статического импорта:

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

Статический импорт:

import static java.util.Arrays.asList;  

Что любая современная IDE предложит и автоматически сделает для вас.
Например, в IntelliJ IDEA вы нажимаете Alt+Enterи выбираете Static import method....

Однако я не рекомендую сокращать List.ofметод до of, потому что это сбивает с толку.
List.ofуже достаточно короткий и хорошо читает.

Используя Streams

Почему это должно быть List?
С Java 8 или более поздней версии вы можете использовать Streamболее гибкий:

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

Вы можете объединить Streams:

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

Или вы можете пойти от Streamк List:

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

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

Но желательно, просто используйте, Streamне собирая его List.

Если вам действительно нужноjava.util.ArrayList

(Вы, вероятно, нет.)
Цитировать JEP 269 (выделение мое):

Существует небольшой набор вариантов использования для инициализации изменяемого экземпляра коллекции с предопределенным набором значений. Обычно желательно, чтобы эти предопределенные значения были в неизменяемой коллекции, а затем инициализировать изменяемую коллекцию с помощью конструктора копирования.

Если вы хотите как предварительно заполнить ап ArrayList и добавить к нему впоследствии (почему?), Использование

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

или в Java 8 или ранее:

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

или используя Stream:

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

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

Но опять же, лучше просто использовать Streamнапрямую, а не собирать его в List.

Программа для интерфейсов, а не для реализаций

Вы сказали, что объявили список ArrayListв своем коде, но вы должны делать это только в том случае, если вы используете какой-то член ArrayList, которого нет в List.

Что вы, скорее всего, не делаете.

Как правило , вы должны просто объявить переменные наиболее общий интерфейс , который вы собираетесь использовать (например Iterable, Collectionили List) и инициализировать их с выполнением конкретной (например ArrayList, LinkedListили Arrays.asList()).

В противном случае вы ограничиваете свой код этим конкретным типом, и изменить его будет сложнее, когда вы захотите.

Например, если вы пропускание ArrayListк 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
}

Другим примером будет всегда объявлять переменную a, InputStreamдаже если это обычно a FileInputStreamили a BufferedInputStream, потому что скоро вы или кто-то другой захотите использовать какой-то другой тип InputStream.

Если вам нужен простой список размером 1:

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

Если вам нужен список из нескольких объектов:

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

С Guava вы можете написать:

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

В Гуаве есть и другие полезные статические конструкторы. Вы можете прочитать о них здесь .

Литералы коллекции не попали в Java 8, но можно использовать Stream API для инициализации списка в одну довольно длинную строку:

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

Если вам необходимо убедиться , что ваш Listявляется ArrayList:

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

С Java-9и выше, как предложено в JEP 269: Методы фабрики удобства для коллекций , это может быть достигнуто с помощью литералов коллекции теперь с -

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

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

Аналогичный подход будет применяться и к Map-

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

что аналогично предложению Collection Literals, как заявлено @coobird. Также уточняется в JEP -

альтернативы

Языковые изменения были рассмотрены несколько раз и отклонены:

Предложение монет проекта, 29 марта 2009 г.

Проект монетного предложения, 30 марта 2009 г.

JEP 186 дискуссия по лямбда-деву, январь-март 2014

Языковые предложения были отложены в предпочтении перед библиотечным предложением, как показано в этом сообщении.

Связанный: в чем смысл перегруженных методов фабрики удобства для коллекций в Java 9

import com.google.common.collect.ImmutableList;

....

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

Вы можете создать фабричный метод:

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

Но это не намного лучше, чем ваш первый рефакторинг.

Для большей гибкости он может быть общим:

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

В Java 9 мы можем легко инициализировать ArrayListодну строку:

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

или

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

Этот новый подход Java 9 имеет много преимуществ по сравнению с предыдущими:

1. Космическая эффективность
2. неизменность
3. Поток Сейф

Смотрите этот пост для более подробной информации -> В чем разница между List.of и Arrays.asList?

О самом компактном способе сделать это:

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

Просто используйте приведенный ниже код следующим образом.

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

С Eclipse Collections вы можете написать следующее:

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

Вы также можете более точно указать типы, а также то, являются ли они изменяемыми или неизменяемыми.

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

Вы также можете сделать то же самое с наборами и сумками:

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

Примечание: я являюсь коммиттером для Eclipse Collections.

Вот еще один способ:

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

(Должен быть комментарий, но слишком длинный, поэтому новый ответ). Как уже упоминалось, Arrays.asListметод имеет фиксированный размер, но это не единственная проблема с ним. Он также не очень хорошо обрабатывает наследование. Например, предположим, у вас есть следующее:

class A{}
class B extends A{}

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

Вышеприведенное приводит к ошибке компилятора, потому что List<B>(то, что возвращается Arrays.asList) не является подклассом List<A>, даже если вы можете добавить объекты типа B к List<A>объекту. Чтобы обойти это, вам нужно сделать что-то вроде:

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

Это, наверное, лучший способ сделать это, особенно. если вам нужен неограниченный список или вам нужно использовать наследование.

Вы можете использовать следующие утверждения:

Фрагмент кода:

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

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

Как сказал Том :

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

Но так как вы жаловались на то, что хотите ArrayList, вы должны сначала знать, что ArrayList является подклассом List, и вы можете просто добавить эту строку:

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

Хотя, это может заставить вас жаловаться на «производительность».

В этом случае мне не имеет смысла, почему, поскольку ваш список предопределен, он не был определен как массив (так как размер известен во время инициализации). И если это вариант для вас:

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

Если вам не нужны незначительные различия в производительности, вы также можете очень просто скопировать массив в ArrayList:

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

Хорошо, но в будущем вам понадобится не только название места, но и код страны. Предполагая, что это все еще предопределенный список, который никогда не изменится во время выполнения, тогда можно использовать enumнабор, который потребует повторной компиляции, если список потребуется изменить в будущем.

enum Places {BUENOS_AIRES, CORDOBA, LA_PLATA}

станет:

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

Enum имеет статический valuesметод, который возвращает массив, содержащий все значения enum в порядке их объявления, например:

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

В этом случае, я думаю, вам не нужен ваш ArrayList.

PS Рандяа продемонстрировал еще один приятный способ, используя статический служебный метод Collections.addAll .

Java 9 имеет следующий метод для создания неизменяемого списка:

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

который легко адаптируется для создания изменяемого списка, если требуется:

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

Подобные методы доступны для Setи Map.

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

Да, с помощью массивов вы можете инициализировать список массивов в одну строку,

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

Вы можете использовать StickyListот Cactoos :

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

Попробуйте с этой строкой кода:

Collections.singletonList(provider)

В Java вы не можете сделать

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

Как было указано, вам нужно выполнить инициализацию в виде двойной скобки:

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

Но это может заставить вас добавить аннотацию @SuppressWarnings("serial") или создать серийный UUID, который раздражает. Кроме того, большинство форматировщиков кода развернут это в несколько операторов / строк.

В качестве альтернативы вы можете сделать

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

но тогда вы можете сделать @SuppressWarnings("unchecked") .

Также в соответствии с Javadoc вы должны быть в состоянии сделать это:

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

Но я не могу заставить его скомпилировать с JDK 1.6.

Collections.singletonList(messageBody)

Если вам нужно иметь список из одного элемента !

Коллекции из пакета java.util .

Лучший способ сделать это:

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

Просто создайте функцию, которая может иметь столько элементов, сколько вы хотите, и вызовите ее, чтобы добавить их в одну строку.

Вот код от 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");

Декларация: я разработчик AbacusUtil.

Для меня Arrays.asList () - лучший и удобный. Мне всегда нравится инициализировать этот путь. Если вы новичок в коллекциях Java, я бы хотел, чтобы вы ссылались на инициализацию ArrayList

Почему бы не сделать простую служебную функцию, которая делает это?

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

« ll» означает «буквальный список».

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

интересно, что ни один вкладыш с другим перегруженным Stream::collect методом не указан

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

На самом деле, это можно сделать в одну строку:

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