Comparable 接口如何工作？

Question

我正在学习 Java 并且想对包含对象的数组进行排序。为此，我想使用 Comparable。我一直运行进入一个编译错误，它似乎指出我没有实现 compareTo（我实现了）或者 Comparator 有问题（我现在不想使用它）。我已经在下面列出的一个小程序中隔离了这个问题。非常感谢任何帮助，因为我花了几个小时在网上搜索。

我已经注释掉了main的一些代码，因为我真正想做的是创建一个带有接口对象的数组并使用Comparable对其进行排序。我不确定这是否可行，所以我现在正在测试排序类.

包 comp_test;

  import java.util.ArrayList;
  import java.util.List;

  public class program {

    public static void main(String[] args) 
    {
        List<root> container = new ArrayList<root> ();

        container.add (new A ("Een"));
  //        container.add (new AA ("twee"));
        container.add (new B ("drie"));
  //        container.add (new AA ("vier"));
        container.add (new A ("en Vijf"));

        for (root r: container)
        {
            r.show ();
        } // for
        List.sort (container); // <=== error
        // The method sort(Comparator) in the type List is not 
        // applicable for the arguments (List<root>
    }

  /*
    public static void main(String[] args) 

    {
        List<Itf> container = new ArrayList<Itf> ();

        container.add (new A ("Een"));
        container.add (new AA ("twee"));
        container.add (new B ("drie"));
        container.add (new AA ("vier"));
        container.add (new A ("en Vijf"));

        for (Itf i: container)
        {
            i.show ();
        } // for
        container.sort ();
    }
  */
  }

  --------------
  package comp_test;

  public interface Itf 
  {
    public void show ();
  }
  ---------------
  package comp_test;

  abstract public class root  implements Itf, Comparable<root> 
  {
    abstract public void show ();
    abstract public String getID ();

    @Override
    public int compareTo (root other) 
    {
        return this.getID ().compareTo (other.getID ());
    } /*** compareTo ***/

  }
  ------------------
  package comp_test;

  public class A extends root  
  {
    private String ID;

    public A (String id) 
    {
        this.ID = id;
    } /*** A ***/

    public String getID ()
    {
        return ID;
    } /*** getID ***/

    @Override
    public void show ()
    {
        System.out.println ("A (" + getID () + "): " + super.toString ());
    } /*** show ***/

  }
  ------------------
  package comp_test;

  public class B extends root 
  {
    private String Name;

    public B (String id)
    {
        this.Name = id;
    } /*** B ***/

    @Override 
    public String getID ()
    {
        return Name;
    } /*** getID ***/

    @Override
    public void show ()
    {
        System.out.println ("B (" + Name + "): " + super.toString ());
    } /*** show ***/

  }

Answer 1

而不是

List.sort (container);

你应该使用

Collections.sort (container);

或

container.sort(new Comparator<root>() {
        @Override
        public int compare(root o1, root o2) {
            return o1.compareTo(o2);
        }
    });

或（使用 lambda）：

 container.sort((o1, o2) -> o1.compareTo(o2));

或（使用 lambda，情况 2）：

container.sort(root::compareTo);

Answer 2

你应该使用这个：

container.sort()

它将使用填充列表的根元素的 compareTo 方法

PS : root-->Root (对象命名首字母大写)

Answer 3

您试过这样调用排序：

List.sort(container);

每当遇到这样的编译器错误时，您应该查看 Javadoc 以查找导致错误的方法。查看 List.sort 的 Javadoc，我们可以看到该方法不是静态的，但您正在尝试使用它，就好像它是静态的一样。由于该方法不是静态的，您需要在您尝试排序的对象上调用它：

container.sort(null);

进一步阅读该方法，Javadoc 说，如果您想使用包含的对象的自然顺序（即它们的 compareTo 方法），那么您应该传递 null，而不是比较器（正如我在上面所做的那样） .

顺便说一下，您也可以调用 Collections.sort(container); 但这只是一个包装器，它所做的只是调用 container.sort(null).

Comparable 接口如何工作？

How does the Comparable interface work?

java

sorting

comparable