Java学习笔记---泛型

Java学习笔记—泛型

• 泛型的简介
  
  • 为什么要使用泛型？
    
    • 一般使用在集合上：比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值就失去了本身的类型，只能是object类型。这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误。如果想要解决这个问题，就可以是用泛型来解决。
• 在集合上如何使用泛型？
  
  • 常用集合： list set map
  • 泛型语法： 集合<对象> 比如：List<String> list = new ArrayList<String>();
• 在泛型里面写的是一个对象，e.g.String，但不能写基本的数据类型 e.g.int
  
  • 泛型里只能写基本的数据类型对应的包装类
    
    • byte — Byte
    • short — Short
    • int — Integer
    • long — Long
    • float — Float
    • double — Double
    • char — Character
    • boolean — Boolean
• 在List上使用泛型
  
  • List 的三种实现 ArrayList linkedList Vector
  • 代码：

//泛型在list上的使用    @Test    public void testList(){        List<String> list = new ArrayList<String>();        list.add("aaa");        list.add("bbb");        //遍历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());          }           }

• 在set上使用泛型
  
  • 代码

//泛型在set上的使用    @Test    public void TestSetup(){        Set<String> set = new HashSet<String>();        set.add("www");        set.add("sss");        set.add("xxx");        //set.add("xxx");        //遍历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-value形式
  • 代码：

//泛型在map上的使用    @Test    public void testMap(){        Map<String, String> map = new HashMap<String, String>();        map.put("name", "1");        map.put("age", "2");        map.put("sex", "3");        //遍历map 两种方式  （无序）        //获取所有的key，通过key得到value 使用get方法        //获取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 key = entry.getKey();            String value = entry.getValue();            System.out.println(key+":"+value);        }    }

• 泛型使用在方法上
  
  • 定义一个数组，实现指定位置上数组元素的交换
  • 一般在逻辑相同，只是数据类型不同方法上使用泛型方法
  • 如下是一个逻辑相同的方法，没有用泛型方法，如果出现其它类型的数组，需要写更多的swap方法重载

public static void main(String[] args) {        //创建一个数组 实现11 和 13 的位置交换        int[] arr1 = {10,11,12,13,14};        //System.out.println(Arrays.toString(arr1));        swap(arr1,1,3);        //System.out.println(Arrays.toString(arr1));        //创建一个String类型的数组 实现mm和xx之间的位置交换        String[] arr2 = {"aa","mm","ww","xx","zz"};        System.out.println(Arrays.toString(arr2));        swap(arr2, 1, 3);        System.out.println(Arrays.toString(arr2));    }    private static void swap(String[] arr2, int i, int j) {        //定义一个中间变量        String temp = arr2[i];        arr2[i] = arr2[j];        arr2[j] = temp;    }    private static void swap(int[] arr1, int i, int j {        //定义一个中间变量        int temp = arr1[i];        arr1[i] = arr1[j];        arr1[j] = temp;    }

    如下泛型方法：

  /* * 使用泛型方法 需要定义一个类型 使用大写字母来表示  e.g. T ：这个T表示任意的类型 写在返回值之前     * 表示定义了一个类型 这个类型是T 在下面就可以使用这个类型T了     * */    public static <T> void swap(T[] arr,int a,int b){        T temp = arr[a];        arr[a] = arr[b];        arr[b] = temp;    }

• 泛型在类上的使用
  
  • 在类上定义一个泛型，这个泛型可以在类里直接使用
  • 代码：

public class TestDemo<T>(){//在类里面可以直接使用T类型T aa;public void test(T aa){}//在类上定义的泛型，不能在静态方法里面使用。如需使用，需自行定义public static <A> void test2(A bb){}}

• 泛型擦除

  • 泛型只是出现在源代码阶段，当编译之后泛型就不存在了

• 泛型实例：实现一个泛型方法，接受任意类型的数组，颠倒数组中所有的元素

import java.util.Arrays;/** *  * 实现一个泛型方法，接受任意类型的数组，颠倒数组中所有的元素  * @author Administrator * */public class TestDemo {    public static void main(String[] args) {        Integer[] arr1 = {10,12,14,16,25};        System.out.println(Arrays.toString(arr1));        //写方法实现颠倒        reverses(arr1);        System.out.println(Arrays.toString(arr1));        String[] arr2 = {"a","b","c","d","e"};        System.out.println(Arrays.toString(arr2));        reverses(arr2);        System.out.println(Arrays.toString(arr2));    }    public static <T> void reverses(T[] arr) {        /*         * 基本思想：把第一个元素和最后一个元素交换位置，第二个和倒数第二个......         * 交换次数  长度/2         * */        //遍历数组        for(int i = 0;i<arr.length/2;i++){            T temp = arr[i];            arr[i] = arr[arr.length-i-1];            arr[arr.length-i-1] = temp;        }    }}