Generici Java con più parametri

Question

Ho visto esempi sul sito che si occupano di generici con più parametri ma nessuno che funzioni per la mia situazione.

Quindi, ecco l'accordo: sto cercando di imparare i generici Java e ho deciso di creare una semplice funzione di utilità di ricerca di array binario. Lo sto testando usando oggetti personalizzati e interi. Per ottenere feedback su errori e avvertenze sto usando Eclipse. Ecco cosa ho:

public static int binarySearch(Comparable[] array, Comparable item, int start, int end) { 
    if(end < start) { 
     return -1; 
    } 
    int mid = (start + end)/2; 
    if(item.compareTo(array[mid]) > 0) { 
     return binarySearch(array, item, mid + 1, end); 
    } else if(item.compareTo(array[mid]) < 0) { 
     return binarySearch(array, item, start, mid - 1); 
    } else { 
     return mid; 
    } 
} 

Quindi ovviamente ricevo gli avvisi per i tipi di Raw che dicono che i generici devono essere parametrizzati. Come posso farlo correttamente dato che ho più parametri che entrambi devono essere dello stesso tipo?

SOLUZIONE

Ecco la soluzione di lavoro utilizzando farmaci generici con il corretto controllo dei parametri:

public static <T extends Comparable<? super T>> int binarySearch(T[] array, T item, int start, int end) { 
    if(array.length == 0) { 
     return -1; 
    } 
    if(item == null) { 
     return -1; 
    } 
    if(start < 0) { 
     return -1; 
    } 
    if(end < start) { 
     return -1; 
    } 
    int mid = (start + end)/2; 
    if(item.compareTo(array[mid]) > 0) { 
     return binarySearch(array, item, mid + 1, end); 
    } else if(item.compareTo(array[mid]) < 0) { 
     return binarySearch(array, item, start, mid - 1); 
    } else { 
     return mid; 
    } 
} 

Answer 1

è possibile specificare specifica funzione parametro generico in questo modo

public static <T extends Comparable<? super T>> int binarySearch(T[] arr,T elem,int start,int end){ 
    //... 
} 

Answer 2

Questo è il tipico modo per creare funzioni generiche:

public static <T extends Comparable<? super T>> int binarySearch(T[] array, T item, int start, int end) { ... } 

Per extra generalità, item non hanno di essere dello stesso tipo le cose nella matrice sono, e le cose nella matrice non hanno essere Comparable dal momento che non li sta confrontando per niente, quindi

public static <T> int binarySearch(T[] array, Comparable<T> item, int start, int end) { ... } 

dà una maggiore flessibilità.