ฉันจะเพิ่มในรายการ <ได้อย่างไร ขยายหมายเลข> โครงสร้างข้อมูลหรือไม่

ฉันมีรายการที่มีการประกาศเช่นนี้:

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

ฉันพยายามเพิ่ม 3 ลงใน foo3 อย่างไรก็ตามฉันได้รับข้อความแสดงข้อผิดพลาดเช่นนี้:

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นั้น เท่านั้น "รับประกัน" คือการที่คุณสามารถอ่านจากมันและคุณจะได้รับหรือเป็นรองTT

ตรรกะกลับนำไปใช้เช่น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เข้าไป

"รายชื่อ '<' ขยายหมายเลข> จริง ๆ แล้วเป็นสัญลักษณ์แทนขอบบน!

wildcard ที่มีขอบเขตด้านบนกล่าวว่าคลาสใด ๆ ที่ขยาย Number หรือ Number สามารถใช้เป็นพารามิเตอร์ชนิดเป็นทางการได้: ปัญหาเกิดขึ้นจากข้อเท็จจริงที่ว่าJava ไม่ทราบว่า Type Listจริงๆคืออะไร ต้องเป็นประเภท EXACT และ UNIQUE ฉันหวังว่ามันจะช่วย :)

มันทำให้ฉันสับสนแม้ว่าฉันจะอ่านคำตอบที่นี่จนกว่าฉันจะพบความคิดเห็นของ Pavel Minaev:

โปรดทราบว่ารายการ <? ขยาย Number> ไม่ได้หมายถึง "รายชื่อวัตถุประเภทต่าง ๆ ซึ่งทั้งหมดนี้จะขยาย Number" มันหมายถึง "รายการวัตถุประเภทเดียวซึ่งขยายจำนวน"

หลังจากนี้ฉันสามารถเข้าใจคำอธิบายที่ยอดเยี่ยมของ BertF รายการ <? ขยายหมายเลข> หมายถึงอะไร อาจเป็นประเภทใดก็ได้ที่มี Number (Integer, Double และอื่น ๆ ) และไม่ถูกทำให้ชัดเจนในการประกาศ (List <? extends Number> รายการ) ที่มันเป็นเช่นนั้นดังนั้นเมื่อคุณต้องการใช้วิธีการเพิ่มประเภทเดียวกันหรือไม่; ประเภทใดบ้าง

ดังนั้นองค์ประกอบของรายการ <? สามารถขยาย Number> ได้เมื่อทำการสร้างเท่านั้น

โปรดทราบสิ่งนี้ด้วย: เมื่อเราใช้เทมเพลตเรากำลังบอกคอมไพเลอร์ว่าเราพิมพ์ข้อความอะไร Tเช่นถือประเภทที่สำหรับเรา แต่ไม่ได้? ทำเช่นเดียวกัน

ฉันต้องบอกว่า .. นี่เป็นหนึ่งในสิ่งสกปรกที่จะอธิบาย / เรียนรู้

คุณสามารถทำสิ่งนี้แทน:

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

คุณสามารถทำให้เหลวไหลได้โดยสร้างการอ้างอิงไปยังรายการที่มีประเภทที่แตกต่างกัน

(นี่คือ "casts ที่ไม่ปลอดภัย" ที่กล่าวถึงโดย 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 ของคุณเท่านั้น