List <에 추가하려면 어떻게해야합니까? 숫자> 데이터 구조를 확장합니까?

다음과 같이 선언 된 목록이 있습니다.

 List<? extends Number> foo3 = new ArrayList<Integer>();

foo3에 3을 추가하려고했습니다. 그러나 다음과 같은 오류 메시지가 나타납니다.

The method add(capture#1-of ? extends Number) in the type List<capture#1-of ?
extends Number> is not applicable for the arguments (ExtendsNumber)

미안하지만 할 수 없습니다.

와일드 카드 선언은 List<? extends Number> foo3변수 foo3가 특정 유형의 값이 아닌 유형 패밀리의 모든 값을 보유 할 수 있음을 의미합니다 . 이는 다음 중 하나가 법적 과제임을 의미합니다.

List<? extends Number> foo3 = new ArrayList<Number>;  // Number "extends" Number
List<? extends Number> foo3 = new ArrayList<Integer>; // Integer extends Number
List<? extends Number> foo3 = new ArrayList<Double>;  // Double extends Number

따라서, List foo3위의 가능한 ArrayList할당 후에 합법적 인 객체 유형을 추가 할 수 있습니다 .

• 에서를 가리킬 수 Integer있기 때문에를 추가 할 수 없습니다 .foo3List<Double>
• 에서를 가리킬 수 Double있기 때문에를 추가 할 수 없습니다 .foo3List<Integer>
• 에서를 가리킬 수 Number있기 때문에를 추가 할 수 없습니다 .foo3List<Integer>

List<? extends T>어떤 종류의 객체 List가 실제로 가리키는 지 보장 할 수 없기 때문에 객체를 추가 할 수 없으므로 객체가 해당 객체에서 허용되는지 보장 할 수 없습니다 List. 유일한 "보증인"은 오직 그것으로부터 만 읽을 수 있고의 T또는 서브 클래스를 얻게된다는 것 입니다 T.

역 논리가 super예를 들어에 적용됩니다 List<? super T>. 이들은 합법적입니다.

List<? super Number> foo3 = new ArrayList<Number>; // Number is a "super" of Number
List<? super Number> foo3 = new ArrayList<Object>; // Object is a "super" of Number

당신은 특정 유형 T (예 : 읽을 수없는 Number에서) List<? super T>당신이 종류의 것을 보장 할 수 없기 때문에 List정말 가리키는됩니다. 당신이 가진 유일한 "보증인"은 당신이 지적한리스트의 무결성을 침해하지 않고 타입의 값 T(또는 서브 클래스 T) 을 추가 할 수 있다는 것입니다.

이것의 완벽한 예는 다음에 대한 서명입니다 Collections.copy().

public static <T> void copy(List<? super T> dest,List<? extends T> src)

src목록 선언 extends이 관련 목록 유형의 패밀리에서 목록을 전달하고 T 유형의 값 또는 T의 서브 클래스를 생성하도록 보장 하는 방법에 주목하십시오 . 그러나 src목록에 추가 할 수는 없습니다 .

dest목록 선언 용도 super나 관련 목록 유형의 가족에서 모든 목록을 전달할 수 있도록하고 아직도 내가 그 목록에 특정 유형 T의 값을 쓸 수 있습니다 보장합니다. 그러나 목록에서 읽으면 특정 유형 T 의 값을 읽을 수는 없습니다 .

이제 제네릭 와일드 카드 덕분에 단일 메소드로 이러한 호출을 수행 할 수 있습니다.

// copy(dest, src)
Collections.copy(new ArrayList<Number>(), new ArrayList<Number());
Collections.copy(new ArrayList<Number>(), new ArrayList<Integer());
Collections.copy(new ArrayList<Object>(), new ArrayList<Number>());
Collections.copy(new ArrayList<Object>(), new ArrayList<Double());

이 혼란스럽고 넓은 코드를 고려하여 뇌를 운동 시키십시오. 주석 처리 된 행은 불법이며 그 이유는 행의 맨 오른쪽에 표시됩니다 (일부 항목을 보려면 스크롤해야 함).

  List<Number> listNumber_ListNumber  = new ArrayList<Number>();
//List<Number> listNumber_ListInteger = new ArrayList<Integer>();                    // error - can assign only exactly <Number>
//List<Number> listNumber_ListDouble  = new ArrayList<Double>();                     // error - can assign only exactly <Number>

  List<? extends Number> listExtendsNumber_ListNumber  = new ArrayList<Number>();
  List<? extends Number> listExtendsNumber_ListInteger = new ArrayList<Integer>();
  List<? extends Number> listExtendsNumber_ListDouble  = new ArrayList<Double>();

  List<? super Number> listSuperNumber_ListNumber  = new ArrayList<Number>();
//List<? super Number> listSuperNumber_ListInteger = new ArrayList<Integer>();      // error - Integer is not superclass of Number
//List<? super Number> listSuperNumber_ListDouble  = new ArrayList<Double>();       // error - Double is not superclass of Number


//List<Integer> listInteger_ListNumber  = new ArrayList<Number>();                  // error - can assign only exactly <Integer>
  List<Integer> listInteger_ListInteger = new ArrayList<Integer>();
//List<Integer> listInteger_ListDouble  = new ArrayList<Double>();                  // error - can assign only exactly <Integer>

//List<? extends Integer> listExtendsInteger_ListNumber  = new ArrayList<Number>(); // error - Number is not a subclass of Integer
  List<? extends Integer> listExtendsInteger_ListInteger = new ArrayList<Integer>();
//List<? extends Integer> listExtendsInteger_ListDouble  = new ArrayList<Double>(); // error - Double is not a subclass of Integer

  List<? super Integer> listSuperInteger_ListNumber  = new ArrayList<Number>();
  List<? super Integer> listSuperInteger_ListInteger = new ArrayList<Integer>();
//List<? super Integer> listSuperInteger_ListDouble  = new ArrayList<Double>();     // error - Double is not a superclass of Integer


  listNumber_ListNumber.add(3);             // ok - allowed to add Integer to exactly List<Number>

  // These next 3 are compile errors for the same reason:
  // You don't know what kind of List<T> is really
  // being referenced - it may not be able to hold an Integer.
  // You can't add anything (not Object, Number, Integer,
  // nor Double) to List<? extends Number>      
//listExtendsNumber_ListNumber.add(3);     // error - can't add Integer to *possible* List<Double>, even though it is really List<Number>
//listExtendsNumber_ListInteger.add(3);    // error - can't add Integer to *possible* List<Double>, even though it is really List<Integer>
//listExtendsNumber_ListDouble.add(3);     // error - can't add Integer to *possible* List<Double>, especially since it is really List<Double>

  listSuperNumber_ListNumber.add(3);       // ok - allowed to add Integer to List<Number> or List<Object>

  listInteger_ListInteger.add(3);          // ok - allowed to add Integer to exactly List<Integer> (duh)

  // This fails for same reason above - you can't
  // guarantee what kind of List the var is really
  // pointing to
//listExtendsInteger_ListInteger.add(3);   // error - can't add Integer to *possible* List<X> that is only allowed to hold X's

  listSuperInteger_ListNumber.add(3);      // ok - allowed to add Integer to List<Integer>, List<Number>, or List<Object>
  listSuperInteger_ListInteger.add(3);     // ok - allowed to add Integer to List<Integer>, List<Number>, or List<Object>

안전하지 않은 캐스트 없이는 할 수 없습니다. 그들 에게서만 읽을 수 있습니다.

문제는 목록이 정확히 무엇인지 모르는 것입니다. Number의 하위 클래스 목록 일 수 있으므로 요소를 요소에 넣으려고 할 때 요소가 실제로 목록에 맞는지 알 수 없습니다.

예를 들어 List는 Bytes 의 목록 일 수 있으므로 목록에 넣는 것은 오류가됩니다 Float.

"List '<'? extends Number>는 실제로 상한 와일드 카드입니다!

상한 와일드 카드는 Number 또는 Number 자체를 확장하는 모든 클래스를 공식 매개 변수 유형으로 사용할 수 있다고 말합니다. 문제는 Java가 List 유형이 실제로 어떤 유형인지 알지 못한다 는 사실에서 비롯됩니다 . EXACT 및 UNIQUE 유형이어야합니다. 나는 그것이 도움이되기를 바랍니다 :)

Pavel Minaev의 의견을 찾을 때까지 여기에서 답변을 읽었지만 혼란 스럽습니다.

List <? extends Number>는 "다른 유형의 객체 목록으로, 모두 확장 된 번호"를 의미하지 않습니다. "숫자를 확장하는 단일 유형의 객체 목록"을 의미합니다.

이 후 나는 BertF 굉장한 설명을 이해할 수 있었다. 리스트 <? 확장 번호> 의미? Number (Integer, Double 등)를 확장하는 모든 유형이 될 수 있으며 선언에서 명확하지 않습니다 (List <? extends Number> list). 같은 유형 인지 아닌지; 유형은 무엇입니까?

따라서 List <? extends Number>는 구성 할 때만 설정할 수 있습니다.

또한 이것을 참고하십시오 : 템플릿을 사용할 때 컴파일러에게 어떤 유형을 엉망으로 만들고 있는지 알려줍니다. 예를 들어 T 는 우리를 위해 해당 유형을 보유하지만 그렇지 않습니다 . 동일하게

나는 .. 이것은 설명하고 배우는 더러운 것 중 하나입니다.

대신이 작업을 수행 할 수 있습니다.

  List<Number> foo3 = new ArrayList<Number>();      
  foo3.add(3);

다른 유형의 목록에 대한 참조를 작성하여 퍼지 할 수 있습니다.

(sepp2k에서 언급 한 "안전하지 않은 캐스트"입니다.)

List<? extends Number> list = new ArrayList<Integer>();

// This will not compile
//list.add(100);

// WORKS, BUT NOT IDEAL
List untypedList = (List)list;
// It will let you add a number
untypedList.add(200);
// But it will also let you add a String!  BAD!
untypedList.add("foo");

// YOU PROBABLY WANT THIS
// This is safer, because it will (partially) check the type of anything you add
List<Number> superclassedList = (List<Number>)(List<?>)list;
// It will let you add an integer
superclassedList.add(200);
// It won't let you add a String
//superclassedList.add("foo");
// But it will let you add a Float, which isn't really correct
superclassedList.add(3.141);
// ********************
// So you are responsible for ensuring you only add/set Integers when you have
// been given an ArrayList<Integer>
// ********************

// EVEN BETTER
// If you can, if you know the type, then use List<Integer> instead of List<Number>
List<Integer> trulyclassedList = (List<Integer>)(List<?>)list;
// That will prevent you from adding a Float
//trulyclassedList.add(3.141);

System.out.println("list: " + list);

때문에 untypedList, superclassedList그리고 trulyclassedList단지 참조입니다 list, 당신은 여전히 원래의 ArrayList에 요소를 추가 할 예정입니다.

실제로 (List<?>)위의 예제에서 사용할 필요는 없지만 list주어진 유형에 따라 코드에서 필요할 수 있습니다 .

를 사용 ?하면 함수 위에 이것을 넣을 때까지 컴파일러 경고가 표시됩니다.

@SuppressWarnings("unchecked")

여기서 'Object'에서 목록을 확장하면 list.add를 사용할 수 있으며 list.get을 사용하려면 Object를 Object로 캐스팅하면됩니다.