У меня есть массив, который инициализируется как:
Element[] array = {new Element(1), new Element(2), new Element(3)};
Я хотел бы преобразовать этот массив в объект ArrayList
класса.
ArrayList<Element> arraylist = ???;
new ArrayList<>(Arrays.asList(array));
new ArrayList
вызов также не нужен. List<ClassName> list = Arrays.asList(array)
Arrays.asList(array)
без передачи его в новый ArrayList
объект будет фиксировать размер списка. Одной из наиболее распространенных причин использования ArrayList
является возможность динамически изменять его размер, и ваше предложение предотвратит это. new ArrayList<T>(Arrays.asList(myArray));
Убедитесь, что myArray
это тот же тип, что и T
. Вы получите ошибку компилятора, если попытаетесь создать , например, List<Integer>
из массива int
.
Вам, вероятно, просто нужен список, а не ArrayList. В этом случае вы можете просто сделать:
List<Element> arraylist = Arrays.asList(array);
set
метод), вы не можете изменить размер списка (нет add
или remove
элементы)! Данный:
Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };
Самый простой ответ:
List<Element> list = Arrays.asList(array);
Это будет работать нормально. Но некоторые предостережения:
- Список, возвращаемый из asList, имеет фиксированный размер . Итак, если вы хотите иметь возможность добавлять или удалять элементы из возвращенного списка в вашем коде, вам нужно обернуть его в новый
ArrayList
. В противном случае вы получитеUnsupportedOperationException
. - Возвращаемый список
asList()
поддерживается исходным массивом. Если вы измените исходный массив, список также будет изменен. Это может быть удивительно.
java.util.ArrayList
. Arrays.asList фактически возвращает класс, java.util.Arrays.ArrayList
который не является instanceof
другим классом. Поэтому третье предостережение заключается в том, что если вы попытаетесь использовать его в контексте, требующем вышеуказанного, он не будет работать. Поскольку этот вопрос довольно старый, меня удивляет, что никто еще не предложил простейшую форму:
List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
Начиная с Java 5, Arrays.asList()
принимает параметр varargs, и вам не нужно явно создавать массив.
List<String> a = Arrays.asList("first","second","third")
Другой способ (хотя по сути эквивалентный new ArrayList(Arrays.asList(array))
решению с точки зрения производительности:
Collections.addAll(arraylist, array);
(старая ветка, но всего 2 цента, так как никто не упоминает Guava или другие библиотеки и некоторые другие детали)
Если можете, используйте гуаву
Стоит указать путь гуавы, который значительно упрощает эти махинации:
использование
Для неизменного списка
Используйте ImmutableList
класс и его методы 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
.
Почему гуава?
Основная привлекательность может заключаться в уменьшении беспорядка из-за обобщений для безопасности типов, так как использование фабричных методов Гуавы позволяет выводить типы в большинстве случаев. Тем не менее, этот аргумент содержит меньше воды, так как Java 7 прибыл с новым оператором Diamond.
Но это не единственная причина (и 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);
}
List
возвращаемое значение Arrays.asList
является изменяемым, поскольку вы все еще можете set
элементы - оно просто не может быть изменено. Для неизменяемых списков без гуавы вы могли бы упомянуть Collections.unmodifiableList
. arrayToList
для Java 1.5+ неверен. Вы создаете экземпляры списков String
и пытаетесь получить строки из данного массива вместо использования общего типа параметра T
. Кроме этого, хороший ответ и +1 за то, что он единственный, включая ручной способ. O(1)
, но для неизменности вы должны сделать копию, например, с помощью Collections.unmodifiableList(new ArrayList<>(Arrays.asList(array)))
. Есть еще один вариант, если ваша цель - создать фиксированный список во время выполнения, который настолько прост, насколько это эффективно:
static final ArrayList<Element> myList = generateMyList();
private static ArrayList<Element> generateMyList() {
final ArrayList<Element> result = new ArrayList<>();
result.add(new Element(1));
result.add(new Element(2));
result.add(new Element(3));
result.add(new Element(4));
return result;
}
Преимущество использования этого шаблона состоит в том, что этот список создается за один раз очень интуитивно, и поэтому его очень легко изменить даже с большими списками или сложной инициализацией, в то время как, с другой стороны, всегда содержит одни и те же элементы при каждом фактическом запуске программы ( если вы не измените его на более позднем этапе, конечно).
// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray);
Если вы используете:
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
}
....
}
Опасная сторона в том, что если вы измените исходный массив, вы измените список! Вы уверены, что хотите этого? Может да может нет.
Если нет, то самый понятный способ сделать это:
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
, или Guava. Но если он не подходит или вы этого не чувствуете, просто напишите еще одну не элегантную строку.
new ArrayList<T>(Arrays.asList(myArray));
частью, которую вы не хотите использовать. Оба делают одно и то же и имеют одинаковую сложность. new ArrayList<T>(Arrays.asList(myArray));
делает то же самое, он копирует asList
Ань ArrayList
...Еще одно обновление, почти заканчивающееся 2014 годом, вы можете сделать это и с Java 8:
ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));
Несколько символов будут сохранены, если это может быть просто List
List<Element> list = Stream.of(myArray).collect(Collectors.toList());
Collectors.toList()
самом деле возвращает ArrayList
. В соответствии с вопросом ответ с использованием Java 1.7:
ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));
Однако лучше всегда использовать интерфейс:
List<Element> arraylist = Arrays.<Element>asList(array);
Другой простой способ - добавить все элементы из массива в новый ArrayList, используя цикл for-each.
ArrayList<Element> list = new ArrayList<>();
for(Element e : array)
list.add(e);
Вы также можете сделать это с потоком в Java 8.
List<Element> elements = Arrays.stream(array).collect(Collectors.toList());
Collectors.toList()
вернет ArrayList
. Однако это может отличаться в будущих версиях java. Если вы хотите определенный тип коллекции, используйте Collectors.toCollection()
вместо нее, где вы можете указать, какой именно тип коллекции вы хотите создать. Если мы увидим определение
Arrays.asList()
метода, вы получите что-то вроде этого:public static <T> List<T> asList(T... a) //varargs are of T type.
Итак, вы можете инициализировать
arraylist
так:List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
Примечание : каждый
new Element(int args)
будет рассматриваться как отдельный объект и может быть передан какvar-args
.Там может быть другой ответ на этот вопрос тоже.
Если вы видите объявление дляjava.util.Collections.addAll()
метода, вы получите что-то вроде этого:public static <T> boolean addAll(Collection<? super T> c, T... a);
Таким образом, этот код также полезен для этого
Collections.addAll(arraylist, array);
Java 9
В Java 9 вы можете использовать List.of
статический фабричный метод для создания List
литерала. Что-то вроде следующего:
List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));
Это вернет неизменный список, содержащий три элемента. Если вы хотите непостоянный список, передайте этот список ArrayList
конструктору:
new ArrayList<>(List.of(// elements vararg))
JEP 269: методы фабрики удобства для коллекций
JEP 269 предоставляет некоторые удобные фабричные методы для API коллекций Java . Эти неизменные статические фабричные методы встроены в List
, Set
и Map
интерфейсы в Java 9 и более поздних версий.
Вы можете конвертировать, используя разные методы
List<Element> list = Arrays.asList(array);
List<Element> list = new ArrayList();
Collections.addAll(list, array);Arraylist list = new Arraylist();
list.addAll(Arrays.asList(array));
Для получения более подробной информации вы можете обратиться к http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html
Начиная с Java 8 существует более простой способ преобразования:
public static <T> List<T> fromArray(T[] array) {
return Arrays.stream(array).collect(toList());
}
как все сказали, так и будет
new ArrayList<>(Arrays.asList("1","2","3","4"));
и самый распространенный способ создания массива - observableArrays
ObservableList: список, который позволяет слушателям отслеживать изменения, когда они происходят.
для Java SE вы можете попробовать
FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));
то есть согласно Oracle Docs
observableArrayList () Создает новый пустой список наблюдаемых, который поддерживается массивом. observableArrayList (E ... items) Создает новый список наблюдаемых массивов с добавленными в него элементами.
Обновите Java 9
также в Java 9 это немного просто:
List<String> list = List.of("element 1", "element 2", "element 3");
Хотя на этот вопрос есть много прекрасно написанных ответов, я добавлю свои комментарии.
Скажи у тебя есть 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
Но следующие операции возвращают только представление списка 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
Подробнее о представлении списка ссылки на массив .
В Java 9
вы можете использовать:
List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);
Самый простой способ сделать это - добавить следующий код. Пробовал и проверял.
String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));
Вы можете сделать это в Java 8 следующим образом
ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());
ArrayList<String> list = Arrays.stream(array).collect(Collectors.toCollection(ArrayList::new));
Другое решение Java8 (я мог пропустить ответ среди большого набора. Если так, мои извинения). Это создает ArrayList (в отличие от списка), то есть можно удалить элементы
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);
}
}
Вывод ...
Привет,
мир
Вы можете создать с ArrayList
помощью Cactoos (я один из разработчиков):
List<String> names = new StickyList<>(
"Scott Fitzgerald", "Fyodor Dostoyevsky"
);
Нет никакой гарантии, что объект действительно будет классом ArrayList
. Если вам нужна эта гарантия, сделайте это:
ArrayList<String> list = new ArrayList<>(
new StickyList<>(
"Scott Fitzgerald", "Fyodor Dostoyevsky"
)
);
List
и остальные ее коллекции (ArrayList и т. Д.) Уже слишком много для обработки. Почему вы хотите, чтобы я больше страдал :-(Мы можем легко преобразовать массив в ArrayList
. Мы используем addAll()
метод интерфейса Collection для копирования содержимого из одного списка в другой.
Arraylist arr = new Arraylist();
arr.addAll(Arrays.asList(asset));
ArrayList
конструкторов принимает ? extends Collection<T>
аргумент, делая вызов addAll
избыточным. Если массив имеет примитивный тип, данные ответы не будут работать. Но начиная с Java 8 вы можете использовать:
int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());
char
массивом. Уже каждый предоставил достаточно хороший ответ для вашей проблемы. Теперь из всех предложений, вам нужно решить, что будет соответствовать вашим требованиям. Есть два типа коллекций, которые вам нужно знать. Один - это немодифицированная коллекция, а другая - коллекция, которая позволит вам позже изменить объект.
Итак, здесь я приведу краткий пример для двух вариантов использования.
Создание неизменной коллекции :: Когда вы не хотите изменять объект коллекции после создания
List<Element> elementList = Arrays.asList(array)
Создание изменяемой коллекции :: Когда вы можете захотеть изменить созданный объект коллекции после создания.
List<Element> elementList = new ArrayList<Element>(Arrays.asList(array));
List
возвращаемое значение Arrays.asList
является просто оберткой над исходным массивом и позволяет отдельным элементам получать доступ и изменять их с помощью get
и set
. Вы, вероятно, должны уточнить, что вы имеете в виду «не добавлять и не удалять элементы» вместо «неизменяемый», что означает вообще не изменять. Используйте следующий код для преобразования массива элементов в ArrayList.
Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element>elementArray=new ArrayList();
for(int i=0;i<array.length;i++) {
elementArray.add(array[i]);
}
Используйте код ниже
Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> list = (ArrayList) Arrays.asList(array);
ArrayList
. Афиша специально просила об этом.