泛型使用，测试

泛型有很多让人不能很好理解的东西，我在自己的笔记里有总结，不过保存成doc格式了，不能传上来了。

下面就只把我的测试写出来吧，主要是怎样正确使用泛型

ok表示 编译可通过

error表示 不能

ok,error在一Block前是表示这个Block都ok/error,除了几个特别标注的：

　　　　//true
        List<Object> list2 = new LinkedList<Object>();
        list2.add(new String("abc"));
        list2.add(new Integer(1));
        
        //error
        List<?> list3 = new LinkedList<Object>();//ok
        list3.add(new String("abc"));
        list3.add(new Integer(1));
        
        list3.get(0);//ok
        list3.clear();//ok
        list3.contains(new Object());//ok
        list3.addAll(null);//ok 还没测试能不能运行
        list3.addAll(new LinkedList<Object>());//error
        

        //List<?>也是无法调用addAll的，addAll这时候提示添加Collection<? extends ?>也可以看出编译器也不能确定类型，这样就不能使用这个方法了    
        
        list3.removeAll(null);//true;
        list3.removeAll(new LinkedList<Object>());
        //因为removeAll的参数是Collection<V>
        
        
        //error
        List<? extends Object> list32 = new LinkedList<Object>();//ok
        list32.add(new String("abc"));
        list32.add(new Integer(1));
        
        //error
        List<?> list4 = new LinkedList<?>();//LinkedList<?>、LinkedList<? extends Object>_error
        list4.add(new String("abc"));
        list4.add(new Integer(1));
        
        //ok
        LinkedList<Object> list5 = new LinkedList<String>();//error
        list5.add(new String("abc"));
        list5.add(new Integer(1));
        
        //ok
        List<Number> n = new ArrayList<Number>();
        n.add(new AtomicInteger(0));
        n.add(new Integer(0));
        n.add(new Float(0));
        List<Integer> adder = new ArrayList<Integer>();
        adder.add(new Integer(0));
        n.addAll( adder);

就是这样。

下面是我用泛型写的一个求不同类型max的函数，有做效率测试和分析，不知道有没有其他的方法来求，但是我只能想到这些简单的。希望大家来喷，或者指导我：

　　public static <T extends Number, E extends Number> double max(T t,E e){
        return ((t.doubleValue() - e.doubleValue())>0?t.doubleValue():e.doubleValue());
    }
    //最不好，因为Double.valueOf()时，又新建了一个Double
    public static <T extends Object, E extends Object> double max1(T t,E e){
        return     (
                    Double.valueOf(t.toString()).doubleValue() 
                        - 
                        Double.valueOf(e.toString()).doubleValue()>0
                    ?
                        Double.valueOf(t.toString()).doubleValue() 
                    :
                        Double.valueOf(e.toString()).doubleValue()
                );

    }
    //费时间
    //字符型：
    //    char占2个字节
    //    整型：
    //    short占2个字节
    //    int占4个字节
    //    long占8个字节
    //    浮点型：
    //    float占4个字节
    //    double占8个字节
    //    布尔型：
    //    boolean占2个字节
    //
    //    汉字占2个字节
    //  引用占4个字节(32位)
    
    public static <T extends Object, E extends Object> double max2(T t,E e){
        Double t1 = Double.valueOf(t.toString());
        Double e1 = Double.valueOf(e.toString());
        return t1.doubleValue()>e1.doubleValue()?t1.doubleValue():e1.doubleValue();
    }
    //费空间
    public static <T extends Object, E extends Object> double max3(T t,E e){
        double t1 = Double.valueOf(t.toString()).doubleValue();
        double e1 = Double.valueOf(e.toString()).doubleValue();
        return t1>e1?t1:e1;
    }

每个调用10000000次的时间是这样的：

max 183
max1 3365
max2 2336
max3 2328

第一个是只能比较Number肯定会比下面的效率要好很多。

转载于:https://www.cnblogs.com/blogonfly/articles/4129546.html