标签: comparable

我有以下对象Node:

    private class Node implements Comparable<Node>(){
         private String guid();

         ...

         public boolean equals(Node o){
             return (this == o);
         }

         public int hashCode(){
              return guid.hashCode();
         }

         public int compareTo(Node o){
            return (this.hashCode() - o.hashCode());
         }

         ...

    }

我在下面使用它TreeMap:

TreeMap<Node, TreeSet<Edge>> nodes = new TreeMap<Node, TreeSet<Edge>>();

现在,树图被用在一个被调用的类中,Graph用于存储当前在图中的节点,以及它们的一组边(来自类Edge).我的问题是当我尝试执行时:

   public containsNode(n){
        for (Node x : nodes.keySet()) {
            System.out.println("HASH CODE: ");
            System.out.print(x.hashCode() == n.hashCode());
            System.out.println("EQUALS: ");
            System.out.print(x.equals(n));
            System.out.println("CONTAINS: ");
            System.out.print(nodes.containsKey(n));
            System.out.println("N: " + n);
            System.out.println("X: " + …

Compareable<Collection<T extends Compareable<T>>>Java中是否有任何实现(表现为C++ std::list<T>::operator<()或者std::set<T>::operator<())？

编辑:Comparator会更有意义......

我试图在Java中为一个对象实现类似的接口,我需要通过两个不同的列/变量进行排序.我尝试了多种方法,到目前为止这是最好的方法:

public int compareTo(Object o) {
    Match m = (Match)o;
    int diff = m.matches - matches;
    if (diff == 0) {
        if (distance > m.distance) {
            return 1;
        } else if (distance < m.distance) {
            return -1;
        } else {
            return 0;
        }
    } else {
        return diff;
    }
}

但它仍然失败了

java.lang.IllegalArgumentException: Comparison method violates its general contract!

我有什么想法我做错了吗？

附注1:如果o为null或不合适的类,则需要NPE/ClassCastExceptions - 这不是问题.

旁注2:我知道JDK 1.7中排序算法的变化,但我真的没有看到我在这里违反合同的地方.所以关闭异常似乎是错误的解决方案.

现在我正在尝试做一个涉及创建可以接收任何通用对象的堆的赋值,并且节点可以通过实现Comparable接口相互比较.问题是,我找不到像这样比较通用对象的方法.

这是我到目前为止Node类的内容:

private class Node<E> implements Comparable<E>
{
    private E data;
    private Node left;
    private Node right;

    //constructors
    public Node(E data)
    {
        this.data = data;
        left = null;
        right = null;
    }

    public Node(E data, Node left, Node right)
    {
        this.data = data;
        this.left = left;
        this.right = right;
    }


   //returns current data
    public Object getData()
    {
        return this.data;
    }

    public int compareTo(E other)
    {
        return data.compareTo(other);
    }
}

当我尝试编译时,它说"找不到符号 - 方法比较(E)." 方法compareTo()在Comparable接口中,所以我无法理解为什么会发生这种情况,我不知道如何修复它.任何人都有任何想法？

我读到了:

每当需要对集合进行排序时,元素必须是相互可比的.

我写了下面的代码,它工作正常.你能否告诉我们b级和c级是如何相互比较的,以及"相互比较"的含义是什么？

import java.util.ArrayList;
import java.util.Collections;

class b implements Comparable<c> {
    String str1;

    b(String str1) {
        this.str1 = str1;
    }

    public int compareTo(c object) {
        return str1.compareTo(object.str1);
    }
}

class c implements Comparable<b> {
    String str1;

    c(String str1) {
        this.str1 = str1;
    }

    public int compareTo(b object) {
        return str1.compareTo(object.str1);
    }
}

public class a {

    public static void main(String[] args) {
        b obj1 = new b("monster");
        c obj2 = new c("aman");

        ArrayList list  = new ArrayList();
        list.add(obj1);
        list.add(obj2); …

是否有可能适当地比较使用运营商的对象>,<并==在Java中？我Comparable在我的一个对象中实现了接口.

它可以节省一些时间并且很好写

if (obj1 < obj2) do sth

代替

if (obj1.compareTo(obj2) < 0) do sth

如果我实现其他东西或通常不能像这样工作,那可能吗？

我搜索并发现了几个类似问题的实例,但是已经实现了明显的解决方案,所以我有点不知所措.仅供参考:这是一项家庭作业,如果重要的话.

public class Entry<K extends Comparable<K>, V> implements 
    Comparable<Entry<K, V>> {

    protected K key;
    protected V value;

    protected Entry(K k, V v) {
        key = k;
        value = v;
    }

    public K key() {
        return key;
    }

    public V value() {
        return value;
    }

    // override toString method
    // toString method should print the entry as:
    // <key,value>
    @Override
    public String toString() {
        return "<>" + key.toString() + ", " + value.toString();
    }

    public int compareTo(Entry<K, V> other) {
        if …

假设我们有一些带有值的ArrayList:

List<Integer> list = new ArrayList<Integer>(40);
list.add(5);
list.add(-5);
list.add(-1);
list.add(10);
list.add(-12);

自然排序将是:[ - 12,-5,-1,5,10]与Collections.sort(列表)

但是我怎么能"忽略"(我很抱歉定义)负面和正面的值,我得到以下结果:[ - 1,-5,5,10,-12]？

以前感谢我的问题的业余时间.

我尝试得到一个答案,但有关比较器的每个问题都涉及排序.

我试图使用带有值的比较器 dog.getAge()

我的班级看起来像

public final class Dog implements Comparator<Dog>{
...
@Override
    public int compare(Dog o1, Dog o2) {
        if (o1.getAge() > o2.getAge()) {
            return 1;
        } else if (o2.getAge() > o1.getAge()) {
            return 2;
        }
        return 0;
    }
}

在主要活动中,我尝试比较狗,但我认为问题是我不知道如何结束这种方法,

我也有一个错误: Fatal Exception thrown on Scheduler.

我想从api那里得到狗.

所以这是我在MainActivity中的方法

private List<Dog> dogsArray = new ArrayList<>();

private void checkAscendingOrDescendingDogsAge() {
        Dog dog= new Dog();
        for (int i = 0; i < dogsArray.size(); i++) {
            dog.compare(dogsArray.get(i), dogsArray.get(i + 1));
        }
    }

初步问题:

在Scala中,我想使用隐式Ordering[T]#Ops来比较两个LocalDate.

它只是用来>代替"运营商" isAfter.

它应该只是一个导入: import scala.math.Ordering.Implicits._

检查:

看起来它适用LocalTime而不是LocalDate因为LocalTime而不是LocalDate工具Comparable<LocalTime>.

题:

我想知道,

为什么要LocalDate实现Comparable<ChronoLocalDate>而不是 Comparable<LocalDate>？