Arrays.asList(array)와 새로운 ArrayList(Arrays.asList(array)의 차이점

Arrays.asList(array)와 새로운 ArrayList(Arrays.asList(array)의 차이점

와의 차이는 무엇입니까?

• List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia)); // Copy

• List<Integer> list2 = Arrays.asList(ia);

서, snowledge.ia수배 ??

일부 작업이 허용되지 않는 것을 알게 되었습니다.list2것은은 왜???모리참 복복 복복 떻떻 떻??

, 「 」가 됩니다.list1어레이에는을 주지 않습니다만, 「」는 을 주지 않습니다.list2한데, 그래도 . 하지만 여전히list2좀 헷갈리네요.

는 어떻게 ?ArrayList은 새로운 것과 ArrayList

list1 differs from (1)
ArrayList<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));

1. 먼저, 이 기능에 대해 살펴보겠습니다.

   Arrays.asList(ia)
   

   은 배열이 하다.ia를 를 작성합니다.List<Integer>그러면 원래 어레이를 목록으로 사용할 수 있습니다.복사되지 않고 래퍼 개체만 하나만 생성됩니다.목록 래퍼의 작업이 원래 어레이로 전파됩니다., 래퍼를 몇 가지, 몇 가지, 몇 가지입니다.List리스트에서 요소를 추가하거나 제거하는 등의 작업은 래퍼에서 허용되지 않습니다. 을 사용법

   확장되지 .ArrayList - 다른 종류의 물건입니다. ArrayList에는 요소를 저장하고 내부 어레이 크기를 조정할 수 있는 자체 내부 어레이가 있습니다.래퍼에는 자체 내부 배열이 없으며 지정된 배열에 작업만 전파됩니다.

2. 한편, 다음에 새로운 어레이를 작성하면,

   new ArrayList<Integer>(Arrays.asList(ia))
   

   해서 새로 예요.ArrayList이치노요.Arrays.asList새로 합니다.ArrayList그 후에는 쓰레기 수거가 됩니다. '의 구조'구조'ArrayList는 원래 어레이와 완전히 독립되어 있습니다.과 이 배열 가 포함되어 있습니다.ArrayList을 이용하다 단, 참조를 유지하는 새로운 내부 배열을 만듭니다.따라서 요소를 셔플, 추가, 삭제해도 원래 배열은 변경되지 않습니다.

이게 뭐냐면ArrayList의 Arrays.asList()이 java.util.ArrayList.

Arrays.asList() 창조하다ArrayList입입 of java.util.Arrays$ArrayList되지 않습니다.java.util.ArrayList는 , " " , " " " 뿐입니다.java.util.AbstractList.

List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));  //copy

「」는,list1은 「」입니다.ArrayList.

List<Integer> list2 = Arrays.asList(ia);

은 is기에에 a a a a a a a a a a a a a로 됩니다.List즉그 interfaceview에 만 있음을 합니다. 일부 는 에서 허용되지 .list2.

ArrayList<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));

여기에서는, 새로운 것을 작성한다.ArrayList컨스트럭터에 값을 전달하고 있을 뿐입니다.이것은 캐스팅의 예가 아닙니다.캐스팅에서는 다음과 같이 보일 수 있습니다.

ArrayList list1 = (ArrayList)Arrays.asList(ia);

답을 찾는 사람에게는 문서 참조와 함께 설명하는 것이 좋습니다.

1. java.displays.어레이

• 이는 지정된 어레이에서 동작하는 정적 메서드 집합이 포함된 유틸리티 클래스입니다.
• asList는 입력 배열을 받아 java.util 개체를 반환하는 정적 메서드 중 하나입니다.Arrays.ArrayList: AbstractList <E>를 확장한 스태틱네스트 클래스입니다.이 클래스는 리스트인터페이스를 실장합니다.
• 따라서 Arrays.asList(inarray)는 입력 배열 주위에 목록 래퍼를 반환하지만 이 래퍼는 java.util입니다.java.util이 아닌 ArrayList.Array List는 동일한 어레이를 참조하기 때문에 List wraped 배열에 요소를 추가하면 원래 어레이에도 영향을 미쳐 길이를 변경할 수 없습니다.

2. java.displays.어레이 리스트

• ArrayList에 오버로드된 컨스트럭터가 다수 있습니다.

   public ArrayList() - // Returns arraylist with default capacity 10
  
   public ArrayList(Collection<? extends E> c)
  
   public ArrayList(int initialCapacity)
  

• 따라서 Arrays.asList가 반환한 오브젝트(즉, List(AbstractList))를 위의 두 번째 컨스트럭터에 전달하면 새로운 다이내믹 어레이가 생성됩니다(이 어레이 사이즈는 용량보다 많은 요소를 추가하면 원래 어레이에 영향을 주지 않습니다). 원래 어레이를 r에 복사하는 것을 의미합니다).참조만 하고 원래 어레이와 동일한 오브젝트 세트를 새로 작성하지 않습니다.)

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

위의 문장은 입력 배열에 래퍼를 추가합니다.따라서 add 및 remove와 같은 메서드는 목록 참조 개체 'namesList'에는 적용되지 않습니다.

기존 배열/목록에 요소를 추가하려고 하면 "Exception in thread "main" java.lang"이 표시됩니다.지원되지 않는 조작예외입니다.

위의 작업은 읽기 전용 또는 보기 전용입니다.
목록 개체에서 추가 또는 제거 작업을 수행할 수 없습니다.

그렇지만

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 클래스의 구체적인 인스턴스를 만들고 목록을 매개 변수로 전달했습니다.

이 경우 두 메서드가 ArrayList 클래스의 메서드이기 때문에 추가 및 삭제 메서드는 정상적으로 동작하므로 UnSupportedOperation을 얻을 수 없습니다.예외.Arraylist 오브젝트(배열목록에서 요소를 추가 또는 삭제하는 방법)에서 이루어진 변경은 원래 java.util에 반영되지 않습니다.리스트 오브젝트

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

우선 Arrays 클래스는 Arrays 클래스에서 동작하는 다수의 유틸리티 메서드를 포함하는 유틸리티 클래스입니다(Arrays 클래스 덕분입니다.그렇지 않으면 어레이 오브젝트에 대응하는 독자적인 메서드를 작성해야 합니다.)

asList() 메서드:

1. asList는 method의 중 입니다.Array를 부를 입니다(클래스 등).Arrays.asList(T...a))
2. 이제 반전이 있습니다.새로운 것이 점에 하시기 바랍니다.ArrayList it. 존존 to to to to to to to to to to to to to to to to to to to to에 대한 List 합니다.Array 현재 후)asList ""에 , ""2""Array오브젝트가 생성됩니다.)
3. ★★★★★★★★★★★★★★★★★★★★★★★★★★★에서 List오브젝트, 이 어레이 오브젝트에서는 동작하지 않을 수 있습니다.List를 들면 예를 들면, 예어들들 for like.Array길이가 되어 있기 에 s 사이즈의 요소를 할 수 .Array 오브젝트를 한 오브젝트List: 조예:list.add(10) ★★★★★★★★★★★★★★★★★」list.remove(10); Unsupported 이 느려집니다.★★★★★★★★★★★★★★★★★★」
4. 하여 수행한 된 목록 참조에 됩니다.Arrayobject (하여 기존 Array )의 " " " ( " " " " " " " " " " s s s s s s " )

번째.Arraylistobject 참조는 되지 않습니다.ArrayList 오브젝트). 오브젝트는 두 오브젝트가 .는 ★★★★★★★★★★★★★★★.Array와 또 은 오른른른른른 object object object이다.ArrayList사이에 한 은 다른을 받지 2의 경우, 다른 오브젝트에 되거나 영향을 받지 않는다).Array ★★★★★★★★★★★★★★★★★」Arraylist입니다) 2개의 오브젝트입니다.

케이스 1:

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

케이스 2:

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 the 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 the existing Array object using the List reference - valid 
list2.set(1,11); 
ia[2]=12;     // Making changes in the existing Array object using the Array reference - valid
System.out.println("list2: " + list2);
System.out.println("Array: " + Arrays.toString(ia));

Java 8에서는 위의 'ia'가 Integer[]가 아니라 Integer[]여야 합니다.int 배열의 arrays.asList()는 단일 요소를 포함하는 목록을 반환합니다.OP의 코드 스니펫을 사용하면 컴파일러가 문제를 검출하지만 일부 메서드(예: 컬렉션)가 검출됩니다.shuffle()은 사용자가 기대하는 것을 자동으로 실행하지 못합니다.

많은 사람들이 이미 기계적인 세부 사항에 대해 답했지만 주목할 필요가 있습니다.Java에 의한 설계 선택은 적절하지 않습니다.

의 ★★★asList메서드는 "고정 크기 목록을 반환합니다.③ 결과를 취합하여 전화(말씀)를 하면.add 메서드, 슬로우링글링글링글링글링글잉글링글링글링글링글링글링글.UnsupportedOperationException건이의의도!에서 반환되는 List '를List개발자는 어떤 umptein을 외울 필요가 없습니다.util.List create " " 입니다.List 것을 입니다.List★★★★★★★★★★★★★★★★★★.

이 그 했다면.asImmutableList 반환 됩니다.List(및 백업 어레이를 복사해 주세요).그게 말이 돼요그들은 최소한의 놀라움이라는 원칙과 회피하는 좋은 객체 지향 관행을 위반하는 대신 런타임 성능과 짧은 이름 모두를 선호하기로 결정했다.UnsupportedOperationExceptions.

가 ('')를 도 있습니다).interface ImmutableList 것을 UnsupportedOperationExceptions).

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

Arrays.asList()

일람표 그을 구축합니다.는 어레이에서 하여 Atribut에서 반환된 하면 원래 됩니다.이는 어레이에서 데이터를 복사하지 않지만 원래 어레이를 사용하면 어레이에 의해 반환된 목록을 수정할 때 원래 어레이가 변경됩니다.Arrays.asList()★★★★★★ 。

반,는ArrayList(Arrays.asList());의 입니다.ArrayList """를 반환하는 ArrayList 즉 「」, 「」, 「」, 「」, 「」, 「」, 「」, 「」,Arrays.asList()이 경우 인수로 간주됩니다.

그래서 이런 결과를 볼 수 있습니다.

1.List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));  //copy
2.List<Integer> list2 = Arrays.asList(ia);

번째 줄에는 '''가 있습니다.Arrays.asList(ia)를 반환하다List에서 정의된 객체의 Arrays '일명 '일명 '일명 '일명'이다' 입니다ArrayList으로, 까지나 확장되어 있습니다.AbstractList은 .이에서 Arrays.asList(ia)라고 하는 것은 클래스 오브젝트입니다.new ArrayList<Integer>.

할 수 . 왜냐하면 2행의 내부 가 있기 입니다.Arrays에서는 이러한 메서드는 제공되지 않습니다.

다음 링크를 참조하여 개인 내부 클래스로 수행할 수 있는 작업을 확인하십시오.http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/Arrays.java#Arrays.ArrayList

에 의해 '1'이 됩니다.ArrayList오브젝트는 2행에서 얻은 요소에서 요소를 복사합니다. 네가 하고 대로 돼.java.util.ArrayList에는 이러한 있습니다.

Java 8 이후 Arrays.asList()의 동작에 대한 몇 가지 질문에 대한 답변:

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

차이의 요약 -

새로운 것을 사용하지 않고 목록을 작성하면 연산자 Arrays.asList() 메서드는 다음을 의미하는 래퍼를 반환합니다.

1. 추가/업데이트 작업을 수행할 수 있습니다.

2. 원래 어레이에서 변경된 내용은 목록에도 반영되며, 그 반대도 마찬가지입니다.

언급URL : https://stackoverflow.com/questions/16748030/difference-between-arrays-aslistarray-and-new-arraylistintegerarrays-aslist