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

Создаем Set как:

Set myset = new HashSet()

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

ОТВЕТЫ

Ответ 1

List myList = new ArrayList();

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

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

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

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

Ответ 2

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

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");

Ответ 3

Позвольте мне подытожить и добавить что-то:

JDK

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

Guava

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

Ответ 4

В 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!

Ответ 6

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

Ответ 7

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

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

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

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

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

List<String> list = ImmutableList.of("foo", "bar");

Ответ 8

List - это просто интерфейс, как Set.

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

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

Скорее всего, он ArrayList.

Ответ 9

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 и Collectors.unmodifiableList в Java 10.

Ответ 10

List list = new ArrayList();

Или с помощью дженериков

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

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

Ответ 11

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

Ответ 12

Один пример:

List somelist = new ArrayList();

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

Ответ 13

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

import com.google.common.collect.Lists;

// ...

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

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

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

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

Ответ 14

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

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

Ответ 15

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

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

Ответ 16

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

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

List<Integer> mutableList = new ArrayList<>(immutableList);

Ответ 17

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

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

Ответ 18

List arrList = new ArrayList();

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

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

arrList.add("one");

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

List<String> lnkList = new LinkedList<String>();

Ответ 19

Больше возможностей сделать то же самое с 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));

Ответ 20

Используя 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.

Ответ 21

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

  • Это создаст список с фиксированным размером, добавление/удаление элементов невозможно, он выдаст исключение 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<>();

Ответ 22

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

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

Или же:

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

Ответ 23

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

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

Ответ 24

Как объявление списка массивов в 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();

Ответ 25

Экземпляр List может быть создан любым из следующих способов:

    List list1 = new ArrayList();
    List list2 = new Stack();
    List list3 = new LinkedList();
    List list4 = new Vector();