泛型的简介

* 为什么要使用泛型？

        - 一般使用在集合上

        ** 比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本事的类型，只能是object类型，

        这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误，怎么解决这个问题，可以使用泛型来解决

     

    * 在集合上如何使用泛型

        - 常用集合 list  set  map

        - 泛型语法 集合<String>  比如 List<String>

    * 在泛型里面写是一个对象，String 不能写基本的数据类型 比如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);

            }

 

            System.out.println("=================");

            //使用增强for

            for (String s1 : list) {

                System.out.println(s1);

            }

 

            System.out.println("=================");

            //使用迭代器遍历

            Iterator<String> it = list.iterator();

            while(it.hasNext()) {

                System.out.println(it.next());

            }

 

        * 作业1： ArrayList linkedList  Vector 这三个区别

 

    * 在set上使用泛型

        代码：

        //泛型使用set集合上

        @Test

        public void testSet() {

            Set<String> set = new HashSet<String>();

            set.add("www");

            set.add("qqq");

            set.add("zzz");

            //set.add("qqq");

            //遍历set 有几种方式  两种

            //迭代器  增强for

            //使用增强for遍历

            for (String s2 : set) {

                System.out.println(s2);

            }

            System.out.println("=================");

            //使用迭代器遍历

            Iterator<String> it1 = set.iterator();

            while(it1.hasNext()) {

                System.out.println(it1.next());

            }

        }

     

    * 在map上面使用泛型

        - map结构：key-valu形式

        代码：

        //在map上使用泛型

        @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);

            }

             

            System.out.println("==============");

            //得到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);

            }

        }

 

6、泛型使用在方法上

    * 定义一个数组，实现指定位置上数组元素的交换

    * 方法逻辑相同，只是数据类型不同，这个时候使用泛型方法

    * /*

     * 使用泛型方法 需要定义一个类型 使用大写字母表示 T :这个T表示任意的类型

     * 写在返回值之前  void之前 <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： 实现一个泛型方法，接受任意一个数组，颠倒数组中所有元素

 

7、泛型在类上的使用（了解）

    * 在一个类上定义一个类型，这个类型可以在类里面直接使用

    * public class TestDemo04<T> {

     

    //在类里面可以直接使用T的类型

    T aa;

    public void test11(T bb) {}

     

    //写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用

    public static <A> void test12(A cc) {}

    }