泛型简介

为什么使用泛型？

一般使用在集合上

比如说把一个字符串类型值放入集合里面，这个时候，这个值放入集合·之后会失去本身的类型，只能是object类型这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误，怎么解决这个错误，可以使用泛型来解决。

在集合上如何使用泛型

List set map

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

在list上面使用泛型：

ArrayList linkedList Vector这三个区别

//遍历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集合上
    @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);

        }

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

        //第二种  得到key  和value关系

        Set<Entry<String,String>> sets1 = map.entrySet();

        //遍历sets1   增强for

        for (Entry<String, String> entry : sets1) {

            //entry是key 和value关系

            String keyv = entry.getKey();

            String valuev = entry.getValue();

            System.out.println(keyv + ":" + valuev);

        }

    }

写基本数据类型类型对应包装类

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

6泛型使用在方法上用的很多

定义一个数组指定位置交换

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

public static <T> void swap1(T[] arr,int a,int b){

        T temp = arr[a];

        arr[a] = arr[b];

        arr[b] = temp;

    }

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

在类上定义·一个类型这个类型可以在类中直接使用

public class TestDemo04<T> {

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

    T aa;

    public void test11(T bb){

       

    }

   

    //写静态方法  在类上面定义泛型，不能在静态方法里面使用  如要使用需要自己定义

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

       

    }

}

枚举

什么是枚举？

**需要在一定范围内取值，这个值只能是这个范围内中任意一个

**现实场景：交通信号灯有三种颜色每次只能亮三种颜色里面任意一个。

//使用枚举实现枚举的构造方法是私有的

enum Color3{

    RED,GREEN,YELLOW;

}

（简写方式）

class Color2{

    //构造方法私有化

    private Color2(){}

    public static final Color2 RED = new Color2();

    public static final Color2 GREEN = new Color2();

    public static final Color2 YELLOW = new Color2();

   

}

特殊的枚举操作

在枚举里面有构造方法

有抽象方法

9枚举的api操作

**name() : 返回枚举的名称

** ordinal() : 枚举的下标，下表从0开始

**valueOf(Class<T> enumType, String name) ；得到枚举对象

还有两个方法，都是这两个方法不在api里面编译的时候生成的两个方法

valueof(String name) 转换枚举对象

values() 获取所有枚举对象数组

10静态导入（了解）

int[] arr1 = {10,2,1,32,56};

Arrays.sort(arr1);

System.out.println(Arrays.toString(arr1)); 排列

11自动拆装箱 jdk5.0

装箱

把基本数据类型转换成包装类

拆箱

把包转换成基本数据类型

//自动装箱

Integer i = 10;

//自动拆箱

int m = i;

jdk 会向下兼容的

可变参数

* 可变参数

* 如果实现多个方法，这些方法里面的逻辑基本相同，唯一不同的是传递的参数个数，可以使用可变参数

public static void add(int...nums){

        //nums理解为一个数组，这个数组可以存储传递来的参数

        //System.out.println(nums.length);

        //遍历数组

        int sum = 0;

        for(int i = 0;i<nums.length;i++){

            sum += nums[i];

        }

        System.out.println(sum);

       

    }

只能做参数；方法列只能有一个可变参数；方法的参数列表中的可变参数，必须放在参数最后 add(int a;int…nums)