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;
        }
    }
}