如何在這種情況下聲明Java Comparable

Question

這是我正在研究的課程：

public class Thing<T extends Comparable<? super T>> {
   private Map<String, List<SourcedValue<T>>> properties;
}

然后， SourcedValue是這樣的：

public class SourcedValue<T extends Comparable<? super T>> 
                         implements Comparable<****?*****> {
  private T value;
  private List<Sources> sources;

  @Override
  public int compareTo(SourcedValue<****?****> other) {
    return value.compareTo(other);
  }
}

我怎么把***?*** ？

我需要做的是在一些轉換方法中對Thing中的List<SourcedValue<T>>進行排序，該方法創建Thing並填充其properties （以及每個屬性的List<SourcedValue<T>> ）。

Answer 1

我不確定這是否會對您有所幫助，但這是我實現您的要求的一種方式。 如果這有助於你，我會很高興的。

public class SourcedValue<T extends Comparable<? super T>>
    implements Comparable<SourcedValue<? super T>> {
private T value;
private List<Integer> sources;

@Override
public int compareTo(SourcedValue<? super T> o) {
    return value.compareTo((T)o.value);
    }
}

此處使用super似乎也是多余的。 即使是以下解決方案也應該產生相同的結果

public class SourcedValue<T extends Comparable<T>>
    implements Comparable<SourcedValue<T>> {
private T value;
private List<Integer> sources;

@Override
public int compareTo(SourcedValue<T> o) {
    return value.compareTo(o.value);
}
}

Answer 2

這是我可能會這樣做的：

TypedProperty.java

/**
 * A TypedProperty class - more than String.
 * @link https://stackoverflow.com/questions/56498727/how-to-declare-java-comparable-in-this-situation
 */
public class TypedProperty<T extends Comparable<T>> implements Comparable<TypedProperty<T>> {

    private final T value;
    private final Class<T> type;

    public TypedProperty(T value, Class<T> clazz) {
        this.value = value;
        this.type = clazz;
    }

    public T getValue() {
        return value;
    }

    public Class<T> getType() {
        return type;
    }

    @Override
    public int compareTo(TypedProperty<T> other) {
        return this.value.compareTo(other.value);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        TypedProperty<?> that = (TypedProperty<?>) o;

        if (!getValue().equals(that.getValue())) return false;
        return getType().equals(that.getType());
    }

    @Override
    public int hashCode() {
        int result = getValue().hashCode();
        result = 31 * result + getType().hashCode();
        return result;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("TypedProperty{");
        sb.append("value=").append(value);
        sb.append(", type=").append(type);
        sb.append('}');
        return sb.toString();
    }
}

一個JUnit測試來證明它的工作原理：

import org.junit.Assert;
import org.junit.Test;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.List;

/**
 * @link https://stackoverflow.com/questions/56498727/how-to-declare-java-comparable-in-this-situation
 */
public class TypedPropertyTest {

    @Test
    public void testConstructor_DateTypedProperty() throws ParseException {
        // setup
        String [] testDates = { "2019-06-07", "2018-03-17", "2017-01-01" };
        List<String> expected = Arrays.asList(testDates);
        Collections.sort(expected);
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        List<TypedProperty<Date>> typedProperties = new ArrayList<>();
        for (String testDate : testDates) {
            typedProperties.add(new TypedProperty<>(format.parse(testDate), Date.class));
        }
        // test
        Collections.sort(typedProperties);
        // assert
        for (int i = 0; i < typedProperties.size(); ++i) {
            Assert.assertEquals(format.parse(expected.get(i)), typedProperties.get(i).getValue());
        }
    }
}