[JAVA]: Uso di Arrays.binarySearch con Comparator

[maurizio2]

Ciao ragazzi, quando uso Arrays.binarySearch() su un array di tipi fondamentali
(int, long etc....) per cercare un elemento che sono sicuro di non trovare
il metodo restituisce l'indice presunto + 1 con segno negativo, per esempio
se l'elemento da me cercato si trovasse nell'indice 2 il metodo
mi restituirebbe -3.
Ecco ma quando uso lo stesso metodo con gli oggetti passando un oggetto
Comparator per l'ordinamento, il metodo mi restituisce l'indice effettivo
dove si dovrebbe trovare l'elemento, nel caso di prima mi restituisce 2
malgrado l'oggetto non sia nella lista, un esempio

import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
/**
 *
 * @author mau2
 */
public class TryArrays {   
    public static void main(String[] args) {        
        Num [] numbers = new Num[4];
        
        numbers[0] = new Num(0);
        numbers[1] = new Num(1);
        numbers[2] = new Num(2);
        numbers[3] = new Num(27);
        
        int [] numInt = new int[3];
        numInt[0] = 1;
        numInt[1] = 2;
        numInt[2] = 4;
        int j = Arrays.binarySearch(numInt, -1);
        int i =  Arrays.binarySearch(numbers, new Num(-1), new NumComparator());
        System.out.println(j);//visualizza - 3, tutto ok
        
        System.out.println(i);//visualizza 1 e non -1 come dovrebbe
                           //numbers[1] ha il membro uguale ad
                           //1 e non -1 come l'oggetto passato
                           //come chiave.
    }   
    public static class NumComparator implements Comparator<Num> {        
        public int compare(TryArrays.Num o1, TryArrays.Num o2) {
            
            if( Integer.parseInt(o1.toString()) < Integer.parseInt(o2.toString())  )
                return -1;
            else if(Integer.parseInt(o1.toString()) < Integer.parseInt(o2.toString()))
                return 1;
            else
                return 0;
        }    
    }
    
    public static class Num{        
        
        private int num;
        public Num(int n){
            num = n;
        }  
        
        public String toString() {
            return String.valueOf(num);
        }        
    }
}

Qualcuno mi dice dove sbaglio, ciao

[LeleFT]

Ho già risposto in PVT, al tuo messaggio, comunque ripeto, dato che il post nel forum è pubblico.
Il metodo compare() è implementato male: non hai invertito gli operandi (o il verso) nell'istruzione if annidata. Corretto qui sotto:

public static class NumComparator implements Comparator<Num> {        
     public int compare(TryArrays.Num o1, TryArrays.Num o2) {
            
         if( Integer.parseInt(o1.toString()) < Integer.parseInt(o2.toString())  )
             return -1;
         else if(Integer.parseInt(o1.toString()) > Integer.parseInt(o2.toString())) // L'errore era qui: avevi messo "minore", ripetendo la condizione di prima
             return 1;
         else
             return 0;
     }    
}

Ciao.

[maurizio2]

Bhe... Allora visto che ho capito la lezione ho fatto un programmino
che utilizza Arrays.binarySearch() sia con un Comparator
che senza:

import java.util.Arrays;
import java.util.Comparator;

/**
 *
 * @author mau2
 */
public class TryArrays2 {
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //
        //
        //UTILIZZO DI COMPARABLE
        //
        //
        NumImplementsComparable [] numbers = new NumImplementsComparable[3];
        //l'array deve essere ordinato in maniera crescente
        //altrimenti si vanifica l'algoritmo di ricerca binaria
        numbers[0] = new NumImplementsComparable(1);
        numbers[1] = new NumImplementsComparable(2);
        numbers[2] = new NumImplementsComparable(4);
        int n = 4;
        NumImplementsComparable num = new NumImplementsComparable(n);
        //se NumImplementsComparable non implementasse
        //l'interfaccia Comparable verrebbe lanciata un
        //ClassCastException
        System.out.println("Attemps key " + "\"new NumImplementsComparable(" + n + ")\".");
        int i = Arrays.binarySearch(numbers, num);
        if(i < 0)
            System.out.println("Key not found.");
        else
            System.out.println("Key found at index  " + i + ".");
        
        //
        //
        //UTILIZZO DI COMPARATOR CON i GENERICS
        //
        //
        NumWithoutImplementsComparable [] numbers2 = new NumWithoutImplementsComparable[3];
        numbers2[0] = new NumWithoutImplementsComparable(1);
        numbers2[1] = new NumWithoutImplementsComparable(2);
        numbers2[2] = new NumWithoutImplementsComparable(4);
        NumWithoutImplementsComparable num2 = new NumWithoutImplementsComparable(n);
        System.out.println("Attemps key " + "\"new NumWithoutImplementsComparable(" + n + ")\".");
        i = Arrays.binarySearch(numbers2, num2, new ComparatorWithGenerics());
        if(i < 0)
            System.out.println("Key not found.");
        else
            System.out.println("Key found at index  " + i + ".");
        
        
        
        
        
        
        
    }
    
    
    
    public static class NumImplementsComparable implements  Comparable{
        private int num;
        public NumImplementsComparable(int n){
            num = n;
        }
        public String toString() {
            return String.valueOf(num);
        }
        
        public int compareTo(Object o) {
            return  this.toString().compareTo(((NumImplementsComparable)o).toString());
        }
    }
    
    public static class NumWithoutImplementsComparable{
        
        private int num;
        public NumWithoutImplementsComparable(int n){
            num = n;
        }
        public String toString() {
            return String.valueOf(num);
        }
    }
    
    public  static class ComparatorWithGenerics implements Comparator<NumWithoutImplementsComparable> {
        public int compare(TryArrays2.NumWithoutImplementsComparable o1, TryArrays2.NumWithoutImplementsComparable o2) {
            if( Integer.parseInt(o1.toString()) < Integer.parseInt(o2.toString())  )
                return -1;
            else if(Integer.parseInt(o1.toString()) > Integer.parseInt(o2.toString()))
                return 1;
            else
                return 0;
        }
    }
    
    
    
    
    
}