Как сделать новый список в Java

762

Мы создаем Setкак:

Set myset = new HashSet()

Как мы создаем Listв Java?

user93796
источник
1
На Javadoc для списка. «Все известные классы реализации: AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector»
KitsuneYMG
121
Этот вопрос является одним из самых популярных в Google по списку «java create list», и у него есть очень полезный набор ответов, поэтому он кажется мне достаточно разумным :-)
JosephH
52
Это хороший вопрос с хорошими ответами. Одна из целей Stack Overflow - создать какой-то канонический ответ на вопросы программирования, по крайней мере, по словам основателей сайта. Поэтому, пожалуйста, постарайтесь избежать повторного голосования подобных сообщений в будущем, если вы можете противостоять искушению.
eggonlegs

Ответы:

978
List myList = new ArrayList();

или с дженериками ( Java 7 или более поздняя версия)

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

или с дженериками (старые версии Java)

List<MyType> myList = new ArrayList<MyType>();
Дэн Винтон
источник
68
Обратите внимание, что ArrayList - не единственный вид List - и, что касается вопроса, HashSet - не единственный вид Set.
худенький
17
Я удивлен, что никто не упомянул, что вы можете посмотреть интерфейс списка в документации Java, чтобы получить определенный список всех классов, которые реализуют List: docs.oracle.com/javase/7/docs/api/java/util /List.html
Дэвид Мейсон
5
Если вы используете IDE, вы также можете просматривать иерархию типов там, что может быть более удобным. В Eclipse по умолчанию используется ярлык F4, а в IDEA это Ctrl + H.
Дэвид Мейсон
1
Насколько я понимаю, вы не можете использовать дженерики с ArrayList в C # MSDN
JohnOsborne
5
Второй явный аргумент типа <MyType> можно заменить просто <> для Java 7 и 8.
Jannik
469

Кроме того, если вы хотите создать список, в котором есть что-то (хотя это будет фиксированный размер):

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");
Аарон Маенпаа
источник
15
Предостережение заключается в том, что этот тип списка (тот, который возвращается asList ()) является неизменным.
Авром
70
@Avron - неправильно: это только фиксированный размер: вы не можете изменить размер, но вы можете изменить содержимое (предостережение о предостережении?)
user85421
Потрясающие. Спасибо за краткость.
R Claven
1
если в списке есть только одна вещь, я использую Collections.singletonList () вместо Arrays.asList (). (Но, я думаю, я не знаю почему.)
MikeB
@MikeB, если вы не знаете, почему, тогда придерживайтесь arrays.aslist
bharal
183

Позвольте мне подвести итог и добавить кое-что:

JDK

1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")

гуайява

1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});

Неизменный список

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

Пустой неизменяемый список

1. Collections.emptyList();
2. Collections.EMPTY_LIST;

Список персонажей

1. Lists.charactersOf("String")                                 // Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  // Guava

Список целых чисел

Ints.asList(1,2,3);                                             // Guava
Сергей Шевчик
источник
Ints.asListне создает неизменный список, но список фиксированного размера, подкрепленный заданным массивом целых чисел (т.е. он поддерживает List.set(int, Object)). Второй пример «Неизменяемого списка символов» также не является неизменным (я бы удалил эту строку).
Xaerxess
9
Неиспользование дженериков создает действительно «хороший» пример для любого разработчика, который прочтет это.
Natix,
60

В Java 8

Чтобы создать непустой список фиксированного размера (такие операции, как добавление, удаление и т. Д. Не поддерживаются):

List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported

Чтобы создать непустой изменяемый список:

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

В Java 9

Используя новые List.of(...)статические фабричные методы:

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

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

В Java 10

Используя вывод типа локальной переменной :

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

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

var list3 = new ArrayList<String>();

И следовать лучшим практикам ...

Не используйте сырые типы

Начиная с Java 5, дженерики были частью языка - вы должны использовать их:

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

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

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

Например, программа для Listинтерфейса:

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

Вместо:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!
Александр Пирохов
источник
1
Привет, не могли бы вы предложить, где я могу узнать эти различия и эволюцию Java? Кажется очень интересным!
Шив
31

Сначала прочитайте это , затем прочитайте это и это . 9 раз из 10 вы будете использовать одну из этих двух реализаций.

На самом деле, просто прочитайте Sun's Guide по структуре коллекций .

Адам Яскевич
источник
11
Я бы даже добавил «8 раз из 10», вы будете использовать ArrayList, просто потому, что это просто не имеет значения в 9,9 раз из 10.
Joachim Sauer
1
LinkedList семантически уместен, когда вы действительно заботитесь только о концах.
Адам Яскевич
LinkedLists превосходны, если вы просто собираетесь их перебирать. Мне кажется, что связанные списки более элегантны, но, возможно, это только потому, что я выучил lisp до Java.
KarlP
@Karlp Согласен. Я бы сказал, что между ArrayList и LinkedList большую часть времени составляет 50/50, и ответ не всегда связан со сложностью операций; чаще всего это просто то, что кажется правильным для стоящей перед нами проблемы.
Адам Яскевич
1
Я почти всегда использовал ArrayList. Если я работаю только с концами списка, это deque (или очередь), и я использую ArrayDequeреализацию. Причина в том, что, хотя реализации на основе массива могут тратить некоторую память на пустые слоты (когда я не могу предсказать необходимую емкость), для небольших коллекций это сопоставимо с накладными расходами всех экземпляров узла в связанном списке ( или deque). И в ответ я получаю произвольный доступ. Какое уникальное преимущество LinkedListдает?
Эриксон
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
источник
21

Начиная с Java 7, у вас есть вывод типов для создания универсального экземпляра , поэтому нет необходимости дублировать универсальные параметры в правой части назначения:

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

Список фиксированного размера может быть определен как:

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

Для неизменяемых списков вы можете использовать библиотеку Guava :

List<String> list = ImmutableList.of("foo", "bar");
Виталий Федоренко
источник
У меня есть вопрос относительно этого объявления List <String> list = Arrays.asList ("foo", "bar"); Мне интересно, является ли список в объявлении объектом?
20

Список просто интерфейс, как Set .

Подобно тому, как HashSet является реализацией Set, которая имеет определенные свойства в отношении добавления / поиска / удаления производительности, ArrayList является голой реализацией List.

Если вы посмотрите документацию для соответствующих интерфейсов, вы найдете «Все известные классы реализации» и сможете решить, какой из них больше подходит для ваших нужд.

Скорее всего, это ArrayList .

Сорин Мокану
источник
18

Listявляется интерфейсом как Setи имеет ArrayListи LinkedListкак реализации общего назначения .

Мы можем создать список как:

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

Мы также можем создать список фиксированного размера как:

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

Мы почти всегда будем использовать в ArrayListпротивоположность LinkedListреализации:

  1. LinkedList использует много места для объектов и плохо работает, когда у нас много элементов.
  2. Любая индексированная операция в LinkedListтребует времени O (n) по сравнению с O (1) в ArrayList.
  3. Проверьте эту ссылку для получения дополнительной информации.

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

Java 8

Согласно документу , метод Collections.unmodifiableListвозвращает неизменяемое представление указанного списка. Мы можем получить это как:

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

Java 9

Если мы используем Java 9, тогда:

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

Java 10

В случае, если мы находимся на Java 10, метод Collectors.unmodifiableListвозвратит экземпляр действительно неизменяемого списка, представленного в Java 9. Проверьте этот ответ для получения дополнительной информации о разнице в Collections.unmodifiableList vs Collectors.unmodifiableListв Java 10 .

akhil_mittal
источник
9

Иногда - но только очень редко - вместо нового ArrayList вы можете захотеть новый LinkedList. Начните с ArrayList, и если у вас есть проблемы с производительностью и доказательства того, что список является проблемой, и много добавлений и удалений в этот список - тогда - не раньше - переключитесь на LinkedList и посмотрите, улучшатся ли вещи. Но в основном придерживайтесь ArrayList и все будет хорошо.

Карл Манастер
источник
9
List list = new ArrayList();

Или с дженериками

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

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

Пауло Гуэдес
источник
7

Один пример:

List somelist = new ArrayList();

Вы можете посмотреть на javadoc для List и найти все известные классы реализации Listинтерфейса, которые включены в java api.

Алекс Б
источник
7

Используя Google Collections , вы можете использовать следующие методы в классе Lists

import com.google.common.collect.Lists;

// ...

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

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

Существуют перегрузки для инициализации и инициализации varargs из Iterable<T>.

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

Бен Лингс
источник
6
List<Object> nameOfList = new ArrayList<Object>();

Вам нужно импортировать Listи ArrayList.

jp093121
источник
6

Больше возможностей сделать то же самое с Java 8, не лучше, не хуже, просто по-другому, и если вы хотите проделать дополнительную работу со списками, Streams предоставит вам больше альтернатив (фильтр, отображение, уменьшение и т. Д.)

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
источник
6

С Java 9 вы можете сделать следующее для создания неизменяемого List :

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

List<Integer> mutableList = new ArrayList<>(immutableList);
Джейкоб Г.
источник
6

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

List<String> list = new ArrayList<String>(){
  {
   add("a");
   add("b");
  }
};
angry_gopher
источник
2
Это дорогая операция. Вы создаете анонимный подкласс ArrayList здесь.
Викрам Бодичерла
@VikramBodicherla Я согласен. Это больше о синтаксисе сахара здесь.
angry_gopher
5

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

Это хорошее введение для встроенных коллекций Java. http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

Питер Лори
источник
5
List arrList = new ArrayList();

Лучше использовать дженерики, как указано ниже:

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

arrList.add("one");

Если вы используете LinkedList.

List<String> lnkList = new LinkedList<String>();
Рохит Гоял
источник
4

Используя Eclipse Collections, вы можете создать список следующим образом:

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

Если вы хотите неизменный список:

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

Вы можете избежать автобокса, используя примитивные списки. Вот как вы можете создавать 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);

Есть варианты для всех 8 примитивов.

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

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

Крейг П. Мотлин
источник
4

Ниже приведены некоторые способы создания списков.

  • Это создаст список с фиксированным размером, добавление / удаление элементов невозможно, java.lang.UnsupportedOperationExceptionесли вы попытаетесь это сделать, вы получите список .

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


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

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


  • Это как создать LinkedListв Java, если вам нужно делать частые вставки / удаления элементов в списке, вы должны использовать LinkedListвместоArrayList

    List<String> linkedList = new LinkedList<>();
JoBⅈN
источник
1
Вы можете использовать Arrays.asList("Male", "Female").
Джонни
3

Попробуй это:

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

Или:

List<String> list1 = Lists.mutable.empty(); // Empty
List<String> list2 = Lists.mutable.of("One", "Two", "Three");
Гавриил Коэн
источник
2

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

List<String> singList = Collections.singletonList("stackoverlow");
Эрол Йениарас
источник
2

Как объявление списка массивов в Java похоже

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

Существует множество способов создания и инициализации списка массивов в 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
источник