Java 泛型和 Infinity（可比较）

Question

使用 Integer 类型，您可以执行以下操作：

int lowest = Integer.MIN_VALUE;

如果我使用泛型，我可以做什么？

K lowest = <...>;

我需要这个来实现类似于 PriorityQueue 的东西。 我可以访问要从队列中删除的节点，但它不是最小值。

1. I need to make it the min by decreasing the key of that node,
2. And then remove the min.

我被困在第一步了。 我唯一能做的就是将节点的密钥设置为当前最小值。 不确定这是否足够。

Answer 1

考虑不要使 K 成为泛型，而是使用包装原始包装器的接口（双重包装器！）。

import java.util.HashMap;


public class NodeWrapper<K extends Comparable<K>> implements Comparable<NodeWrapper<K>> {

    private static HashMap<Class, NodeWrapper> minVals = new HashMap<Class, NodeWrapper>();

    private K value;

    private NodeWrapper() {
        super();
    }

    public NodeWrapper(K value, Class<K> clazz) {
        super();
        this.value = value;

        if (minVals.get(clazz)==null) {
            minVals.put(clazz, new NodeWrapper<K>());
        }
    }

    public K getValue() {
        return value;
    }

    public static NodeWrapper getMinValue(Class clazz){
        return minVals.get(clazz);
    }

    public void setValue(K value) {
        this.value = value;
    }

    @Override
    public int compareTo(NodeWrapper<K> o) {
        NodeWrapper min = minVals.get(this.getClass());
        if (this==min && o==min)  {
            return 0;
        } else if (this==min){
            return -1;
        } else if (o==min){
            return 1;
        } else {
            return this.value.compareTo(o.value);
        }
    }

}

简而言之，这个想法是，每当实例化一个新类时，都会创建一个最小值并将其放入存储每个类的最小值的静态哈希图中。 （事实上​​，这些值根本就不是什么，只是一个哨兵对象，但是由于我们将使用对象相等性来确定某个值是否为最小值，所以这根本没有问题。）所需要的只是包装的对象具有可比性一般而言，对于其自身的其他实例。

一个缺点是，当您调用 getMinValue 时，您将收到编译器警告，因为返回类型没有通用信息。 可能有一种更优雅的方法来解决这个问题，但我现在想不到。

总体而言，这个总体想法可能相当不错。 然而，我真的应该强调：如果您尝试使用任何多态性或任何相互可比较的类的混合，这绝对会失败。 同一棵树中的Long和Integer将彻底摧毁你。

Answer 2

呃……又出什么问题了？

PriorityQueue，像所有集合，允许您使用对象的实例 将其从集合中删除。

Answer 3

呃，这不是取决于K是什么类型吗？

泛型的要点是 K 可以是任何类型（或某种类型的任何子类）； 为了能够调用 K 上的方法或访问它的属性，您需要使用通配符限制它的类型界限。

Answer 4

仅仅因为一个对象是可比较的并不意味着它必须具有最小值。 int 的最小值为 -(2^(31)) 的原因是因为符号需要 1 位，因此 2^31 是可以存储的最大（或最小）整数。 对于像字符串这样的东西，它没有任何意义，因为没有最大/最小可能的字符串，它是内存限制的。

Answer 5

您可能必须创建一个接口“IInfinity”，并让 K 扩展 IInfinity，让 IInfinity 具有方法“getInfinityValue()”，然后在实现 IInfinity 的类中包装/扩展 Integer、Double、BigDecimal 等...呃！

Answer 6

基本上，您希望任何类型 K 实现一些静态函数，例如遵守标准数学属性的最低和最高函数。

我假设为了使这种最低（或最高）的感觉可用，您会希望任何 Comparable 对象都具有这些方法。 （或静态字段）。 如果您只对自己的自定义对象感兴趣，则执行此操作的方法是让所有内容都继承自抽象数据类型，该抽象数据类型声明了 MINVALUE 和 MAX_VALUE 的静态字段，然后您的类型变量将为 . 如果其他类需要此功能，则需要创建某种外部哈希图来跟踪不同类的这些属性（但这会变得非常难看）

Answer 7

对于所有 Comparable 类型，没有通用形式的 MIN_VALUE 或 MAX_VALUE。

考虑一个实现可比较的 Time 类。 尽管 Time 是 Comparable，但它没有 MAX_VALUE。

Answer 8

我试图想象什么情况下需要这样的行为。 这是我能想到的最好的...

警告：此代码很危险。 请怜悯我发布如此令人厌恶的内容。 这只是一个概念证明。

public class Lowest<K> implements Comparable<K> {
    public int compareTo(K other) {
        return -1;
    }
}

进而...

public class Test {
    public <K extends Comparable<K>> K findMaximum(List<K> values) throws Exception {
        K lowest = (K) new Lowest<K>(); /// XXX DANGER! Losing compile-time safety!!!

        K maximum = lowest;
        for (K value : values) {
            if (maximum.compareTo(value) < 0) {
                maximum = value;
            }
        }

        if (maximum == lowest) {
            throw new Exception("Could not find a maximum value");
        } else {
            return maximum;
        }
    }
}

Answer 9

这没有任何意义...

鉴于您当时不知道 K 是什么，（即您一般地实现它...废话！）您无法为其指定最小/最大界限。

在 K 可能是 int、long、string OR 对象的情况下，您无法明智地猜测使用

Integer.MIN_VALUE、"" OR NULL。

我猜您正在寻找的是 K.MIN_VALUE_OF_EVENTUAL_TYPE 但它不存在。

Answer 10

您可以创建一个包装类，为所有类型“添加”最小值和最大值。 它只有两个代表最小值和最大值的静态实例，然后其他实例包装某种类型的其他值。 当我们进行比较时，我们检查其中一项是否是最小值或最大值，并返回正确的结果； 否则我们只进行与基础类型相同的比较。 像这样的事情：

class Extended<T extends Comparable<? super T>> implements Comparable<Extended<T>> {
    private Extended() { }

    private static Extended min = new Extended();
    private static Extended max = new Extended();

    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> Extended<T> getMin() {
        return (Extended<T>)min;
    }
    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> Extended<T> getMax() {
        return (Extended<T>)max;
    }

    public T value;

    public Extended(T x) { value = x; }

    public int compareTo(Extended<T> other) {
        if (this == other) return 0;
        else if (this == min || other == max) return -1;
        else if (this == max || other == min) return 1;
        else return this.value.compareTo(other.value);
    }
}