У меня есть массив, который инициализируется следующим образом:
Element[] array = {new Element(1), new Element(2), new Element(3)};
Я хотел бы преобразовать этот массив в объект класса ArrayList.
ArrayList<Element> arraylist = ???;
new ArrayList<>(Arrays.asList(array))
Дано:
Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };
Самый простой ответ это делать:
List<Element> list = Arrays.asList(array);
Это будет работать нормально. Но некоторыми оговорками:
коллекции
. В противном случае вы'll получить для себя возникновению unsupportedoperationexception`.asList()
опирается на исходный массив. Если вы измените исходный массив, список будет изменен, а также. Это может быть удивительно. <суп>(старый нить, но только 2 цента как никто не упоминал гуавы или других библиотек и некоторые другие детали) в</SUP-серфинг>
Это's стоит отметить гуава способом, что значительно упрощает эти махинации:
Использование ##
Используйте ImmutableList
класс и и()
и копия()
методами фабрики <суп>(элементы могут'т быть null)</суп>:
List<String> il = ImmutableList.of("string", "elements"); // from varargs
List<String> il = ImmutableList.copyOf(aStringArray); // from array
Используйтесписки
]4 класс и 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
Также обратите внимание на аналогичные методы для других структур данных в другие классы, например, в наборы
.
Главной достопримечательностью может быть, чтобы уменьшить беспорядок из-за дженерики для безопасности типа, так как использование гуавы фабричные позволяют видах должно быть выведено большую часть времени. Однако, этот аргумент имеет меньше воды, начиная с Java 7 прибыл с новым оператором Алмаз.
Но это's не единственная причина (и Java 7 это'т везде пока): сокращенный синтаксис тоже очень удобно, и методы, инициализаторы, как показано выше, позволяют писать более выразительный код. Вы в одном гуава назвать то, что за 2 с текущими коллекциями Java.
Используйте версию JDK'ы массивы
класс и asList()
метод фабрики, завернутый с коллекции .unmodifiableList()
:
List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));
Обратите внимание, что возвращаемый тип для asList()является
списокс помощью осуществления конкретной
коллекции, но **не**
Ява.утиль.Класса ArrayList. Это'с внутренним типом, который эмулирует
коллекции`, но на самом деле напрямую ссылается на массив и делает ее "писать" По (изменения отражены в массиве).
Он запрещает изменения через некоторые из списка
АПИ'ы методов путем простого расширения AbstractList
(таким образом, добавляя или удаляя элементы не поддерживаются), но позволяет делать звонки набор () переопределять элементы. Таким образом, этот список вовсе'т-настоящему непреложное и в asList () должны быть обмотаны коллекций.unmodifiableList()
.
Увидеть следующий шаг, если вам нужен изменяемый список.
Как и выше, но завернутый с Ява.утиль.Класса 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<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));
Начиная с Java 5, `массивы.asList () принимает параметр varargs и вы Don'т иметь, чтобы явно построить массив.
new ArrayList<T>(Arrays.asList(myArray));
Убедитесь, что myArray
имеет тот же тип, что и T
. Вы'получите ошибку компилятора, если попытаетесь создать List<Integer>
из массива int
, например.
Другой способ (хотя по сути эквивалентно новый ArrayList(массивов.asList(массив)) производительность-мудрое решение:
Collections.addAll(arraylist, array);
В Ява 9 Вы можете использовать список.в
статический метод фабрики, чтобы создать список литералов. Что-то вроде следующего:
List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));
Это позволит вернуть неизменяемые список, содержащий три элемента. Если вы хотите Мутабельный список, передать этот список в коллекции
конструктора:
new ArrayList<>(List.of(// elements vararg))
Сеп 269 приводятся некоторые удобные методы фабрики для коллекций Java интерфейс API. Эти неизменные статические методы фабрики построены в "список", С
и "карта" интерфейсы в Java 9 и позже.
Еще одно обновление, почти конец 2014 года, вы можете сделать это с Java 8 тоже:
ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));
Несколько персонажей будут сохранены, если это может быть просто "список"
List<Element> list = Stream.of(myArray).collect(Collectors.toList());
Если вы используете :
new ArrayList<T>(Arrays.asList(myArray));
вы мая создать и заполнить два списка ! Заполняя два раза большой список-это именно то, что вы Don'т хотите, чтобы сделать, потому что будет создан еще один объект[]` массив каждый раз, когда возможностей должен быть продлен.
К счастью, реализация JDK-это массивы и быстро.asList(а[])
очень хорошо сделано. Это создать некую коллекцию именованных массивов.Класса ArrayList, где объект[] точек данных непосредственно в массив.
// 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, вы можете создать другой независимый коллекции с :
new ArrayList<T>(Arrays.asList(myArray));
Я люблю использовать "коллекции", массивы
, или гуава. Но если это не'т подходят, или вы не'т чувствую это, просто написать еще один безвкусный линии вместо.
В языке 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));
Однако он's лучше всегда использовать интерфейс:
List<Element> arraylist = Arrays.<Element>asList(array);
Вы можете конвертировать с помощью различных методов
Список<элемент> Список = массивов.asList(массив);
Список<элемент> Список = новый ArrayList(); Коллекции.методы addall(список, массив);
Список класса ArrayList = новый ArrayList(); список.методы addall(массивов.asList(массив));`
Для более подробной информации вы можете обратиться к http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html
как все сказали, что это не так
new ArrayList<>(Arrays.asList("1","2","3","4"));
и общий новейший способ, чтобы создать массив observableArrays
ObservableList: список, который позволяет слушателям отслеживать изменения, когда они происходят.
для Java SE можно попробовать
FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));
то есть по данным Оракул документы
observableArrayList() Создает новый пустой заметный список, который поддерживается ArrayList. observableArrayList(е... элементов) Создает новый список наблюдаемых массив с элементы, добавленные к нему.
также в Java 9 Это's немного проще:
List<String> list = List.of("element 1", "element 2", "element 3");
Начиная с Java 8 есть более простой способ для преобразования:
public static <T> List<T> fromArray(T[] array) {
return Arrays.stream(array).collect(toList());
}
открытые статические и л;т> Список<Т> asList(т а) //с varargs имеют тип T.
Таким образом, вы можете инициализировать коллекции
, как это:
Список<элемент> класса ArrayList = массивов.asList(новый элемент(1) новый элемент(2) новый элемент(3));
* Примечание: каждый новый элемент(инт аргументы) будет рассматриваться как отдельный объект и может быть передан как
ВАР-аргументы
.
публичный статический <П> логические методы addall(коллекция<? супер Т> с, т... а); Итак, этот код тоже полезно это делать
Коллекции.методы addall(ArrayList, в массиве);
Еще один простой способ-добавить все элементы из массива в новый ArrayList, используя для каждой петли.
ArrayList<Element> list = new ArrayList<>();
for(Element e : array)
list.add(e);
Если массив примитивного типа, ответы выиграл'т работу. Но начиная с Java 8 вы можете использовать:
int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());