泛型

应用：
1. 类型安全检查
2. 编写通用Java程序

1. 类型安全检查
   JDK5 之前集合对象使用问题：
   （1）向集合添加任何类型对象。
   （2）从集合取出对象时，数据类型丢失，使用与类型相关方法，强制类型转换。
   泛型语法： List<泛型类型> 规定 List集合中元素类型
   泛型技术：只是编译器阶段技术，为javac命令，起到类型安全检查作用，生成.class文件后，泛型信息将会被擦除。
   List— 参数化模型
   例：

public void demo1() {
        // 应用泛型集合
        List<String> list = new ArrayList<String>();// 这个集合只能添加String类型数据
        list.add("泛型集合");
        list.add("指定数据类型");
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);// 取出数据
            System.out.println(s);
        }
    }

可以利用泛型技术对 Map、Set、List进行类型安全检查

1. List: ArrayList和LinkedList
   对List遍历存在三种方法：
   （1）list是有序的可以通过size 和get（index）方法进行遍历
   （2）因为List继承collection接口，可以通过Collection 的iterator进行遍历。
   （3）JDK5引入 foreach循环结构
   例：

@Test
    public void demo2() {
        // 使用类型安全list
        List<String> list = new LinkedList<String>();
        // 使用泛型，只能向list添加 String类型
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        // 遍历list 三种方法
        // 1. 由于list是有序的 通过 size和get方法进行遍历
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("----------");
        // 2. 由于list继承collection接口 通过collection的iterator方法 进行遍历
        Iterator<String> iterator = list.iterator();
        // 遍历iterator 通过迭代器hasNext 和next方法进行遍历
        while (iterator.hasNext()) {
            String s = iterator.next();
            System.out.println(s);
        }
        System.out.println("----------");
        // 3.jdk5 引入foreach循环
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("----------");
    }

1. Set: HashSet 使用hashCode和equals 进行排重
   TreeSet使用compareable中的compareTo进行排重和排序
   对 Set取出遍历有两种方法（因为是无序的，比list少一种方法）
   （1）继承Collection 使用Iterator遍历
   （2）JDK5foreach循环结构

@Test
    public void demo3() {
        // 使用类型安全的set
        Set<String> set = new TreeSet<String>();
        set.add("abc");
        set.add("def");
        set.add("cef");

        // 由于 set是无序的 因此 比list 少了一种方法
        // 1.set继承collection 使用 Iterator进行遍历
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            System.out.println(s);
        }

        // 2.JDK5 引入foreach循环
        for (String s : set) {
            System.out.println(s);
        }
    }

1. Map: 是一个键值对结构 执行两个类型的泛型
   遍历方法两种：
   （1）通过keySet
   （2）通过 EntrySet取出每一个键值对，getKey和getValue

@Test
    public void demo5() {
        // 使用类型安全的map map 是一个键值对结构 执行两个类型的泛型
        Map<String, String> map = new HashMap<String, String>();
        map.put("111", "aaa");
        map.put("222", "bbb");
        // 取出map 两种方法，
        // 1.通过 keyset
        Set<String> keys = map.keySet();
        for (String s : keys) {
            System.out.println(s + ":" + map.get(s));
        }

        // 2.通过map entrySet 获得每一个键值对
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry2 : entrySet) {
            System.out.println(entry2.getKey() + ": " + entry2.getValue());

        }

    }

使用泛型对象进行类型转换时，等号两端对象使用泛型的类型必须一致
2. 编写通用java程序
通常是结合反射技术一起使用
自定义泛型方法
（1）定义泛型方法，必须在方法的返回值前进行泛型类型声明<泛型类型>
使用泛型方法，参数必须是对象类型

@Test
    public void demo7() {
        // 将数组元素进行倒序排列
        Integer[] arr1 = new Integer[] { 1, 2, 3, 4, 5, 6 };
        reverce(arr1);
        System.out.println(Arrays.toString(arr1));
        String[] arr2 = new String[] { "aa", "bb", "cc", "dd", "ee", "ff" };
        reverce(arr2);
        System.out.println(Arrays.toString(arr2));

    }

    // 属于引用传递 不需要返回值
    public <T> void reverce(T[] arr) {
        /**
         * 只需要遍历数组的前一半的元素，然后和后一半元素进行交换
         * 
         * */
        for (int i = 0; i < arr.length / 2; i++) {
            T temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
    }

    @Test
    // 交换数组的位置
    public void demo6() {
        Integer[] arr1 = new Integer[] { 1, 2, 3, 4, 5 };
        ChangePosition(arr1, 1, 3);
        System.out.println(Arrays.toString(arr1));
        String[] arr2 = new String[] { "aa", "bb", "cc", "dd", "ee" };
        ChangePosition(arr2, 1, 3);
        System.out.println(Arrays.toString(arr2));
    }

    // 使用泛型交换数组的通用方法
    public <T> void ChangePosition(T[] arr, int index1, int index2) {
        T temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }

（2）在类名后声明类的泛型，当类使用泛型后，该类中的所有方法都可以使用泛型—在类名后<泛型类型> 不对static方法生效。

public class ArrayUtils<T> {

    public void reverce(T[] arr) {
        /**
         * 只需要遍历数组的前一半的元素，然后和后一半元素进行交换
         * 
         * */
        for (int i = 0; i < arr.length / 2; i++) {
            T temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
    }

    // 使用泛型交换数组的通用方法
    public void ChangePosition(T[] arr, int index1, int index2) {
        T temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }

}

    @Test
    public void demo8() {
        // 测试 泛型类 使用
        /*
         * 在创建工具类对象时，使用泛型String, 这个工具类对象完成对String数组 倒序和 交换
         */
        ArrayUtils<String> arrayutils = new ArrayUtils<String>();
        String[] arr1 = new String[] { "aa", "bb", "cc", "dd" };
        arrayutils.ChangePosition(arr1, 1, 3);
        System.out.println(Arrays.toString(arr1));
        arrayutils.reverce(arr1);
        System.out.println(Arrays.toString(arr1));
    }

3.泛型的高级应用–泛型通配符
？：任意的泛型类型

@Test
    public void demo9() {
        List<String> list = new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        print(list);

        List<Integer> list2 = new ArrayList<Integer>();
        list2.add(111);
        list2.add(222);
        list2.add(333);
        print(list2);
    }

    public void print(List<?> list) {// 泛型类型可以是任意类型 --泛型通配符
        for (Object string : list) {
            System.out.println(string);
        }
    }