jdk5.0新特性—— 泛型

目录
    1、泛型的简介
    2、在集合上如何使用泛型（会用）
    3、泛型在方法上使用（会用）
    4、泛型在类上的使用（了解）
====================================================
1、泛型的简介
    为什么要使用泛型？
        一般使用在集合上。
        比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本事的类型，只能是object类型，
    这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误，怎么解决这个问题，可以使用泛型来解决。

2、在集合上如何使用泛型
    常用集合 List、Set、Map
    泛型语法：集合<String> 。 比如：List<String>
    在泛型里面写是一个类，不能写8种原始数据类型。比如 int，应该写基本的数据类型对应包装类。
        byte  --  Byte
        short --  Short
        int   --  Integer
        long  --  Long

        float   --  Float
        double  --  Double
        char    --  Character
        boolean --  Boolean

    在List上使用泛型
    List的三种实现 ArrayList、linkedList、Vector
        代码：
            @Test
            public void testList() {
                List<String> list = new ArrayList<String>();
                list.add("aaa");
                list.add("bbb");
                list.add("ccc");

                //遍历list集合 有几种方式  三种
                //普通for循环、增强for、迭代器
                ========================================
                //普通for循环
                for(int i=0;i<list.size();i++) {
                    String s = list.get(i);
                    System.out.println(s);
                }
                //增强for
                for (String s1 : list) {
                    System.out.println(s1);
                }
                //迭代器遍历
                Iterator<String> it = list.iterator();
                while(it.hasNext()) {
                    System.out.println(it.next());
                }
            }
        作业1： ArrayList、linkedList、Vector 这三个区别

    在Set上使用泛型
        回顾Set的特性：
        代码：
            //泛型使用set集合上
            @Test
            public void testSet() {
                Set<String> set = new HashSet<String>();
                set.add("www");
                set.add("qqq");
                set.add("zzz");

                //遍历set 有几种方式？ 两种
                //增强for、迭代器
            ==============================================
                //使用增强for遍历
                for (String s2 : set) {
                    System.out.println(s2);
                }
                //使用迭代器遍历
                Iterator<String> it1 = set.iterator();
                while(it1.hasNext()) {
                    System.out.println(it1.next());
                }
            }

    在Map上面使用泛型
        map结构：key-valu形式
        代码：
            @Test
            public void testMap() {
                Map<String,String> map = new HashMap<String,String>();
                map.put("aaa", "111");
                map.put("bbb", "222");
                map.put("ccc", "333");

                //遍历map 有几种遍历方式? 两种
                // 1、获取所有的key，通过key得到value 使用get方法
                // 2、获取key和value的关系

                //使用第一种方式遍历：获取所有的key
                Set<String> sets = map.keySet();
                //遍历所有key返回的set
                for (String key : sets) {
                    //通过key得到value
                    String value = map.get(key);
                    System.out.println(key+" : "+value);
                }
                //使用第一种方式遍历：得到key和value的关系
                Set<Entry<String, String>> sets1 = map.entrySet();
                //遍历sets1
                for (Entry<String, String> entry : sets1) {
                    //entry是key和value关系
                    String keyv = entry.getKey();
                    String valuev = entry.getValue();
                    System.out.println(keyv+" : "+valuev);
                }
            }

3、泛型在方法上使用
    使用方法：
        使用泛型方法，需要定义一个类型，一般使用大写字母'T'表示,这个T表示任意的类型.
    <T> 写在返回值位置之前，表示定义了一个类型，这个类型是 T，在下面就可以使用这个'T'类型了。
        public static <T> void swap1(T[] arr ,int a,int b) {
            T temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
        }

    现有需求：定义一个数组，实现指定位置上数组元素的交换
    作业2： 实现一个泛型方法，接受任意一个数组，颠倒数组中所有元素，方法逻辑相同，只是数据类型不同，这个时候使用泛型方法。
        //创建一个Integer类型的数组 实现11和13位置交换
            Integer[] arr1 = {10,11,12,13,14};
            swapData(arr1,1,3);
        //创建一个string类型的数组 实现 aa 和 ff 位置交换
            String[] arr2 = {"aa","bb","cc","dd","ff"};
            swapData(arr2,0,4);

        public static <T> void swapData(T[] arr ,int a,int b) {
            T temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
        }

4、泛型在类上的使用（了解）
    在一个类上定义一个类型，这个类型可以在类里面直接使用
    public class TestDemo04<T> {
        //在类里面可以直接使用T的类型
        T aa;
        public void test11(T bb) {

        }
        //写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用
        public static <A> void test12(A cc) {}
    }