В чем разница между
1.List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); //copy
2.List<Integer> list2 = Arrays.asList(ia);
где ИА
- это массив целых чисел.
Я пришел, чтобы знать, что некоторые операции не допускаются в список2`. почему это так? как она хранится в памяти (ссылки / копия)?
Когда я тасовать списки "список 1" Не'т повлиять на исходный массив, но список2 вовсе. Но еще список2-это несколько смущает.
Как ArrayList с собой upcasted в список отличается от создания новой коллекции`
list1 differs from (1)
ArrayList<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));
Массивы.asList(НМА)
Она принимает массив " иа " и создает оболочку, которая реализует список в <число> У
, что делает исходный массив доступен список. Ничего не копируется и все, только один объект-оболочку создается. Операции на обертке списка распространяются на оригинальный массив. Это означает, что если вы потрете фантик список, исходный массив, а также тасуется, если вы перезаписать элемент, он получает перезаписаны в исходном массиве, и т. д. Конечно, некоторые операции список
не'т позволил на обертке, такие как добавление или удаление элементов из списка, вы можете только прочитать или перезаписать элементы.
Обратите внимание, что фантик список не'т выразить коллекции
- это'с другой вид объекта. `Коллекции есть свой собственный, внутренний массив, в котором они хранят свои элементы, и можете изменять размер внутренних массивов и т. д. Фантик не'т иметь свой собственный внутренний массив, он распространяется только операции к массиву дано ему.
новый ArrayList и Л;целое>(массивов.asList(НМА))
затем вы создаете новый ArrayList С, которая является полноценной, независимой копия оригинала. Хотя здесь можно создать оболочку с помощью массивов.asList также, он используется только при строительстве новой коллекции и будет собран "мусор" после. Структура этой новой коллекции является полностью независимой от исходного массива. Он содержит те же элементы (как исходный массив и новый
коллекции` ссылаются на один целых чисел в памяти), но он создает новый, внутренний массив, который содержит ссылки. Так что если вы потрете его, добавлять, удалять элементы и т. п., исходный массив остается неизменным.
Ну это потому, что коллекции
в результате массивы.asList()
это не типа Java.утиль.Класса ArrayList
. Массивы.asList()
создает коллекции
типа Java.утиль.Массивы$ArrayList с которым не продлит
Ява.утиль.Класса ArrayListа только расширяет
Ява.утиль.AbstractList`
List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); //copy
В этом случае "список 1" имеет тип коллекции
.
List<Integer> list2 = Arrays.asList(ia);
Вот, список возвращается как список
, т. е. он есть только методы, прикрепленные к этому интерфейсу. Следовательно, почему некоторые методы не пускают на список2
.
ArrayList<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));
Здесь вы создаете новую коллекции
. Вы'вэ просто передает это значение в конструкторе. Это не пример литья. В литье, это может выглядеть примерно так:
ArrayList list1 = (ArrayList)Arrays.asList(ia);
Я довольно поздно здесь все равно чувствовал объяснение с доком ссылки будут лучше для тех, кто ищет ответ.
общественного класса ArrayList() - //возвращает ArrayList с мощностью по умолчанию 10
публичные коллекции(коллекция<? выходит е> с)
общественного класса ArrayList(тип int initialCapacity)
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.List<String> namesList = Arrays.asList(names);
или
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.List<String> temp = Arrays.asList(names);
Вышеуказанное заявление добавляет обертку от входного массива. Поэтому такие методы, как добавить & удаление не будет распространяться на ссылку список объектов 'namesList'.
Если вы попытаетесь добавить элемент в существующий массив/список, то вы получите и"; Главное " исключение в потоке" и Ява.яз.Возникновению unsupportedoperationexception-то".
Описанная выше операция readonly или viewonly. <БР> мы выполнить не можем добавить или удалить операцию в список объектов. Но
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.ArrayList<String> list1 = new ArrayList<>(Arrays.asList(names));
или
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.List<String> listObject = Arrays.asList(names);
java.util.ArrayList<String> list1 = new ArrayList<>(listObject);
В вышеупомянутом заявлении вы создали конкретный экземпляр класса ArrayList и передал список в качестве параметра.
В этом случае метод Add &ампер; удалить будет работать должным образом, как методы из класс ArrayList так вот мы выиграли'т получить любую возникновению unsupportedoperationexception. Изменения, внесенные в объект класса ArrayList (способ добавить или удалить элемент из списка ArrayList) вы не отражать в исходный Java.утиль.Объект списка.
String names[] = new String[] {
"Avinash",
"Amol",
"John",
"Peter"
};
java.util.List < String > listObject = Arrays.asList(names);
java.util.ArrayList < String > list1 = new ArrayList < > (listObject);
for (String string: list1) {
System.out.print(" " + string);
}
list1.add("Alex"); //Added without any exception
list1.remove("Avinash"); //Added without any exception will not make any changes in original list in this case temp object.
for (String string: list1) {
System.out.print(" " + string);
}
String existingNames[] = new String[] {
"Avinash",
"Amol",
"John",
"Peter"
};
java.util.List < String > namesList = Arrays.asList(names);
namesList.add("Bob"); // UnsupportedOperationException occur
namesList.remove("Avinash"); //UnsupportedOperationException
В первую очередь класс массивы-это служебный класс, который содержит. полезных методов для работы с массивами (благодаря массивы класса, в противном случае нам пришлось бы создавать наши собственные методы, чтобы действовать на массив объектов)
asList метод является одним из методов полезность
массивкласса ,статический метод, поэтому мы можем вызвать этот метод по имени класса (как массивы.asList(т...а)
)массив
объект(так что теперь после использования asList метод, две ссылки на существующие
массив` создается объект)список
объект , не может работать на этом массиве объекта, используя "список" ссылка
например, размер массива фиксированной длины, поэтому вы, очевидно, не может добавить или удалить элементы из массив
, используя этот "список" ссылок (как список.добавить(10) " или " список.удалить(10); другое его бросит unsupportedoperationexception)В первом случае вы создаете новый ArrayList с объектом (во 2-м случае только ссылку на существующий массив объект создан, но не новый коллекции
объект) ,так что теперь есть два разных объекта в списке-выбора объекта, а другой
коллекциипредмет и никакой связи между ними ( изменение одного объекта не будут отражены/пострадавшим в другой объект ( то есть в случае 2
Времяи
коллекции` это разные объекты)
Integer [] ia = {1,2,3,4};
System.out.println("Array : "+Arrays.toString(ia));
List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); // new ArrayList object is created , no connection between existing Array Object
list1.add(5);
list1.add(6);
list1.remove(0);
list1.remove(0);
System.out.println("list1 : "+list1);
System.out.println("Array : "+Arrays.toString(ia));
Integer [] ia = {1,2,3,4};
System.out.println("Array : "+Arrays.toString(ia));
List<Integer> list2 = Arrays.asList(ia); // creates only a (new ) List reference to existing Array object (and NOT a new ArrayList Object)
// list2.add(5); // it will throw java.lang.UnsupportedOperationException - invalid operation (as Array size is fixed)
list2.set(0,10); // making changes in existing Array object using List reference - valid
list2.set(1,11);
ia[2]=12; // making changes in existing Array object using Array reference - valid
System.out.println("list2 : "+list2);
System.out.println("Array : "+Arrays.toString(ia));
Обратите внимание, что в Java 8, 'ИА' выше должно быть целое число [], а не int[]. Массивы.asList() массива int возвращает список с одним элементом. При использовании ОП'фрагмент кода с, компилятор будет отлавливать проблему, но некоторые методы (например, коллекций.перетасовать()) просто не будет делать то, что вы ожидаете.
package com.copy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class CopyArray {
public static void main(String[] args) {
List<Integer> list1, list2 = null;
Integer[] intarr = { 3, 4, 2, 1 };
list1 = new ArrayList<Integer>(Arrays.asList(intarr));
list1.add(30);
list2 = Arrays.asList(intarr);
// list2.add(40); Here, we can't modify the existing list,because it's a wrapper
System.out.println("List1");
Iterator<Integer> itr1 = list1.iterator();
while (itr1.hasNext()) {
System.out.println(itr1.next());
}
System.out.println("List2");
Iterator<Integer> itr2 = list2.iterator();
while (itr2.hasNext()) {
System.out.println(itr2.next());
}
}
}
Массивы.asList()
этот метод возвращает собственную реализацию списка.Она принимает массив в качестве аргумента и построения методов и атрибутов на нем, так как это не копирование каких-либо данных из массива, но с использованием исходного массива это вызывает изменения в исходный массив при изменении списка возвращаемых массивов.asList()
метод.
с другой стороны.<БР>
Коллекции(Массивы.asList());
это конструктор из коллекциикласс, который принимает список в качестве аргумента и возвращает
коллекции, который является независимым от списка т. е.
Массивы.asList () в этом случае передается в качестве аргумента.
вот почему вы видите эти результаты;
Многие люди уже ответили на механические детали, но это's стоит отметить: Это плохой выбор дизайна, с помощью Java.
Ява's метод asList
описана как "возвращает фиксированного размера список...и". Если вы берете его результат и звонить (допустим).добавить метод, он выдает
возникновению unsupportedoperationexception. Это нелогично поведение! Если метод возвращает список, стандартное ожидание, что он возвращает объект, который поддерживает методы интерфейса list``. Разработчик должен'т придется запоминать *что* из многочисленных
утиль.Методы списка "создать" списка, что Дон'т действительно поддерживают все методы список
.
Если они назвали asImmutableList метод, оно имело бы смысл. Или если они только что метод возвращает фактическое "список" (копию и вспомогательного массива), это имело бы смысл. Они решили в пользу, как во время выполнения производительности и короткие имена, за счет нарушает принцип наименьшего удивления и доброй О. О. практика избегает возникновению unsupportedoperationexception по.
(Также конструкторы могли сделать ImmutableList интерфейс
, чтобы избежать целый ряд возникновению unsupportedoperationexception это.)
1.List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); //copy
2.List<Integer> list2 = Arrays.asList(ia);
В строке 2, массивы.asList(ИА)
возвращает список
ссылка на внутренний объект класса, определенного в массивы
, который также называют коллекции
, но является закрытым и распространяется только AbstractList. Это означает, что вернулись из
массивы.asList(Айова) - это объект класса отличается от того, что вы получите от нового ArrayList и Л;целое>`.
Вы не можете использовать некоторые операции в строке 2, поскольку внутренний класс внутри массивы
не дают эти методы.
Посмотрите по этой ссылке и посмотреть, что можно сделать с частный внутренний класс: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/Arrays.java#Arrays.ArrayList
Строка 1 создает новую коллекцию ArrayList объект копирования элементов из того, что вы получите от 2 линии. Так что вы можете делать, что угодно, начиная с Явы.утиль.Класса ArrayList` предоставляет все эти методы.
В ответ на некоторые комментарии, задавать вопросы о поведении массивы.asList() начиная с Java 8:
int[] arr1 = {1,2,3};
/*
Arrays are objects in Java, internally int[] will be represented by
an Integer Array object which when printed on console shall output
a pattern such as
[I@address for 1-dim int array,
[[I@address for 2-dim int array,
[[F@address for 2-dim float array etc.
*/
System.out.println(Arrays.asList(arr1));
/*
The line below results in Compile time error as Arrays.asList(int[] array)
returns List<int[]>. The returned list contains only one element
and that is the int[] {1,2,3}
*/
// List<Integer> list1 = Arrays.asList(arr1);
/*
Arrays.asList(arr1) is Arrays$ArrayList object whose only element is int[] array
so the line below prints [[I@...], where [I@... is the array object.
*/
System.out.println(Arrays.asList(arr1));
/*
This prints [I@..., the actual array object stored as single element
in the Arrays$ArrayList object.
*/
System.out.println(Arrays.asList(arr1).get(0));
// prints the contents of array [1,2,3]
System.out.println(Arrays.toString(Arrays.asList(arr1).get(0)));
Integer[] arr2 = {1,2,3};
/*
Arrays.asList(arr) is Arrays$ArrayList object which is
a wrapper list object containing three elements 1,2,3.
Technically, it is pointing to the original Integer[] array
*/
List<Integer> list2 = Arrays.asList(arr2);
// prints the contents of list [1,2,3]
System.out.println(list2);
Итог разница
когда список создается без использования новых массивов оператора.asList() способ вернуть оболочку, которая означает
1. можно выполнять операции добавления/обновления.
2. изменения, внесенные в исходный массив, будут отражены в списке так же и наоборот.