Contenitore di tipi generici in java

Question

Ho una classe generica Foo<T> e tipi parametrizzati Foo<String> e Foo<Integer>. Ora voglio mettere diversi tipi di parametri in un singolo ArrayList. Qual è il modo corretto di farlo?

Candidate 1:

public class MMM { 
    public static void main(String[] args) { 
     Foo<String> fooString = new Foo<String>(); 
     Foo<Integer> fooInteger = new Foo<Integer>(); 

     ArrayList<Foo<?> > list = new ArrayList<Foo<?> >(); 
     list.add(fooString); 
     list.add(fooInteger); 

     for (Foo<?> foo : list) { 
      // Do something on foo. 
     } 
    } 
} 
class Foo<T> {} 

Candidate 2:

public class MMM { 
    public static void main(String[] args) { 
     Foo<String> fooString = new Foo<String>(); 
     Foo<Integer> fooInteger = new Foo<Integer>(); 

     ArrayList<Foo> list = new ArrayList<Foo>(); 
     list.add(fooString); 
     list.add(fooInteger); 

     for (Foo foo : list) { 
      // Do something on foo. 
     } 
    } 
} 
class Foo<T> {} 

In una parola, è legato alla differenza tra Foo<?> e il tipo grezzo Foo.

Aggiornamento:

Grep Qual è la differenza tra il jolly tipo parametrico illimitata e il tipo crudo? su this link potrebbe essere utile.

Answer 1

List rappresenta un elenco senza parametro di tipo. È un elenco i cui elementi sono di qualsiasi tipo, ad es. gli elementi possono essere di diversi tipi. È praticamente lo stesso di List<Object>.

Nel frattempo, List<?> rappresenta un elenco con un parametro di tipo illimitato. I suoi elementi sono di tipo specifico, ma sconosciuto (prima del runtime). Questi elementi devono essere tutti dello stesso tipo in fase di esecuzione.

Si consiglia di evitare l'utilizzo di tipi non elaborati. La soluzione corretta per il tuo esempio è List<Foo<?>>.

Answer 2

Se si desidera evitare tipi non elaborati, quando possibile. Il modo corretto per farlo sarebbe con
List<Foo<?>>.