java - элемент - Создать ArrayList из массива




скопировать массив в arraylist java (20)

У меня есть массив, который инициализируется следующим образом:

Element[] array = {new Element(1), new Element(2), new Element(3)};

Я хотел бы преобразовать этот массив в объект класса ArrayList.

ArrayList<Element> arraylist = ???;

Еще одно решение Java8 (возможно, я пропустил ответ среди большого набора. Если да, мои извинения). Это создает ArrayList (в отличие от List), то есть можно удалить элементы

package package org.something.util;

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

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)
            .stream()
            .collect(Collectors.toCollection(ArrayList::new));
    }

    public static void main(String[] args) {
        String[] sArr = new String[]{"Hello", "cruel", "world"};
        List<String> ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

Выход ...
Привет
Мир


Java 9

В Java 9 вы можете использовать List.of static factory для создания литерала List . Что-то вроде следующего:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

Это вернет immutable список, содержащий три элемента. Если вы хотите изменить список, передайте этот список конструктору ArrayList :

new ArrayList<>(List.of(// elements vararg))

JEP 269: методы фабрики удобрений для коллекций

JEP 269 предоставляет некоторые удобные фабричные методы API Java Collections . Эти неизменные статические заводские методы встроены в интерфейсы List , Set и Map в Java 9 и более поздних версиях.


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

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

В соответствии с вопросом ответ с использованием java 1.7:

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

Однако лучше всегда использовать интерфейс:

List<Element> arraylist = Arrays.<Element>asList(array);

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

  1. List<Element> list = Arrays.asList(array);

  2. List<Element> list = new ArrayList();
    Collections.addAll(list, array);

  3. Arraylist list = new Arraylist();
    list.addAll(Arrays.asList(array));

Более подробно вы можете обратиться к http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html


Вы можете сделать это в java 8 следующим образом

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());

Вы также можете сделать это с потоком в Java 8.

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 

Дано:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

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

List<Element> listArray = Arrays.asList(array);

Другой способ (хотя по существу эквивалентен new ArrayList(Arrays.asList(array)) решению new ArrayList(Arrays.asList(array)) :

Collections.addAll(arraylist, array);

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

new ArrayList<T>(Arrays.asList(myArray));

вы можете создавать и заполнять два списка! Заполнение дважды большого списка - это именно то, чего вы не хотите делать, потому что он будет создавать другой массив Object[] каждый раз, когда необходимо увеличить пропускную способность.

К счастью, реализация JDK выполняется быстро, и Arrays.asList(a[]) очень хорошо сделан. Он создает своего рода ArrayList с именем Arrays.ArrayList, где данные Object [] указывают непосредственно на массив.

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

Опасная сторона заключается в том, что если вы измените начальный массив, вы измените List! Вы уверены, что хотите этого? Может да может нет.

Если нет, наиболее понятным способом является следующее:

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

Или, как указано в @glglgl, вы можете создать еще один независимый ArrayList с:

new ArrayList<T>(Arrays.asList(myArray));

Я люблю использовать Collections , Arrays или Гуаву. Но если это не подходит, или вы этого не чувствуете, просто напишите еще одну неэлегантную строку.


Еще один простой способ - добавить все элементы из массива в новый ArrayList, используя цикл for-each.

ArrayList<Element> list = new ArrayList<>();

for(Element e : array)
    list.add(e);

Еще одно обновление, почти закончившееся в 2014 году, вы можете сделать это и с Java 8:

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

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

List<Element> list = Stream.of(myArray).collect(Collectors.toList());

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

Скажем, у вас есть Element[] array = { new Element(1), new Element(2), new Element(3) };

Новый ArrayList может быть создан следующими способами

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

И они очень хорошо поддерживают все операции ArrayList

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

Но следующие операции возвращают только представление List для ArrayList, а не фактическое ArrayList.

// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

Поэтому они будут давать ошибку при попытке выполнить некоторые операции ArrayList

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

Подробнее о представлении списка link на массив.


Поскольку Java 8 имеет более простой способ преобразования:

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}

Самый простой способ сделать это - добавить следующий код. Пробовал и тестировал.

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

Уже каждый предоставил достаточно хороший ответ на вашу проблему. Теперь из всех предложений вам нужно решить, какое будет соответствовать вашим требованиям. Есть два типа коллекций, которые вам нужно знать. Один - это немодифицированная коллекция и другая одна коллекция, которая позволит вам позже модифицировать объект.

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

  • Непрерывное создание коллекции :: Если вы не хотите изменять объект коллекции после создания

    List<Element> elementList = Arrays.asList(array)

  • Создание мутируемых коллекций :: Когда вы захотите изменить созданный объект коллекции после создания.

    List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));


(старая нить, но всего 2 цента, поскольку никто не упоминает Guava или другие библиотеки и некоторые другие детали)

Если вы можете, используйте Guava

Стоит отметить путь Гуавы, который значительно упрощает эти махинации:

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

Для неизменяемого списка

Используйте класс copyOf() и его of() и copyOf() заводские методы (элементы не могут быть пустыми) :

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

Для сопоставимого списка

Используйте класс Lists и его newArrayList() :

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

Также обратите внимание на аналогичные методы для других структур данных в других классах, например, в Sets .

Почему Гуава?

Главной привлекательностью может быть сокращение беспорядка из-за дженериков для безопасности типов, так как использование фабричных методов Guava позволяет предположить, что типы будут выведены большую часть времени. Тем не менее, этот аргумент содержит меньше воды, поскольку Java 7 прибыла с новым оператором бриллианта.

Но это не единственная причина (и Java 7 не везде): синтаксис сокращений также очень удобен, а инициализаторы методов, как видно выше, позволяют писать более выразительный код. Вы делаете в одном вызове Guava то, что занимает 2 с текущей коллекцией Java.

Если вы не можете ...

Для неизменяемого списка

Используйте класс Arrays JDK и его asList() , завернутый в Collections.unmodifiableList() :

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

Обратите внимание, что возвращаемый тип для asList() - это List использующий конкретную реализацию ArrayList , но это НЕ java.util.ArrayList . Это внутренний тип, который эмулирует ArrayList но фактически напрямую ссылается на переданный массив и заставляет его «писать» (изменения отражены в массиве).

Он запрещает модификации с помощью некоторых методов List API, просто расширяя AbstractList (поэтому добавление или удаление элементов неподдерживается), однако он позволяет вызовам set() переопределять элементы. Таким образом, этот список не является поистине неизменным, и вызов asList() должен быть обернут Collections.unmodifiableList() .

См. Следующий шаг, если вам нужен измененный список.

Для изменяемого списка

То же, что и выше, но обернуто фактическим 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+

Для образовательных целей: правильный путь руководства

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

Чтобы преобразовать массив в ArrayList, разработчики часто это делают:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList() вернет ArrayList, который является private static class inside Arrays , это не класс java.util.ArrayList. The java.util.Arrays.ArrayList имеет методы set(), get(), contains() , но не имеет методов для добавления элементов, поэтому его размер исправлен. Чтобы создать реальный ArrayList, вы должны сделать:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

Конструктор ArrayList может принимать тип Collection , который также является супер-типом для java.util.Arrays.ArrayList


// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 

new ArrayList<>(Arrays.asList(array))




type-conversion