我一直在四处寻找,看看是否能找到可以帮助我解决问题的东西,但直到现在才找到。我有以下类(class):
public interface ISort<T> {
public List<T> sort(List<T> initialList);
}
public abstract class Sort<T> implements ISort<T> {
private Comparator<? super T> comparator;
public Sort(Comparator<? super T> comparator) {
this.comparator = comparator;
}
@Override
public List<T> sort(List<T> initialList) {
ArrayList<T> list = new ArrayList<T>(initialList);
Collections.sort(list, comparator);
return list;
}
}
public abstract class InternalTreeItem<T> {
public abstract String getValue();
}
public class D extends InternalTreeItem<Integer> {
private Integer i;
public D(Integer i) {
this.i = i;
}
@Override
public String getValue() {
return i.toString();
}
public Integer getInteger() {
return i;
}
}
public class DComparator implements Comparator<D> {
@Override
public int compare(D o1, D o2) {
return o1.getInteger() - o2.getInteger();
}
}
public class DSort extends Sort<D> {
public DSort(Comparator<D> comparator) {
super(comparator);
}
public DSort() {
super(new DComparator());
}
}
和测试类:
public class TestClass {
@Test
public void test1() {
List<InternalTreeItem<?>> list= new ArrayList<InternalTreeItem<?>>();
list.add(new D(1));
list.add(new D(10));
list.add(new D(5));
ISort<?> sorter = new DSort();
sorter.sort(list);
}
}
编译器在该行报错
sorter.sort(list);
和状态
The method sort(List<capture#2-of ?>)
in the type ISort<capture#2-of ?>
is not applicable for the arguments
(List<InternalTreeItem<?>>)
好的,几个小时后,在 friend 的帮助下,我们意识到问题在于 Collection # sort(List<T> list, Comparator<? super T> c)
在抽象类 Sort 中,因为我使用了 Comparator<? extends T>
.
我使用泛型,因为我有 2 个模型,一个模型的父类(super class)是 35 个类的通用抽象子类,而第二个模型实际上有 2 个不同的父类(super class),它们合并后又被 35 个类子类化。这些层次结构是给定的,我无法修改它们。
这里的模型很简单,但是你明白了。此外,还有一个工厂,根据 T 的类型返回一个或另一个分类器。
任何人都可以帮助并为我的问题提供解决方案(即对通用列表进行排序;参数类型可以是通用父类(super class)或其子类之一)。
谢谢和最好的问候, 多米
最佳答案
解决此问题的一种方法是为您无法更改的类使用包装类。
因此,在您的示例中,您希望根据整数值对对象 D 的列表进行排序。通过将您的对象放在包装器中,然后将其添加到列表中,您可以公开您希望作为列表排序依据的值。
例如,您可以定义如下接口(interface):
private interface SortableListItem<T> extends Comparable<SortableListItem<T>> {
public T getValue();
}
然后,为D创建一个包装类:
public class DWrapper implements SortableListItem<Integer> {
private D item;
public DWrapper(D item) {
this.item = item;
}
public Integer getValue() {
return item.getInteger();
}
public int compareTo(SortableListItem<Integer> o) {
return getValue().compareTo(o.getValue());
}
}
从这里创建和排序列表非常简单:
D item1= new D(1);
D item2= new D(10);
D item3= new D(5);
DWrapper wrapper1 = new DWrapper(item1);
DWrapper wrapper2= new DWrapper(item2);
DWrapper wrapper3= new DWrapper(item3);
List<SortableListItem<Integer>> sortableList = new ArrayList<SortableListItem<Integer>>();
sortableList.add(wrapper1 );
sortableList.add(wrapper2);
sortableList.add(wrapper3);
Collections.sort(sortableList);
您当然可以让包装类接受更通用的对象 - 关键是每个对象都返回一个值(在本例中为整数),列表可以根据该值进行排序。
关于具有泛型、比较器和排序错误的 Java 类层次结构,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/2107829/