标签: comparable

给定两个不同类型的列表,是否可以使这些类型在彼此之间可转换或相互比较(例如使用TypeConverter或类似),以便LINQ查询可以比较它们？我已经在SO上看过其他类似的问题,但没有任何指出使类型可以在彼此之间转换以解决问题.

收集类型:

public class Data
{
    public int ID { get; set; }
}

public class ViewModel
{
    private Data _data;

    public ViewModel(Data data)
    {
        _data = data;
    }
}

所需用法:

    public void DoMerge(ObservableCollection<ViewModel> destination, IEnumerable<Data> data)
    {
        // 1. Find items in data that don't already exist in destination
        var newData = destination.Except(data);

        // ...
    }

这似乎是合乎逻辑的,因为我知道如何将ViewModel的实例与Data的实例进行比较,我应该能够提供一些比较逻辑,然后LINQ将用于查询,例如.Except().这可能吗？

我正在编写一个方法,它将唯一参数作为可比较对象的列表,并且不返回任何内容.我不确定它应具有的语法:

public static void methodName(List<Comparable<Object>> list) {
    // Do some stuff
}

我认为这是错误的,因为<Object>作为Comparable的类型,这意味着列表可以将Integer和Boolean作为对象,但我不希望这样.我希望列表只采用一种类型,但该类型必须实现Comparable接口.我如何实现这一目标？

我是新手,学习红宝石.希望能够更好地理解所提出的问题.我不明白使用类似的mixin和可枚举的mixin.我的意思是当我们需要使用它们时,我们不会在课堂中包含这些,对吧？如果我们想比较两个对象,我们只需写x> y.那么明确使用它们的用途是什么？

我经历了一些非常怪异的TreeMap行为,我在缩小一个小测试用例时遇到了一些麻烦,所以请耐心等待.

我想从运行时提供的文件中将大量键值对读入Map.我正在使用自定义密钥类.后来,当我把条目撤回时,我发现其中一个或多个丢失了.使用调试器和一些测试用例,我已经确定缺少的条目在读取阶段肯定会消失,但我不确定是什么导致它.

基本上:

Map<MyKey,Double> map = new TreeMap<MyKey,Double>();
map.put(key1,value1);

// ... put another ~500 entries into the map ...

assertTrue(map.containsKey(key1)); // passes
if (!map.containsKey(keyN)) { 
    map.put(keyN, valueN); // this code executes
}
assertTrue(map.containsKey(key1)); // FAILS

......实质上,向地图添加一个全新的密钥会导致无关的条目失效.

• 如果我只是单独添加key1和keyN,则key1保留在地图中 - 介入的500个条目在某种程度上很重要
• 如果我从2 ..(N-1)中删除一个或两个任意键,则在添加keyN时仍会启动key1
• 如果我从2 ..(N-1)中删除了大范围的键,则key1在添加keyN时保持不变,但是当添加keyQ时会掉出来,在行下面还有~300个键
• 不幸的是,当keyN踢出key1的地图的大小是不一样的地图的大小时keyQ踢出key1的,所以它可能不是一个有限的尺寸问题
• 如果我使用HashMap,则key1仍保留在地图中
• 自定义键类MyKey对Comparable,equals和hashCode使用相同的逻辑.

我最初使用TreeMap是因为我希望使用大型数据集,而TreeMap的内存效率更高一些.HashMap将是一个很好的选择,但看到TreeMap以这种方式表现仍然令人震惊 - 任何人都对这里发生的事情有所了解？

今天在AP计算机科学课上,我有这个代码:

    Comparable x = 45;
    Comparable y = 56;
    System.out.println(x.compareTo(y));

这是有效的.它打印1(或-1,我忘了哪个),但可以比较它们.

我理解接口变量是指实现该接口的类的对象,但对我来说没有意义的是如何为接口变量分配一个整数,然后在其上调用一个方法.在这种情况下,什么对象是被调用的compareTo()方法？什么都没有实例化!

码:

public class CompareTest {

    public static void main(String[] args) {

        ArrayList list =  new ArrayList();
        (list).add(new CompareTest());  


        Arrays.sort(list.toArray()); //Does not throw Exception , why ?
        Collections.sort(list);   //throws ClassCastException
    }

}

根据Java Doc: Arrays#sort

根据元素的自然顺序,将指定的对象数组按升序排序.数组中的所有元素都必须实现Comparable接口.

为什么阵列#sort,ClassCastException不像JavaDoc所说的那样抛出？

今天我被问到这个面试问题:

如果我有一个Person带班name,age和salary领域,我把这个100个新的实例Person中的ArrayList,然后做Collections.sort(list),然后什么参数将列表进行排序？

我知道我需要有Person类实现Comparable然后覆盖compareTo,但如果我不这样做,会发生什么？

我发现这个注释可以将StringBuffer对象作为Java中TreeSet中的键吗？

"在Java中使用地图有两种识别策略(或多或少).

散列:输入"Foo"被转换为尽可能最好的尝试,以生成唯一访问数组索引的数字.(纯粹主义者,请不要虐待我,我故意简化).此索引是存储值的位置."Foo"和"Bar"实际上可能生成相同的索引值,这意味着它们都将映射到相同的数组位置.显然这不起作用,所以这就是"equals()"方法的用武之地; 它用于消除歧义

比较:通过使用比较方法,您不需要这个额外的消歧步骤,因为比较首先不会产生这种碰撞."Foo"等于的唯一关键是"Foo".一个非常好的想法是,如果你可以将"equals()"定义为compareTo()== 0; 为了一致的缘故.不是要求."

我的问题如下:如果我的类实现了可比性,那么它是否意味着我不必重写equals和hashcode方法来将我的对象用作Hash集合中的键.例如

class Person implements Comparable<Person> {
     int id;
     String name;

     public Person(int id, String name) {
        this.id=id;
        this.name=name;
     }

    public int compareTo(Person other) {
      return this.id-other.id;
    }
}

现在,我可以在Hashable集合中使用我的Person对象吗？

我是编程的初学者,我有两节课.头等舱是:

public class User implements Comparable<User>

with field int age,constructor和overrided interface of interface Comparable:

 @Override
    public int compareTo(User user) {
        return user.age >= age ? -1 : 0;
    }

第二类是 public class SortUser使用从List创建Set集合的方法:

public Set<User> sort(List<User> list) {
        Set<User> result = new TreeSet<>();
        for (User user : list) {
            result.add(user);
        }
        return result;
    }

在我看来,UserSet 中的所有对象都应该排序,但是当我创建一个包含3个User对象的List时......

 User a = new User(1);
 User b = new User(2);
 User c = new User(3);
 List<User> list = …

据我所知，Comparator.comparingInt()应按升序排序，并Comparator.comparingInt().reversed应按降序排序。但是我发现了一种相反的情况。

用一个例子可以更好地解释这一点。以下是我的代码。

金额等级：

class Amount
{
    int lineNum;
    int startIndex;
    Double value;
//Getters , setters and toString.
}

主要方法：

public static void main( String[] args )
{
    List<Amount> amounts = new ArrayList<>();
    amounts.add( new Amount( 1.0, 5, 10 ) ); //LINE_NUM 5
    amounts.add( new Amount( 3.0, 9, 30 ) );
    amounts.add( new Amount( 2.0, 3, 40 ) );
    amounts.add( new Amount( 9.0, 5, 20 ) ); //LINE_NUM 5
    amounts.add( new Amount( 6.0, 1, 50 ) ); …