标签: comparable

我刚刚发现这句话:"通过首先比较最有可能不同的项目,可以大大提高compareTo的性能".这是真的吗？如果是,为什么？

我使用我之前声明的Comparator在ArrayList上调用Collections.sort().

ArrayList<Employee> list = new ArrayList<Employee>();
Comparator<Employee> comparator = new Comparator<Employee>() {

  public int compare(Employee o1, Employee o2) {
    return o1.getName().toLowerCase().compareTo(o2.getName().toLowerCase());
  }

};

...

Collections.sort(list, comparator);

出于某种原因,sort尝试将我的ArrayList的元素转换为Comparables,即使我传递了Comparator.为什么会发生这种情况？

如果它有用,这是我的堆栈跟踪

Exception in thread "Thread-3" java.lang.ClassCastException: processing.app.EmployeeManager$PrettyOkayEmpolyee cannot be cast to java.lang.Comparable
    at java.util.Arrays.mergeSort(Unknown Source)
    at java.util.Arrays.sort(Unknown Source)
    at java.util.Collections.sort(Unknown Source)
    at foobar.Main.doSomeSorting(Main.java:140)
    ...
    at java.lang.Thread.run(Unknown Source)

 1  class test {
 2      public static int compare0(Comparable x, Comparable y) {
 3          return x.compareTo(y);
 4      }

 5      public static int compare1(Object x, Object y) {
 6          return ((Comparable) x).compareTo((Comparable) y);
 7      }

 8      public static int compare2(Object x, Object y) {
 9          Comparable p = (Comparable) x;
10          Comparable q = (Comparable) y;
11          return (p).compareTo(q);
12      }

13      public static void main(String[] args) {
14          Comparable zero = new Integer(0);
15          Comparable one = new Integer(1);
16 …

我对使用Orderings的Scala中的排序有些熟悉,但是我想对一些用Java定义的对象进行排序.他们是Comparable(不Comparable[T])和final:

final class Term implements Comparable { ... }

(这实际上是Lucene的Term类,不,我不能改变Lucene的版本).

我首先希望有一个隐含的地方:

terms.sorted //fail - no implicit ordering

也许我可以订购它？

class OrderedTerm extends Term with Ordering[Term] //fail - class is final

在此之后,我想我会诉诸于使用的肮脏java.util.Collections.sort:

Collections.sort(terms) // error: inferred type arguments [org.apache.lucene.index.Term] do not conform to method sort's type parameter bounds [T <: java.lang.Comparable[_ >: T]]

所以看起来即使这不起作用,因为Scala严格遵守它的类型参数.在这一点上,我可以看到两种方法:重新实现另一个显式排序(坏)或在Java中编写排序(不是那么糟糕).

有没有办法在Scala中干净利落地做到这一点？我假设使用旧Java对象可能会出现这种情况？

任何人都可以帮助我使用泛型比较Integer和Double吗？

这就是我所拥有的:

public static <T extends Comparable<? super T>> int compare(T arg1, T arg2)
{
    return arg1.compareTo(arg2);
}

public static void main(String[] args)
{   
    Number i = new Integer(5);
    Number j = new Double(7);

    System.out.println(GenericsTest.compare(i, j));
}

我得到的错误消息是:绑定不匹配:GenericsTest类型的泛型方法compare(T,T)不适用于参数(Number,Number).推断类型Number不是有界参数的有效替代>

我有一个库存类，它创建一个充满对象 Item 的 ArrayList，它也是一个类。我知道我必须调用 Collections.sort(items);才能对 ArrayList 进行排序（顺便说一下，它称为项目）。作业说我必须在 Item 类上使用一个接口，我不知道是否要实现 Comparator 或 Comparable，然后为方法compareTo()或compare()方法编写什么。另外，我Collections.sort(items)在声明 ArrayList 后立即接到电话，这样可以吗？

Comparable<Item>编辑：我的老师刚刚澄清说她希望我们在 Item 类上实现。

我有一个实现Comparable接口的类.在这个类中,我需要覆盖compareTo方法,以便按Long值对对象进行排序.

我不知道的是如何执行是Long类型的比较.尝试检查值是否大于或小于另一个Long值时出错.我知道龙是长期的对象,但不知道如何比较两个龙的.

代码示例:

public int compareTo(MyEntry<K, V> object) {
    if (this.value < object.value)
        return -1;
    if (this.value.equals(object.value))
        return 0;

    return 1;
}

错误信息:

           operator < cannot be applied to V,V
if (this.value < object.value)
                       ^

V,V长,长

所以我有一个实现Comparable的类(为了简洁我在这里有一个虚拟方法)

public class MarkovEntry<T extends Chainable> implements Comparable<MarkovEntry<T>>
{
    // Compare two rows by ID
    public int compareTo(MarkovEntry<T> e)
    {
        return 0;
    }
}

另一个类中的方法采用Comparable(再次,虚拟方法)

public class ArrayOps
{
    public static int binSearch(ArrayList<Comparable> list, Comparable c)
    {
        return 0;
    }
}

然而,当我尝试按如下方式调用我的方法时

int index = ArrayOps.binSearch(entries, newEntry);

其中entries是MarkovEntry的ArrayList,newEntry是MarkovEntry,编译器告诉我

actual argument java.util.ArrayList<com.company.MarkovEntry<T>> cannot be converted 
to java.util.ArrayList<java.lang.Comparable> by method invocation.

这里发生了什么？MarkovEntry专门实现了Comparable - 为什么编译器不能识别？

我的类Chainable也实现了Comparable,以防它与它有任何关系.

I want to understand what is the difference between these two methods? Can they both be used for the same problem? Or are they designed for different cases?

public int compareTo(Coordinates o) {
    if (row < o.row) return -1;
    if (row > o.row) return +1;

    if (column < o.column) return -1;
    if (column > o.column) return +1;
    return 0;
}

@Override
public int compareTo(Coordinates o) {
    int cmp = row - o.row;
    if (cmp == 0)
        cmp = column - …

在我的一次采访中，我被问到

Comparable 和 Comparator 之间的性能差异是什么？

我回答说不知道。面试官说，

如果 Comparable 由类Employee 实现，当创建 5000 个 Employee 对象并将其添加到 ArrayList 中时，堆内存中将有 5000 个具有compareTo方法的对象。所以除非绝对必要，否则不要使用 Comparable。使用 Comparator，消除了上述内存开销。

他这样说对吗？