题

与整数类型的你可以这样做：

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.

我停留在的第一步。我唯一能做的就是设置的关键节点的到当前分钟。不知道这是不够的。

有帮助吗？

解决方案

这没有任何意义......

鉴于你不知道那时K是什么，（即你正在实施它......呃！）你不能指定它的最小/最大界限。

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

Integer.MIN_VALUE，＆quot;＆quot;或者是空。

我猜你要找的是K.MIN_VALUE_OF_EVENTUAL_TYPE但不存在。

其他提示

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

考虑实现可比较的 Time 类。时间没有 MAX_VALUE ，即使它是可比较的。

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

警告：此代码很危险。发表这样的憎恶，请怜悯我。这只是一个概念证明。

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;
        }
    }
}

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

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);
    }
}
呃......又是什么问题？

PriorityQueue ，与所有< a href =“http://java.sun.com/javase/6/docs/api/java/util/Collection.html#remove(java.lang.Object）”rel =“nofollow noreferrer”>集合，允许您使用对象的实例从集合中删除。

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

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

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

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

基本上你希望任何类型K都能实现一些静态函数，比如最低和最高符合标准数学属性。

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

考虑不做 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 你将有编译器的警告，由于返回的类型将没有任何通用的信息。有可能是一个更优雅的方式解决这个问题，但我不认为它现在。

这一一般想法可能是相当不错的整体。然而，我真的应该强调：这绝对会打破，如果你尝试用任何多态性或任何混合的相互比较的类别。 Longs和 Integers在同一棵树就会完全摧毁。

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top