标签: comparable

我没有看到任何我做错的事,但NetBeans给了我以下错误:

incomparable types
required: boolean
found: java.lang.Object


public int compareTo(Object obj)  {
    if( obj instaceof Employee){
       Employee employee = (Employee) obj;
       if(this.weekly_earnings > employee.weekly_earnings)
           return 1;
       else if(this.weekly_earnings == employee.weekly_earnings)
           return 0;
       else
           return -1;
    }
    else{
        System.out.println("Error");
    }
}

我刚刚发现这个考试题目,无法弄清楚:

下面描述了一个实现Comparable接口的设计部分类.这个设计类的唯一目的是将它的实例与给定的字符串进行比较.

我们需要在课堂上填写两件事来完成它.这是班级:

public class PrivateComparableClass // FILL IN PART 1 { 
   private String thing;

    public PrivateComparableClass(String thing) {
     this.thing=thing;
    }
   //FILL IN PART 2
}

我假设第1部分只对应于:

public class PrivateComparableClass implements Comparable {

第2部分,我假设他期待compareTo方法的实现,但我真的不知道如何正确地实现这个:

public static int compareTo() {
  if this.thing.equals(thing){
  return 1;
  } else {
    return -1;
  }
}

我该如何解决这个问题？

这可能是一个微不足道的问题,但我还没有找到任何关于它的内容,所以这里说:
当实现Comparable接口时,我们应该定义方法compareTo(),以便根据文档提供以下内容:

• 对于所有x和y,sgn(x.compareTo(y))== -sgn(y.compareTo(x)).

• 该关系是传递的:(x.compareTo(y)> 0 && y.compareTo(z)> 0)意味着x.compareTo(z)> 0.

• 对于所有z,x.compareTo(y)== 0表示sgn(x.compareTo(z))== sgn(y.compareTo(z)).

现在,令人困惑的部分是返回值,具体如下:

返回负整数,零或正整数,因为此对象小于,等于或大于指定对象.

似乎大多数实现都返回1,-1或者0,即使没有提到返回值以这种方式受限的要求.
因此,以下代码适用于对Collections.sort()包含类实例的列表(使用)进行排序Foo:

public int compareTo(Foo other){
    return this.value > other.value? 1 : this.value < other.value ? -1 : 0;
}

但是,这不是:

public int compareTo(Foo other){
    return (int)(this.value - other.value);
}

哪里value是long,和值之间的差值不超过Integer.MAX_VALUE.

我失去了一些东西在这里,或者是完全需要的返回值1,-1或者0,矛盾的文件？

更新:感谢您的所有答案,但似乎人为因素归咎于此.我提到计算的差异小于Integer.MAX_VALUE,这应该意味着没有溢出,但我的计算是错误的,所以我确实得到了溢出,这导致了奇怪的结果.

我不明白Javadoc:

The natural ordering for a class C is said to be consistent with equals if and only if
  (e1.compareTo((Object)e2) == 0) has the same boolean value as e1.equals((Object)e2) for
  every e1 and e2 of class C.

为什么要那样？

我知道e1.equals(e2)= true应该始终意味着e1.compareTo(e2)== 0,但我无法理解为什么相反应该是真的.比较不平等!2个相等的对象应该与零进行比较,但是如果排序标准与它们的情况不相关,则2个不同的对象应该能够比较0.我的意思是,让不同的对象等于不正确,但不同的对象与0比较为什么不呢？

编辑:后来它表示强烈建议一致性,因为一些兼容性问题,因此问题

我有一对哈希值,如

1. 128ecf542a35ac5270a87dc740918404; d603ac0c04b9d08974482ae7fd4cf55
2. a1288b1c7e2257a90bad9bdfb7690fbb; f23828e312d90cb7fdadd6479236119c
3. ................................; ................. ...............

我想让每一对与其他对比,意思是:

128ecf542a35ac5270a87dc740918404; d603ac0c04b9d08974482ae7fd4cf55d

保持原样;

如果是

d603ac0c04b9d08974482ae7fd4cf55d; 128ecf542a35ac5270a87dc74091840

4,它应该成为

128ecf542a35ac5270a87dc740918404; d603ac0c04b9d08974482ae7fd4cf55d

我的主要目标是有一个特定的函数,它比较一对的两个哈希值,并根据一些规则返回一个具有在其中排序的值的对.规则本身并不重要,唯一的要求是,它应该非常快,并且应该总是给出相同的结果,因为输入是(unique1,unique2)或(unique2,unique1)

谢谢!

一种显而易见但效率低下的方法是仅将每个散列值中包含的数字相加并比较它们,并将散列值与较小的和作为对中的第一个元素,将较大的和作为第二个位置.

Go中是否有任何内部机制来实现平等和排序？(所以我们可以在类型上使用比较运算符 - ==,!=,<,>,<=,> =.)

注意:我看到一些类型有一个名为Less的方法,似乎用于排序.但我找不到该文档或相等检查界面(如果有的话).

对我来说,与其他任何东西(甚至是另一个null类型)进行比较的null类型是未定义的操作.如果我错了,请纠正我.

根据这个假设,以下内容对我有意义:

nil.is_a? Comparable
 => false

nil.respond_to? :<=
 => false

nil.respond_to? :<
 => false

nil.respond_to? :>=
 => false

nil.respond_to? :>
 => false

但是,nil 确实响应"宇宙飞船"比较运算符:

nil.respond_to? :<=>
 => true

我无法想象比较nil甚至有意义的情况,更不用说实际了.为什么nil会有这种行为？

我最近写了一个简单的通用选择排序方法来获得它的乐趣,当我对某些东西感到有些困惑时.这是我的代码:

public static <T extends Comparable<T>> void sort(List<T> list) {
    for (int i = 0; i < list.size(); i++) {
        int minIndex = i; // Assume that the first element is the minimum for now.

        // Find smallest element in unsorted sub-list.
        for (int k = i + 1; k < list.size(); k++) {
            if (list.get(k).compareTo(list.get(minIndex)) < 0) {
                minIndex = k;
            }
        }

        // Swap smallest element with the first element in unsorted sub-list.
        T temp = list.get(i);
        list.set(i, …

我是lambda的初学者,并试图了解它是如何工作的.所以我有这个具有id和分数属性的学生列表,我必须根据分数对其进行排序.我的守则

import java.util.*;

class Student {

    int id, score;

    public Student(int id, int score) {
        this.id = id;
        this.score = score;
    }
    public String toString() {
        return this.id + " " + this.score;
    }
}

interface StudentFactory < S extends Student > {
    S create(int id, int score);
}

class Test {

    public static void main(String[] ad) {

        StudentFactory < Student > studentFactory = Student::new;
        Student person1 = studentFactory.create(1, 45);
        Student person2 = studentFactory.create(2, 5);
        Student …

我正在开发一个程序，该程序必须重写Comparable中的CompareTo（）以使Collections.sort（）工作。因为我正在使用由助手组成的ArrayList，所以我必须根据名称进行排序。

我浏览了论坛，发现并尝试更改

public class Assistant{

至

public class Assistant implements Comparable<Assistant>{

作为回报，它使我可以在另一个类中使用Collections.sort（），并且不会警告我任何错误，但是会出现两个新错误。

首先，在同一行

public class Assistant implements Comparable<Assistant>{

它告诉我“它不是抽象的，并且不会覆盖Comparable中的compareTo（Assistant）”。当我转到compareTo（）时，我已经创建了：

    @Override
    public int compareTo(Object o2){
        Assistant m2 = (Assistant) o2;

        if(this.name.compareTo(m2.name) == 0){
            return 0;
        }else if(this.name.compareTo(m2.name)<0){
            return -1;
        }else{
            return 1;
        }
    }

（助手的构造函数仅包含名称）。

但是，在这个地方我在@Override中出错：“方法不会覆盖或实现超类型的方法”。

在下一行

    public int compareTo(Object o2){

我收到另一个错误（与上一个相关），该错误告诉我：“名称冲突：Assistant中的compareTo（Object）和Assistant中的compareTo（Assistant）具有相同的擦除，但是两者都不能覆盖另一个。”

我有点理解问题，我没有覆盖原始的compareTo（）。

我是Java的新手，因此，如果有人发现问题，如果您也能解释我做错了（或遗漏了），我将不胜感激。

谢谢 ：）