泛型的简介

* 为什么要使用泛型？

         - 一般使用在集合上

         ** 比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本事的类型，只能是 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) {}

     }

转载于:https://www.cnblogs.com/fiyxiang/p/5652307.html