Apa perbedaan antara
1.List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); //copy
2.List<Integer> list2 = Arrays.asList(ia);
di mana ia
adalah array bilangan bulat.
Saya datang untuk mengetahui bahwa beberapa operasi yang tidak diperbolehkan dalam list2
. mengapa begitu?
bagaimana itu disimpan di memori (referensi / copy)?
Ketika aku mengocok daftar, list1
doesn't mempengaruhi asli array tapi list2
tidak. Tapi masih list2
agak membingungkan.
Bagaimana ArrayList
menjadi upcasted ke daftar yang berbeda dari menciptakan baru ArrayList
list1 differs from (1)
ArrayList<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));
Array.sebagai daftar(ia)
Dibutuhkan sebuah array ia
dan menciptakan pembungkus yang menerapkan Daftar<Integer>
, yang membuat array asli tersedia sebagai daftar. Tidak ada yang disalin dan semua, hanya satu bungkus objek dibuat. Operasi pada daftar pembungkus yang disebarkan ke array asli. Ini berarti bahwa jika anda mengocok daftar bungkus, asli array dikocok juga, jika anda menimpa sebuah elemen, hal itu akan ditimpa asli array, dll. Tentu saja, beberapa Daftar
operasi aren't diperbolehkan di bungkusnya, seperti menambahkan atau menghapus elemen dari daftar, anda hanya dapat membaca atau menimpa elemen.
Perhatikan bahwa daftar wrapper doesn't memperpanjang ArrayList
- it's berbagai jenis objek. `ArrayList memiliki mereka sendiri, internal array, di mana mereka menyimpan unsur-unsur mereka, dan mampu mengubah ukuran internal array dll. Pembungkus doesn't memiliki internal sendiri array, itu hanya merambat operasi untuk array yang diberikan untuk itu.
new ArrayList
kemudian anda buat baru ArrayList
, yang penuh, independen copy dari yang asli. Meskipun di sini anda membuat pembungkus menggunakan Array.sebagai daftar
juga, itu hanya digunakan selama pembangunan baru ArrayList
dan mengumpulkan sampah setelahnya. Struktur baru ini ArrayList
adalah benar-benar independen dari array asli. Mengandung unsur-unsur yang sama (baik asli array dan ini baru ArrayList
referensi yang sama bilangan bulat dalam memori), tapi itu menciptakan yang baru, internal array, yang memegang referensi. Jadi, ketika anda shuffle itu, menambah, menghapus elemen dll., array asli tidak berubah.
Nah ini adalah karena ArrayList
yang dihasilkan dari Array.sebagai daftar()
adalah bukan dari jenis jawa.util.ArrayList
. Array.sebagai daftar()
menciptakan ArrayList
jenis jawa.util.Array$ArrayList
yang tidak memperpanjang jawa.util.ArrayList
tetapi hanya memperpanjang jawa.util.AbstractList
List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); //copy
Dalam hal ini, list1
adalah jenis ArrayList
.
List<Integer> list2 = Arrays.asList(ia);
Di sini, daftar dikembalikan sebagai Daftar
lihat, yang berarti hanya memiliki metode yang melekat pada antarmuka tersebut. Oleh karena itu mengapa beberapa metode yang tidak diperbolehkan pada list2
.
ArrayList<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));
Di sini, anda membuat baru ArrayList
. Anda're hanya melewati nilai dalam konstruktor. Ini adalah bukan contoh dari pengecoran. Dalam casting, mungkin terlihat lebih seperti ini:
ArrayList list1 = (ArrayList)Arrays.asList(ia);
Saya cukup terlambat di sini, lagian merasa penjelasan dengan doc referensi akan lebih baik bagi seseorang yang mencari jawaban.
public ArrayList() - //kembali arraylist dengan standar kapasitas 10
public ArrayList(Collection<? meluas E> c)
public ArrayList(int initialCapacity)
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.List<String> namesList = Arrays.asList(names);
atau
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.List<String> temp = Arrays.asList(names);
Atas Pernyataan menambahkan pembungkus pada input array. Sehingga metode seperti add & hapus tidak akan berlaku pada daftar referensi objek 'namesList'.
Jika anda mencoba untuk menambahkan sebuah elemen dalam array yang ada/daftar maka anda akan mendapatkan "Terkecuali di thread "main" java.lang.UnsupportedOperationException".
Operasi di atas adalah readonly atau viewonly.
Kami tidak dapat melakukan menambah atau menghapus operasi dalam daftar objek.
Tapi
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.ArrayList<String> list1 = new ArrayList<>(Arrays.asList(names));
atau
String names[] = new String[]{"Avinash","Amol","John","Peter"};
java.util.List<String> listObject = Arrays.asList(names);
java.util.ArrayList<String> list1 = new ArrayList<>(listObject);
Di atas pernyataan yang telah anda buat beton contoh ArrayList kelas dan lulus daftar sebagai parameter.
Dalam hal ini metode add & hapus akan bekerja dengan baik sebagai metode kedua dari ArrayList kelas jadi di sini kita tidak't mendapatkan UnSupportedOperationException. Perubahan yang dibuat dalam Arraylist objek (metode menambah atau menghapus sebuah elemen dari arraylist) akan mendapatkan tidak mencerminkan asli jawa.util.Daftar objek.
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
Pertama-tama Array class adalah sebuah kelas utilitas yang berisi no. utilitas metode untuk beroperasi pada Array (terima kasih untuk Array kelas kalau tidak kita akan memiliki yang dibutuhkan untuk membuat metode sendiri untuk bertindak pada Array benda)
sebagai daftar
metode adalah salah satu utilitas metode Array
kelas ,itu adalah metode statis thats mengapa kita dapat memanggil metode ini dengan nama kelas (seperti Array.sebagai daftar(T...)
)ArrayList
objek, itu hanya mengembalikan Daftar referensi yang ada Array
objek(jadi sekarang setelah menggunakan sebagai daftar
metode, dua referensi yang ada Array
objek yang akan dibuat)Daftar
objek , mungkin TIDAK bekerja pada Array ini objek menggunakan Daftar
seperti referensi
misalnya, Array ukuran tetap panjang, maka anda jelas tidak dapat menambah atau menghapus elemen dari
Arrayobjek menggunakan ini
Daftarreferensi (seperti
daftar.tambahkan(10)atau
daftar.menghapus(10);` yang lain itu akan membuang UnsupportedOperationException)Dalam kasus pertama anda membuat baru Arraylist
objek (dalam kasus 2 hanya referensi ke Array yang ada objek dibuat tapi tidak baru ArrayList
objek) ,jadi sekarang ada dua objek yang berbeda yang satu adalah Array
objek dan yang lainnya adalah ArrayList
objek dan tidak ada hubungan di antara mereka ( sehingga perubahan pada satu objek tidak akan tercermin/terpengaruh dengan objek lain ( yang dalam kasus 2 Array
dan Arraylist
adalah dua objek yang berbeda)
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));
Perhatikan bahwa, dalam Java 8, 'ia' di atas harus Integer[] dan tidak int[]. Array.sebagai daftar() int array mengembalikan sebuah list dengan elemen tunggal. Ketika menggunakan OP's cuplikan kode, compiler akan menangkap masalah, tapi beberapa metode (misalnya Koleksi.shuffle()) diam-diam akan gagal untuk melakukan apa yang anda harapkan.
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());
}
}
}
Array.sebagai daftar()
metode ini mengembalikan implementasi sendiri dari Daftar.Dibutuhkan sebuah array sebagai argumen dan membangun metode dan atribut-atribut di atas itu, karena tidak menyalin data dari sebuah array tetapi menggunakan array asli ini menyebabkan perubahan dalam array asli ketika anda memodifikasi daftar dikembalikan oleh Array.sebagai daftar()
metode.
di sisi lain.
ArrayList(Array.sebagai daftar());
adalah konstruktor dari ArrayList
kelas yang membutuhkan daftar sebagai argumen dan mengembalikan sebuah ArrayList
yang independen dari daftar ie. Array.sebagai daftar()
dalam hal ini dilewatkan sebagai argumen.
itulah mengapa anda melihat hasil ini;
Banyak orang telah menjawab mekanik rincian sudah, tapi itu's dicatat: Ini adalah orang-orang pilihan, oleh Jawa.
Jawa's sebagai daftar
metode didokumentasikan sebagai "Kembali fixed-size daftar...". Jika anda mengambil hasilnya dan call (katakanlah).tambahkan
metode, itu melempar UnsupportedOperationException
. Ini adalah unintuitive perilaku! Jika metode yang mengatakan itu kembali Daftar
, standar harapan adalah bahwa hal itu mengembalikan sebuah objek yang mendukung metode dari interface Daftar
. Pengembang seharusnya't harus menghafal yang dari sekian util.Daftar
metode membuat Daftar yang don't benar-benar mendukung semua
Daftar` metode.
Jika mereka telah bernama metode asImmutableList
, itu akan masuk akal. Atau jika mereka hanya memiliki metode return yang sebenarnya Daftar
(dan menyalin dukungan array), itu akan masuk akal. Mereka memutuskan untuk mendukung runtime-kinerja dan nama pendek, dengan mengorbankan melanggar kedua Prinsip Paling Mengejutkan dan baik-O. O. praktek menghindari `UnsupportedOperationException ini.
(Juga, para desainer mungkin telah membuat antarmuka ImmutableList, untuk menghindari sejumlah besar
UnsupportedOperationException ini.)
1.List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); //copy
2.List<Integer> list2 = Arrays.asList(ia);
Di baris 2, Array.sebagai daftar(ia)
mengembalikan Daftar
referensi dalam kelas objek yang didefinisikan dalam Array
, yang juga disebut ArrayList
tetapi adalah pribadi dan hanya meluas AbstractList
. Ini berarti apa yang kembali dari Array.sebagai daftar(ia) adalah kelas objek yang berbeda dari apa yang anda dapatkan dari
new ArrayList
Anda tidak dapat menggunakan beberapa operasi untuk baris 2 karena dalam kelas private hanya Array
tidak memberikan metode-metode tersebut.
Coba lihat di link ini dan lihat apa yang dapat anda lakukan dengan swasta dalam kelas: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/Arrays.java#Arrays.ArrayList
Baris 1 menciptakan baru ArrayList
objek menyalin elemen dari apa yang anda dapatkan dari baris 2. Sehingga anda dapat melakukan apapun yang anda inginkan karena jawa.util.ArrayList
menyediakan semua metode tersebut.
Dalam menanggapi beberapa komentar yang menanyakan pertanyaan-pertanyaan tentang perilaku [Array.sebagai daftar()](https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList-T... -), karena Jawa 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);
Ringkasan perbedaan -
ketika daftar ini dibuat tanpa menggunakan operator baru Array.sebagai daftar() method ini mengembalikan Pembungkus yang berarti
1. anda dapat melakukan add/update Operasi.
2. perubahan-perubahan yang dilakukan dalam array asli akan tercermin ke Daftar juga dan sebaliknya.