泛型和枚举

1.泛型的简介

在泛型中写的是一个对象，不能是基本的数据类型（写起对应的包装类）

*List遍历方式：for循环、迭代器、增强for

*set遍历方式：迭代器、增强for（元素无序、不能重复出现）

*在map上使用泛型

  Map（key，value）

  遍历方式：1）获取所有的key，通过key得到value，使用get方法

                    2）获取key和value的关系

package com.dzg.learn.day07;

import org.junit.jupiter.api.Test;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class TestGenericity {

    @Test
    public void testMap(){
        /**
         * 在Map上使用泛型
         */
        Map<String,String> mapsets = new HashMap<String,String>();
        mapsets.put("a","a");
        mapsets.put("b","b");
        mapsets.put("c","c");
        mapsets.put("d","d");

        /**
         * map的遍历方式1:
         *      获取所有的key，通过key值来获取value值
         */
        Set<String> keysets = mapsets.keySet();
        for(String str:keysets){
            System.out.println(str+":"+mapsets.get(str));
        }
        System.out.println("=========");
        /**
         * map的遍历方式2:
         *      获取key和value的关系
         */
        //得到key和value的关系
        Set<Map.Entry<String,String>> sets1 = mapsets.entrySet();
        //遍历sets1
        for (Map.Entry<String,String> entry:
             sets1) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
}

2.泛型方法

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

    @Test
    public void swapElement(){
        Integer arr1[] = {1,2,3,4,5};
        System.out.println(Arrays.toString(arr1));
        swap(arr1,1,3);
        System.out.println(Arrays.toString(arr1));

        System.out.println("============");
        String arr2[] ={"aa","bb","cc","dd"};
        System.out.println(Arrays.toString(arr2));
        swap(arr2,0,3);
        System.out.println(Arrays.toString(arr2));
    }

    /**
     * 泛型交换的方法,T表示任意类型
     * 若不是用泛型的方法，对于不同类型的数组交换数据，需要写出不同的方法（重载）
     * @param arr
     * @param i
     * @param j
     * @param <T>
     */
    public <T>void swap(T[] arr,int i,int j){
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

泛型的擦除：泛型只出现在源代码阶段，当编译之后泛型就不存在了

3.泛型在类上使用（了解）

  

4.枚举的简介

 

***构造方法有参数，在每个实例上都需要传递参数

***在没个枚举类都实现抽象方法

 

package com.dzg.learn.day07;

import org.junit.jupiter.api.Test;

public class TestEnum {

    //知道枚举的对象，得到枚举的名称和下标
    @Test
    public void test1(){
        //得到枚举的对象
        Color color1 = Color.RED;
        //枚举的名称
        String str = color1.name();
        //枚举的下标
        int index = color1.ordinal();
        System.out.println(index +":"+str);
    }
    //根据枚举的名称，得到枚举的对象和名称
    @Test
    public void test2(){
        String name = "GREEN";
        //得到对象
        Color color = Color.valueOf(name);
        //枚举下标
        int index = color.ordinal();
        System.out.println(index+":"+color);
    }

    //知道枚举的下标，得到枚举的名称和对象
    @Test
    public void test3(){
        int index = 2;
        //得到枚举的对象
        Color color[] = Color.values();
        //根据下标得到对象
        Color col = color[index];
        String name = col.name();
        System.out.println(name+":"+col);
    }
}

enum Color{
    RED,GREEN,YELLOW;
}

5.静态导入（了解）

  可以在java类中直接导入静态的常量或者方法,导入之后可以直接使用对应的方法

  import static *******

  import static java.util.Arrays.sort

6.自动拆装箱

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

            八种基本数据类型对应的包装类：int -- Integer 、char --Character 其他的首字母大写

   拆箱：把基本的包装类转换成基本的数据类型

  JDK向下兼容

7.增强for循环

 * 实现Iterable接口

 *map没有实现该接口，list和set实现了

 * 底层就是迭代器，出现为了替代迭代器

8.可变参数：

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

可以使用可变参数。

   数据类型...数组名称（三个点）、必须放在参数列表最后

  add（int...nums）nums相当于一个数组