Question

我正在创建一个实现java.util.List的类。我的班级使用E来表示参数化类型。

我想调用Collections.sort来排序我正在用我的课程包装的内部列表。问题是这需要我的列表具有实现可比较的类型。

与sort方法一样，我希望能够使用比较器，因此我不想强制E成为Comparable的子类。因此，在不使用比较器的构造函数中，我想验证E是否实现了Comparable。

那么，我如何做到这一点，强大的Java巫师？

Answer 1

您需要有两个不同的类或两个构建器方法供编译器检查。

CollectionOfAny<E> {
     CollectionOfAny(Comparator<? super E> comparator) {
     }

     public static <E> CollectionOfAny<E> create(Comparator<? super E> comparator) {
         return new CollectionOfAny<E>(comparator);
     }

     public static <E extends Comparator<E>> CollectionOfAny<E> create() {
         return new CollectionOfAny<E>(NaturalComparator.INSTANCE);
     }
}

CollectionOfComparable<E extends Comparable<E>> extends CollectionOfAny<E> {
     public CollectionOfComparable() {
         super(NaturalComparator.INSTANCE);
     }
}

Answer 2

您想用来查找接口

YourObject.class.getInterfaces();

private E ob;
    public void testComp(){
    ob.getClass().getInterfaces(); //try using this to get the class first
    }

///////////

public class run<E> implements Comparable{
private E ob;

public run(E ob){
    this.ob = ob;
}
public run() {}

public static void main(String[] args) {
        run r = new run<run>(new run()); //add an instance of the parametised object
        r.testComp();
}

@Override
public int compareTo(Object arg0) {
    // TODO Auto-generated method stub
    return 0;
}


public boolean testComp(){
System.out.println(ob.getClass().getInterfaces()[0].toString());
return ob.getClass().getInterfaces()[0].toString().equals("java.lang.Comparable");
}


}

打印出“interface java.lang.Comparable”。

字符串比较是一种解决方法，因为您无法使用instanceof，因为Comparable接口本身需要参数化，但这会检查它是否属于可比较的接口。任何编辑欢迎！

Answer 3

使用工厂方法。几乎在所有方面，工厂方法都优于构造函数。以后可能会返回一个更具体的类型，类型推断在没有Java 7和菱形运算符的情况下工作得很好......你可以为不同的工厂方法需要不同的类型参数边界：

public static <E extends Comparable<? super E>> YourList<E> wrap(List<E> wrapped) {
  return new YourList<E>(wrapped);
}

Answer 4

您可以使用instanceof运算符，如果E实现了Comparable，则object instanceof Comparable将返回true。

Answer 5

喜欢这个吗？

class MyList<E extends Comparable> implements List<E> {
...
}

<强>更新

然后就是这个想法 - 让工厂有两个静态方法：首先生成Comparable实现者的列表，第二个方法生成非Comparable的列表。

以下是示例代码：

public class MyListFactory {
    static class OthersComparator implements Comparable{
        public int compareTo(Object o) {
            return 0;
        }
    }

    public static class MyList<E> {
        private final OthersComparator comparator;

        private final List<E> impl;

        private MyList() {
            this(null);
        }

        private MyList(OthersComparator comparator) {
            this.comparator = comparator;
            impl = new ArrayList<E>();
        }

        public void sort() {
            if (comparator == null) {
            } else {
            }
        }
    }

    static <E extends Comparable> MyList<E> getForComparable(Class<E> aClass) {
        System.out.println("for comparables");
        return new MyList<E>();
    }

    static <E> MyList<E> getForOthers(Class<E> aClass) {
        System.out.println("for non-comparables");
        return new MyList<E>(new OthersComparator());
    }

    public static void main(String[] args) {
        MyListFactory.MyList<Object> l = MyListFactory.getForOthers(Object.class);
        MyListFactory.MyList<Integer> l2 = MyListFactory.getForComparable(Integer.class);
    }
}

Answer 6

没有好办法做到这一点。关闭并继续前进。

如何检查参数化类型的继承？

6 个答案: