Преобразование массива в список на Java

Ответ 1

В вашем примере это потому, что вы не можете иметь список примитивного типа. Другими словами, List<int> невозможен.

Однако вы можете получить List<Integer>, используя класс Integer, который обертывает примитив int. Преобразуйте ваш массив в List с помощью Arrays.asList служебного метода.

Integer[] spam = new Integer[] { 1, 2, 3 };
List<Integer> list = Arrays.asList(spam);

Смотрите этот код на сайте IdeOne.com.

Ответ 2

В Java 8 вы можете использовать потоки:

int[] spam = new int[] { 1, 2, 3 };
Arrays.stream(spam)
      .boxed()
      .collect(Collectors.toList());

Ответ 3

Говоря об обращении, это зависит от того, зачем вам нужен List. Если вам это нужно, просто для чтения данных. Хорошо, здесь вы идете:

Integer[] values = { 1, 3, 7 };
List<Integer> list = Arrays.asList(values);

Но если вы сделаете что-то вроде этого:

list.add(1);

вы получите java.lang.UnsupportedOperationException. Поэтому для некоторых случаев вам даже понадобится следующее:

Integer[] values = { 1, 3, 7 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(values));

Первый подход фактически не преобразует массив, а "представляет" его как List. Но массив находится под капотом со всеми его свойствами, такими как фиксированное количество элементов. Обратите внимание, что при построении ArrayList необходимо указать тип.

Ответ 4

Проблема заключается в том, что varargs введены в Java5 и, к сожалению, Arrays.asList() тоже перегружен версией vararg. Таким образом, Arrays.asList(spam) понимается компилятором Java5 как параметр vararg для массивов int.

Эта проблема объясняется более подробно в "Эффективной Java 2-й редакции", глава 7, пункт 42.

Ответ 5

Кажется, немного поздно, но вот мои два цента. У нас не может быть List<int> поскольку int является примитивным типом, поэтому у нас может быть только List<Integer>.

Java 8 (массив int)

int[] ints = new int[] {1,2,3,4,5};
List<Integer> list11 =Arrays.stream(ints).boxed().collect(Collectors.toList()); 

Java 8 и ниже (целочисленный массив)

Integer[] integers = new Integer[] {1,2,3,4,5};
List<Integer> list21 =  Arrays.asList(integers); // returns a fixed-size list backed by the specified array.
List<Integer> list22 = new ArrayList<>(Arrays.asList(integers)); // good
List<Integer> list23 = Arrays.stream(integers).collect(Collectors.toList()); //Java 8 only

Нужен ArrayList, а не список?

В случае, если мы хотим конкретную реализацию List например ArrayList мы можем использовать toCollection как:

ArrayList<Integer> list24 = Arrays.stream(integers)
                          .collect(Collectors.toCollection(ArrayList::new));

Почему list21 не может быть структурно изменен?

Когда мы используем Arrays.asList размер возвращаемого списка фиксируется, потому что возвращаемый список - это не java.util.ArrayList, а частный статический класс, определенный внутри java.util.Arrays. Поэтому, если мы добавим или удалим элементы из возвращенного списка, будет UnsupportedOperationException исключение UnsupportedOperationException. Таким образом, мы должны перейти к list22 когда мы хотим изменить список. Если у нас есть Java8, то мы также можем перейти с list23.

Для ясности list21 может быть изменен в том смысле, что мы можем вызвать list21.set(index,element) но этот список не может быть структурно изменен, т.е. не может добавлять или удалять элементы из списка. Вы также можете проверить этот вопрос.

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

List<Integer> list 22 = Collections.unmodifiableList(Arrays.asList(integers));

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

У нас может быть действительно неизменный список в Java 10.

Java 10 (действительно неизменный список) двумя способами:

1. List.copyOf(Arrays.asList(integers))
2. Arrays.stream(integers).collect(Collectors.toUnmodifiableList());

Также проверьте мой ответ для получения дополнительной информации.

Ответ 6

Мне недавно пришлось преобразовать массив в список. Позже программа отфильтровала список, пытающийся удалить данные. Когда вы используете функцию Arrays.asList(массив), вы создаете коллекцию фиксированного размера: вы не можете ни добавлять, ни удалять. Эта запись объясняет проблему лучше, чем я могу: Почему я получаю UnsupportedOperationException при попытке удалить элемент из списка?.

В конце концов, мне пришлось выполнить "ручное" преобразование:

    List<ListItem> items = new ArrayList<ListItem>();
    for (ListItem item: itemsArray) {
        items.add(item);
    }

Я полагаю, что я мог бы добавить преобразование из массива в список, используя операцию List.addAll(items).

Ответ 7

Еще короче:

List<Integer> list = Arrays.asList(1, 2, 3, 4);

Ответ 8

Использование массивов

Это самый простой способ преобразования массива в List. Однако, если вы попытаетесь добавить новый элемент или удалить существующий элемент из списка, будет выбрано UnsupportedOperationException.

Integer[] existingArray = {1, 2, 3};
List<Integer> list1 = Arrays.asList(existingArray);
List<Integer> list2 = Arrays.asList(1, 2, 3);

// WARNING:
list2.add(1);     // Unsupported operation!
list2.remove(1);  // Unsupported operation!

Использование ArrayList или других реализаций списка

Вы можете использовать цикл for, чтобы добавить все элементы массива в реализацию List, например. ArrayList:

List<Integer> list = new ArrayList<>();
for (int i : new int[]{1, 2, 3}) {
  list.add(i);
}

Использование Stream API в Java 8

Вы можете превратить массив в поток, а затем собрать поток с использованием разных коллекционеров: сборщик по умолчанию в Java 8 использует ArrayList за экраном, но вы также можете навязать свою предпочтительную реализацию.

List<Integer> list1, list2, list3;
list1 = Stream.of(1, 2, 3).collect(Collectors.toList());
list2 = Stream.of(1, 2, 3).collect(Collectors.toCollection(ArrayList::new));
list3 = Stream.of(1, 2, 3).collect(Collectors.toCollection(LinkedList::new));

См. также:

• Почему мы используем autoboxing и unboxing в Java?
• Когда использовать LinkedList над ArrayList?

Ответ 9

Еще одно обходное решение, если вы используете apache commons-lang:

int[] spam = new int[] { 1, 2, 3 };
Arrays.asList(ArrayUtils.toObject(spam));

Где ArrayUtils.toObject преобразует int[] в Integer[]

Ответ 10

Если вы ориентируетесь на Java 8 (или более позднюю версию), вы можете попробовать это:

int[] numbers = new int[] {1, 2, 3, 4};
List<Integer> integers = Arrays.stream(numbers)
                        .boxed().collect(Collectors.<Integer>toList());

НОТА:

Обратите внимание на Collectors.<Integer>toList(), этот универсальный метод помогает избежать ошибки "Несоответствие типов: невозможно преобразовать из List<Object> в List<Integer> ".

Ответ 11

В Java 9 у вас есть еще более элегантное решение по использованию неизменяемых списков с помощью нового удобного метода factory List.of:

List<String> immutableList = List.of("one","two","three");

(бесстыдно скопировано из здесь)

Ответ 12

вам нужно включить в массив

Arrays.asList((Object[]) array)

Ответ 13

Однострочник:

List<Integer> list = Arrays.asList(new Integer[] {1, 2, 3, 4});

Ответ 14

• Использование Guava:

  Integer[] array = { 1, 2, 3};
  List<Integer> list = Lists.newArrayList(sourceArray);
  

• Использование коллекций Apache Commons:

  Integer[] array = { 1, 2, 3};
  List<Integer> list = new ArrayList<>(6);
  CollectionUtils.addAll(list, array);
  

Ответ 15

Итак, это зависит от того, какую версию Java вы пытаетесь -

Java 7

 Arrays.asList(1, 2, 3);

ИЛИ

       final String arr[] = new String[] { "G", "E", "E", "K" };
       final List<String> initialList = new ArrayList<String>() {{
           add("C");
           add("O");
           add("D");
           add("I");
           add("N");
       }};

       // Elements of the array are appended at the end
       Collections.addAll(initialList, arr);

ИЛИ

Integer[] arr = new Integer[] { 1, 2, 3 };
Arrays.asList(arr);

В Java 8

int[] num = new int[] {1, 2, 3};
List<Integer> list = Arrays.stream(num)
                        .boxed().collect(Collectors.<Integer>toList())

Ссылка - http://www.codingeek.com/java/how-to-convert-array-to-list-in-java/

Ответ 16

Если это помогает: у меня была та же проблема и просто написал обобщенную функцию, которая принимает массив и возвращает ArrayList того же типа с тем же содержимым:

public static <T> ArrayList<T> ArrayToArrayList(T[] array) {
    ArrayList<T> list = new ArrayList<T>();
    for(T elmt : array) list.add(elmt);
    return list;
}

Ответ 17

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

Массив быстрее, чем ArrayList, потому что ArrayList использует фиксированное количество массива. Однако, когда вы добавляете элемент в ArrayList, и он переполняется (превышает его фактический размер, определенный при запуске). Он создает новый массив и копирует каждый элемент из старого в новый. По этой причине программисты предпочитают Array, а не ArrayList. Но в реальных приложениях всегда необходимо преобразовать Array в ArrayList. Это можно сделать напрямую, используя встроенную функцию Java для преобразования String Array в ArrayList.

Синтаксис для преобразования String Array в ArrayList:

 List<String> a = new ArrayList<String>(Arrays.asList(StringObject));

Пример преобразования в ArrayList из Array:

import java.util.Arrays;
    import java.util.List;
    import java.util.ArrayList;

    public class ArrayToArrayList {

                public static void main(String[] args) {

                     String[] str = {"Solution","Factory"}; 

                     List<String> a = new ArrayList<String>(Arrays.asList(str));

                         System.out.println(a);

                 }
    }

Для получения дополнительной информации нажмите: https://www.solutionfactory.in/posts/How-to-Convert-String-Array-to-ArrayList-in-Java

Ответ 18

Заданный массив:

    int[] givenArray = {2,2,3,3,4,5};

Преобразование целочисленного массива в список целых чисел

Один из способов: boxed() → возвращает IntStream

    List<Integer> givenIntArray1 = Arrays.stream(givenArray)
                                  .boxed()
                                  .collect(Collectors.toList());

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

Примечание: Используя mapToObj, вы можете преобразовать каждый элемент int в строковый поток, поток символов и т.д., Указав i в (char) i

    List<Integer> givenIntArray2 = Arrays.stream(givenArray)
                                         .mapToObj(i->i)
                                         .collect(Collectors.toList());

Преобразование одного массива в другой тип Пример:

List<Character> givenIntArray2 = Arrays.stream(givenArray)
                                             .mapToObj(i->(char)i)
                                             .collect(Collectors.toList());

Ответ 19

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

  Integer [] arr={1,2};
  Arrays.asList(arr);