Как я могу добавить в список<? расширяет число> структур данных?

Question

Как я могу добавить в список<? расширяет число> структур данных?

У меня есть список, который объявлен так:

 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)

183

java generics

Источник

user82368 05 май '10 в 21:38

8 ответов

Решение

Вы не можете (без небезопасных бросков). Вы можете только читать из них.

Проблема в том, что вы не знаете, что именно представляет собой список. Это может быть список любого подкласса Number, поэтому, когда вы пытаетесь поместить в него элемент, вы не знаете, что этот элемент в действительности помещается в список.

Например, список может быть списком Bytes, поэтому было бы ошибкой поставить Float внутрь.

20

Источник

user149392 05 май '10 в 21:39

Меня это смущало, хотя я читаю здесь ответы, пока не нашел комментарий Павла Минаева:

Обратите внимание, что список не означает "список объектов разных типов, каждый из которых расширяет Number". Это означает "список объектов одного типа, который расширяет число"

После этого я смог понять BertF потрясающее объяснение. Список значит? может иметь любой тип, расширяющий Number(Integer, Double и т. д.), и он не указан в объявлении ( List ) того, что это из них, поэтому, когда вы хотите использовать метод add, он не известен, если ввод того же типа или нет; какой тип вообще?

Итак, элементы List можно установить только при построении.

Также обратите внимание на следующее: когда мы используем шаблоны, мы сообщаем компилятору, с каким типом мы связываемся. T, например, держит этот тип для нас, но не ? делает то же самое

Я должен сказать.. Это один из грязных, чтобы объяснить / узнать

4

Источник

user6094503 16 окт '18 в 23:49

Вы могли бы сделать это вместо этого:

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

3

Источник

user180516 05 май '10 в 21:48

"List '<'? Extends Number> на самом деле является подстановочным знаком верхней границы!

Подстановочный знак, ограниченный сверху, говорит о том, что любой класс, который расширяет число или число, сам по себе может использоваться в качестве формального типа параметра: проблема связана с тем фактом, что Java не знает, что такое тип List на самом деле. Это должен быть ТОЧНЫЙ и УНИКАЛЬНЫЙ тип. Я надеюсь, что это помогает:)

3

Источник

user8549555 13 мар '18 в 13:38

Вы можете обмануть его, создав ссылку на список другого типа.

(Это "небезопасные приведения", упомянутые 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")

1

Источник

user99777 24 июл '20 в 22:32

Где расширить список из 'Object', вы можете использовать list.add, а когда хотите использовать list.get, нужно только привести Object к вашему Object;

0

Источник

user1718223 28 окт '18 в 05:34

Поскольку 3 является примитивом (int), который не расширяет Number, вы можете добавить его упакованный тип (Integer.valueOf(3)). Хотя в IDEA он отображается как ошибка, он все равно может выполняться в обычном режиме.

0

Источник

01 авг '21 в 14:08

Другие вопросы по тегам java generics

user11296 05 май '10 в 22:48 2010-05-05 22:48 · Accepted Answer · 2010-05-05 22:48

Извините, но вы не можете.

Объявление подстановочного знака 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 так как foo3 может указывать на List<Double>,
Вы не можете добавить Double так как foo3 может указывать на List<Integer>,
Вы не можете добавить Number так как foo3 может указывать на List<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>