Perché questo codice gettando un ClassCastException e come evitarlo

Question

Si consideri questo codice:

import java.util.*;



class jm45 implements Comparator<jm45>
{
   private int x;
   jm45(int input) { x = input; }
   public static void main( String args[] )
   {
      List list = new ArrayList();
      list.add(new jm45(2));
      list.add(new jm45(2));
      Collections.sort(list); //faulty line
   }
   public int compare( jm45 t1 , jm45 t2 )
   {
      return t1.x - t2.x;
   }
}

Answer 1

La classe implementa Comparator<jm45> invece di Comparable<jm45>.

Un Comparator sa come confrontare due oggetti - un Comparable sa come confrontare un altro con se stessa

.

Si sia necessario passare in un comparatore per sort() da usare (come secondo argomento) oi valori devono essere comparabili.

Ecco una versione che utilizza l'interfaccia Comparable invece:

import java.util.*;

class Test implements Comparable<Test>
{
    private int x;

    Test(int input)
    { 
        x = input;
    }

    public static void main(String args[])
    {
        List<Test> list = new ArrayList<Test>();
        list.add(new Test(2));
        list.add(new Test(2));
        Collections.sort(list);
    }

    public int compareTo(Test other)
    {
      return x - other.x;
    }
}

Ed ecco una versione che utilizza l'interfaccia Comparator:

import java.util.*;

class TestComparator implements Comparator<Test>
{
   public int compare(Test t1, Test t2)
   {
      return t1.getX() - t2.getX();
   }
}

class Test
{
    private int x;

    Test(int input)
    { 
        x = input;
    }

    int getX()
    {
        return x;
    }

    public static void main(String args[])
    {
        List<Test> list = new ArrayList<Test>();
        list.add(new Test(2));
        list.add(new Test(2));
        Collections.sort(list, new TestComparator());
    }
}

Non c'è niente da di arresto di una classe che implementa Comparator<T> per se stessa, ma è un po 'strano per lui a farlo. Per esempio, che normalmente non chiedere una stringa per confrontare altre due più uno con l'altro - non ha niente a che fare con la stringa originale in sé

.

Answer 2

Dal javadoc Collections.sort:

ordina l'elenco specificato in modo crescente, secondo la ordinamento naturale dei suoi elementi. Tutti gli elementi della lista devono implementare l'interfaccia Comparable . Inoltre, tutti gli elementi nella lista deve essere reciprocamente comparabili (cioè, e1.compareTo (e2) non deve gettare un ClassCastException per qualsiasi elementi E1 ed E2 nella lista).

La classe implementa comparatore, non paragonabili.