Tipi e prestazioni non elaborati

Question

Nella pagina 140 di Java efficace si consiglia che una firma di metodo con un carattere jolly sia preferibile a una con un parametro di tipo che viene visualizzato solo una volta. Ad esempio,

public static void swap(List<?> list, int i, int j) 

è preferibile

public static <T> void swap(List<T> list, int i, int j) 

Tuttavia non è possibile impostare un elemento di un List<?> essere nulla (tranne null) in modo efficace Java suggerisce scrivendo un metodo di supporto privato a fare la firma con un lavoro con caratteri jolly.

private static <T> void swapHelper(List<T> list, int i, int j) { 
    list.set(i, list.set(j, list.get(i))); 
} 

public static void swap(List<?> list, int i, int j) { 
    swapHelper(list, i, j); 
} 

Comunque ho guardato il codice sorgente per Collections.swap e abbiamo scoperto che il modo in cui hanno ottenuto intorno al problema List<?> era quello di utilizzare tipi prime.

public static void swap(List<?> list, int i, int j) { 
    final List l = list; 
    l.set(i, l.set(j, l.get(i))); 
} 

ci viene consigliato di non utilizzare i tipi di prime nel nuovo codice (tranne che in instanceof controlli). Quindi, vorrei sapere qual è la ragione qui? Esiste un vantaggio in termini di prestazioni nell'utilizzare i tipi non elaborati qui piuttosto che chiamare un metodo di supporto privato? In caso contrario, esistono esempi in cui l'utilizzo di tipi non elaborati può migliorare le prestazioni?