Java泛型应用

泛型是Java SE 5.0版的重要特性，使用泛型编程可以提高代码的重用性。泛型在Java中有比较重要的地位，在面向对象编程以及其他各种设计模式中有非常广泛的应用。

什么是泛型：泛型即是“参数化类型”，也就是将类型由原来具体的类型参数化，类似于方法中的变量参数，此时类型也定义为参数形式。

使用通配符增加泛型

利用泛型类型参数<T>可以将类、方法或接口限制为T类型，但这种方式有个明显缺点就是不够灵活，一旦指定了该类型就不能再修改。这时候可以使用通配符会让代码更加灵活。

例 下面的getMiddleNumber()方法用于获取指定列表的中间值，该方法参数中要求参数的类型是任何Number类型的子集。

public static Object getMiddleNumber(List<? extends Number> list) {

        return list.get(list.size() / 2); //返回中间值

}

    public static void main(String[] args) {

        List<Integer> arrayInt = new ArrayList<Integer>();//整型列表

        arrayInt.add(1);

        arrayInt.add(2);

        arrayInt.add(3);

        arrayInt.add(4);

        arrayInt.add(5);

        System.out.print("整型类型");

        System.out.println(Arrays.toString(arrayInt.toArray()));

        System.out.println("整型列表的中间数：" + getMiddleNumber(arrayInt));

        List<Double> arrayDoubles = new ArrayList<Double>();

        arrayDoubles.add(1.1);

        arrayDoubles.add(2.2);

        arrayDoubles.add(3.3);

        System.out.print("浮点类型：");

        System.out.println(Arrays.toString(arrayDoubles.toArray()));

        System.out.println("浮点列表的中间数：" + getMiddleNumber(arrayDoubles));

    }

泛型中，使用“?”作为通配符，通配符的使用与普通参数类似，通配符也可以利用extends关键字来设置取值上值或下值。

 

运行结果

泛型化的折半查找法

在数据结构中，查找有很多种类型，比如顺序查找、折半查找等。如何使用泛型实现折半查找法。

下面方法使用search()方法在给定的数据中查找指定key的索引。

   public static <T extends Comparable<? super T>>  int search(T[] array, T key) {

        int min = 0; //该变量保存数组的最小索引

        int middle = 0; //该变量保存数组的中间索引

        int max = array.length; //该变量保存数组的最大索引

        System.out.println("中间值：");

        while (min <= max) {

        middle = (min + max) / 2; //获取中间索引

            System.out.print(middle+" ");

//key值大于中间元素，则比较右边

            if (key.compareTo(array[middle]) > 0) {

            min = middle + 1;

            }

//key值小于中间元素，则比较左边

else if (key.compareTo(array[middle]) < 0) {

            max = middle - 1;

            } else {

                System.out.println();

                return middle; //返回对应元素的索引

            }}

        return -1; //没有找到返回-1

    }

    public static void main(String[] args) {

        Integer[] arrayInt = {1,2,3,4,5,6,7,8,9,0};//定义数组

        System.out.println(Arrays.toString(arrayInt));

        System.out.println("元素8所对于的索引序号："+search(arrayInt, 8));

    }

注：折半查找法要求的数据集合中的元素是必须可比较，并各元素按升序或降序排序。取集合的中间元素作为比较对象，则如果指定的值与比较对象相等，查找成功，返回中间元素的序号，但如果指定的值大于比较对象，则会在中间元素的右半段进行查找，若小于比较对象则在中间元素的左半段进行查找。该算法的平均时间复杂度是log2n 

自定义泛型化数组类

在Java虚拟机中没有泛型类型的对象，所有有关泛型的信息都给擦除了，这样导致不能直接创建泛型数组，不过可以使用反射机制来创建一个泛型化的数组。

自定义泛型类

public class MyGeneric<T> {

    private T[] array; //类型为T的数组

    private int size; //数组长度

    public MyGeneric(Class<T> type, int size) {

        this.size = size;

//利用反射根据指定的类型和长度创建泛型数组

        array = (T[]) Array.newInstance(type, size);

}

    public void put(int index, T item) {//数组添加方法

        if (size > index) {

            array[index] = item;

        }

    }

    //获取数组中元素

    public T get(int index) {

        if (size > index) {

            return array[index];

        } else {

            return null;

        }

    }

}

@Test

public  void test() {

  System.out.println("String数组");

  MyGeneric<String> stringArray = new MyGeneric<String>(String.class, 10);

  stringArray.put(0, "测试字符串");

  System.out.println("String数组" + stringArray.get(0));

  System.out.println("Integer数组");

  MyGeneric<Integer> integerArray = new MyGeneric<Integer>(Integer.class, 10);

  integerArray.put(0, 147258369);

  System.out.println("Integer数组" + integerArray.get(0));

  }

运行上面的test()方法结果如下