자바 제네릭과 무한대 (비교할 수 있음)

StackOverflow https://stackoverflow.com/questions/803543

문제

타입 정수를 사용하면 다음을 수행 할 수 있습니다.

int lowest = Integer.MIN_VALUE;

제네릭을 사용하면 어떻게해야합니까?

K lowest = <...>;

우선 순위와 유사한 것을 구현하려면이 문제가 필요합니다. 큐에서 제거하고 싶은 노드에 액세스 할 수 있지만 최소가 아닙니다.

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

나는 첫 단계에 붙어있다. 내가 할 수있는 유일한 일은 노드의 키를 현재 최소로 설정하는 것입니다. 충분하지 않습니다.

도움이 되었습니까?

해결책

이것은 말이되지 않습니다 ...

당신이 그 시점에서 K가 무엇인지 모른다는 것을 감안할 때 (즉, 당신은 일반적으로 그것을 구현하고 있습니다 ... duh!) 당신은 그것에 대한 최소/max를 지정할 수 없습니다.

k가 int, long, string 또는 객체 일 수있는 경우, 당신은 당신은

integer.min_value, ""또는 null.

당신이 찾고있는 것은 k.min_value_of_eventual_type이지만 존재하지 않습니다.

다른 팁

일반적인 형태는 없습니다 MIN_VALUE 또는 MAX_VALUE 모든 비슷한 유형에 대해.

a에 대해 생각하십시오 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);
    }
}

어 ... 다시 문제는 무엇입니까?

우선권, 모두처럼 컬렉션, 객체 인스턴스를 제거하다 컬렉션에서.

u는 이것이 k가 무엇인지에 따라 다르지 않습니까?

제네릭의 점은 K가 모든 유형 (또는 특정 유형의 하위 클래스) 일 수 있다는 것입니다. K 또는 액세스 속성에 대한 방법을 호출하려면 와일드 카드로 유형 경계를 제한해야합니다.

객체가 비교할 수 있다고해서 최소 값을 가져야한다는 의미는 아닙니다. int의 최소값은 -(2^(31)) 인 이유는 부호에 1 비트가 필요하기 때문에 2^31은 저장할 수있는 가장 큰 (또는 가장 작은) 정수이기 때문입니다. 문자열과 같은 경우, 가장 큰/가장 작은 문자열이 없기 때문에 메모리 바운드입니다.

인터페이스 "iinfinity"를 만들어야하고 k는 iinfinity를 확장하고 iinfinity를 확장하여 "getInfinityValue ()"방법을 갖고 Iinfinity를 구현하는 클래스에서 정수, 이중, bigdecimal 등을 랩/확장합니다. 그리고 ugh!

기본적으로 모든 유형 k가 일부 정적 함수를 구현하기를 원합니다. 표준 수학적 특성에 따라 가장 낮고 최고라고 말합니다.

나는 가장 낮은 (또는 최고)를 사용하기 위해서는 비슷한 객체가 이러한 방법을 갖기를 원한다고 가정합니다. (또는 정적 필드). 자신의 사용자 정의 객체에만 관심이 있다면,이를 수행하는 방법은 MinValue 및 Max_Value의 정적 필드를 선언 한 추상 데이터 유형에서 모든 것을 상속하는 것입니다. 그러면 유형 변수가 있습니다. 다른 클래스의 경우이 기능이 필요한 경우 다른 클래스에 대해 이러한 속성을 추적하는 외부 해시 맵을 cre4 처리해야합니다.

만들지 않는 것을 고려하십시오 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);
        }
    }

}

간단히 말해서, 새로운 클래스가 인스턴스화 될 때마다 최소 값이 생성되어 각 클래스의 최소 값을 저장하는 정적 해시 맵에 넣습니다. (사실,이 값은 전혀 아무것도 아니고 Sentinel 객체 일뿐입니다. 그러나 우리는 객체 평등을 사용하여 무언가가 최소 값인지 판단하기 때문에 전혀 문제가되지 않습니다.) 필요한 것은 랩핑 된 객체가 비교할 수 있다는 것입니다. 일반적으로 다른 경우에.

한 가지 단점은 전화 할 때입니다 getMinValue 반환 유형에는 일반 정보가 없기 때문에 컴파일러 경고가 있습니다. 이 주위에는 더 우아한 방법이있을 수 있지만 지금은 생각할 수 없습니다.

이 일반적인 아이디어는 전반적으로 다소 좋을 수 있습니다. 그러나 나는 정말로 스트레스를 받아야한다 : 당신이 다형성이나 상호 비슷한 클래스의 혼합으로 그것을 시도하면 이것은 절대적으로 깨질 것이다. Long모래 Integer같은 나무에있는 S는 당신을 완전히 파괴 할 것입니다.

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top