标签: comparable

我想写一个通用的Pair类,它有两个成员:key和value.这个类的唯一要求是key和value都应该实现Comparable接口,否则Pair类不会接受它们作为类型参数.
首先,我这样编码:

public class Pair<T1 extends Comparable, T2 extends Comparable>

但是JDK 1.6编译器会生成关于此的警告:

Comparable is a raw type. References to generic type Comparable<T> should be parameterized

然后我尝试添加类型参数,代码现在看起来像这样:

public class Pair<T1 extends Comparable<? extends Object>,
                  T2 extends Comparable<? extends Object>>

现在一切顺利,直到我尝试为Pair生成Comparator.(以下代码在Pair类中)

public final Comparator<Pair<T1, T2>> KEY_COMPARATOR = new Comparator<Pair<T1, T2>>() {
        public int compare(Pair<T1, T2> first, Pair<T1, T2> second) {
            *first.getKey().compareTo(second.getKey());*
            return 0;
        }
    };

该代码first.getKey().compareTo(second.getKey());将生成错误说:

The method compareTo(capture#1-of ? extends Object) in the type Comparable<capture#1-of ? extends Object> is …

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

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

通过docjar String,我碰巧看到以下代码:

public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();

private static class CaseInsensitiveComparator
                       implements Comparator<String>, java.io.Serializable {
    // use serialVersionUID from JDK 1.2.2 for interoperability
    private static final long serialVersionUID = 8575799808933029326L;

    public int compare(String s1, String s2) {
        // ...
    }
}

我的问题是,为什么我们不能只实现Comparator,Comparable使用私有方法而不是嵌套类？

同样在一个侧面说明,为什么不Comparator具有相似的一个参数的方法compareTo的Comparable？

目前正在做一项将概念应用Comparable到应用中的作业。

我编写了这个允许输入Comparable[]数组的简单方法。此方法返回任何给定数组输入的最小值。使用该.compareTo()方法，我能够真正扩展该方法以允许真正的任何对象类型，无论它是像类一样的自定义实现Point（我们为分配所做的，但此处未显示）。

public static Comparable getMinimum(Comparable[] inputArray)
{
    Comparable newObj = inputArray[0];
    for(int i = 0; i < inputArray.length; i++)
    {
        Integer retValue = (inputArray[i]).compareTo(newObj);
        if(retValue < 0)
        {
            newObj = inputArray[i];
        }
    }
    return newObj;
}

我的问题是 - 这是什么Comparable类型？查看 Java API，它并没有真正透露太多信息。为什么我们使用Comparabletype 而不是Objecttype，后者还包括int、double、String等类型？

我有一个ArrayList的Person对象。APerson有name，age和height。我的目标是对此进行排序ArrayList<Person>。我已经实现Comparable<Person>并定义了compareTo()但是当我尝试对其进行排序时，它给了我这个错误：

ArrayList 类型中的 sort(Comparator) 方法不适用于参数 ()"

我的理解是，如果你实现了 Comparable，然后定义了compareTo所有其他的东西，你就可以神奇地完成了。

有人可以解释一下这是如何工作的以及为什么我会收到此错误吗？

我正在研究Comparable界面,发现IllegalArgumentException当我放入size=50下面的程序时它正在抛出,并且当我放入时工作正常size =5.

    public class Test {
    public static void main(String[] args) {
        int size = 50;
        Test compareTest = new Test();
        compareTest.test(size);
    }

    public void test(int size) {
        List<TestObject> requests = new ArrayList<TestObject>();
        for (int index = 0; index < size; index++) {
            TestObject request = new TestObject();
            request.value = index;
            requests.add(request);
        }
        Collections.sort(requests);
    }

}

class TestObject implements Comparable<TestObject> {
    public int value;

    public int compareTo(TestObject req) {
        if (value % …

我需要根据过滤器列表对项目列表进行排序，过滤器列表按优先级排序。但是，这些过滤器来自 API 请求正文，因此它们可以更改。

我有一个过滤器类

public class Filter {
  private String fieldName;
  private String order;

  // Getters and Setters...
}

一些过滤对象

Filter filter1 = new Filter("price", "desc");
Filter filter2 = new Filter("size", "asc");

我的 Item 类是这样的：

public class Item {
  private String productName;
  private double size;
  private double price;

  // Getters and Setters...
}

然后我必须像这样对项目进行排序：

如果一个 Item.price 等于下一个 Item，则比较它们的大小，依此类推...

我已经尝试为每个过滤器创建一个比较器，但我无法链接它们，因此每个过滤器都会自行对列表进行排序，而不考虑以前的排序方法（有时将整个列表颠倒过来）。

我还尝试在 Item 类上实现 Comparable 接口，但该接口方法compareTo只接受单个参数（下一个 Item），而不接受规则列表。

所以给定一个项目列表，例如

List<Item> items = new ArrayList<Item>(
  new Item("foo", 10.0, 5.0),
  new Item("bar", 6.0, …

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

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

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

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

他这样说对吗？

在下面的代码中，我定义了一个通用链表。Go1.18 很乐意使用列表的实例作为映射的键。但是，最后一行如果未注释，则无法编译；我收到错误：

Cons[int] 没有实现可比较

是否有一个较弱的类型约束我可以使用来挑选出那些可以用作键的类型，或者这是有意的，还是它是一个编译器错误？

package main

import "fmt"

type List[X any] interface {
    isList()
}

type Cons[X any] struct {
    Data X
    Next List[X]
}

func (Cons[X]) isList() {}

type Nil[X any] struct{}

func (Nil[X]) isList() {}

func id[X comparable](x X) X { return x }

func main() {
    x := Cons[int]{5, Nil[int]{}}
    m := map[List[int]]string{}
    m[x] = "Hi"        // succeeds
    fmt.Println(m[x])  // prints "Hi"
    // fmt.Println(id(x)) // fails
}

比如如果我要比较弦乐"你好"和"世界".

怎么知道Hello比世界更重要？

我唯一能想到的是,它可能使用ASCII表作为参考吗？

谢谢您的帮助!