HashMap，定义泛型类，定义泛型方法，定义泛型接口，泛型通配符，Collections工具类，Collection集合总结，Map集合总结

特点

1. 数据结构基于哈希表
2. 并允许使用null值和null键
3. 次实现不是同步的，在多线程中是不同步的
4. 默认初始化容量是16

HashMap与HashSet比较

5. 相同点：都是以哈希表结构类进存储的
6. 不同点：A.HashMap针对 键与对，HashSet只针对的是元素 B.HashSet集合的底层也是使用HashMap类进行存储，只使用HashMap键的作为数据结构

1. 当定义集合的时候，不确定其数据类型，既可以使用泛型，泛型相当于一个"变量”
2. 注意： A. 泛型只能使用引用数据类型，不能使用基本数据类型 B.通配符不能用来继承，没有继承的概念
3. 好处：避免进行强制类型转换、将运行的发生的错误提前至编译期间
4. 泛型使用的符号（一般来说任何的符号都是可以的）

1. 语法：
2. 访问修饰符 class 类名<类型>{

3.  类中所有的成员都可以使用其泛型
   

4. }

package qf22020303.Demo05;

/**
 1. 类定义泛型
 2. @param <T>
 */
public class Demo01<T>{
    private T t;

    public Demo01() {
    }
    public Demo01(T t) {
        this.t = t;
    }
    public T get(T t){
        return t;
    }

    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}

1. 注意：普通方法可以使用类定义的泛型，静态方法不可以，因为静态资源优先加载，需要在在其方法上添加泛型标明才可识别为泛型

package qf22020303;

/**
 *1、方法自定义泛型
 *2、根据类泛型来定义方法泛型
 * @param <K>
 */
class Demo01<K> {

    //无返回值普通方法自定义泛型格式
    public <T> void print(T t) {
    }
    //有返回值普通方法自定义泛型格式
    public <T> T get(T t) {
        return t;
    }
    //无返回值普通方法根据类定义的泛型格式
    public void print(K k1, K k2, K k3) {
    }
    //有返回值普通方法根据类定义的泛型格式
    public K get(K k1, K k2, K k3) {
        return k1;
    }
    //1、静态方法不能用类定义的泛型，因为静态资源优先加载，没标明就识别不了静态方法的泛型
    //2、普通方法可以和静态方法一起覆写
    public static <T> void print(T t1, T t2) {}
}

例子

package qf22020303;

import java.util.Arrays;

/**
 1. 方法定义泛型--实例
 */
public class Demo02 {
    public static void main(String[] args) {
        String[] c = getC(new String[]{"2", "1", "3"}, 0, 1);
        System.out.println(Arrays.toString(c));
        Integer[] c1 = getC(new Integer[]{2, 1, 3}, 1, 2);
        System.out.println(Arrays.toString(c1));
    }

    //定义一个具有泛型的方法，任意引用类型数据交换位置
    public static <T> T[] getC(T[] arr, int index1, int index2) {
        T temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
        return arr;
    }
}

1. 使用类别：A. 在实现类中确定其泛型 B.在实现类中也不确定其泛型
2. 第一种情况：在实现类中确定其泛型

package qf22020303.Demo03;

/**
 * 其子类实现泛型
 * @param <E>
 */
public interface Demo05<E> {
    void get(E e);
}

package qf22020303.Demo03;
public class Demo06 implements Demo05<String>{
    @Override
    public void get(String s) {
        System.out.println(s);
    }
}

3. 第二种情况：在实现类中不确定其泛型

package qf22020303.Demo03;

/**
 * 接口定义泛型
 */
public interface Demo03<T>{
    T getFirst(T[] arr);
}

package qf22020303.Demo03;

/**
 * 实现类也不确定其泛型
 * @param <T>
 */
public class Demo04<T> implements Demo03<T>{
    @Override
    public T getFirst(T[] arr) {
        return arr[0];
    }
}

1. 概念：A.泛型通配符可以表示任意的数据类型，其符号？来表示。B.泛型通配符一般用作为方法使用，不能在实例化对象的时候使用。

package qf22020303.Demo04;

import java.util.List;

/**
 * 1、通配符的使用
 * 2、使用方式：一般用在方法上，（限制方法中参数定义的范围）不能定义在类上
 */
public class Demo01{
    public static void main(String[] args) {

    }
    //输入的类型只能是本身或是子类
    public void get(List<? extends Number> list){

    }
    //输入的类型只能是其本身或其父类
    public void get1(List<? super Number> list){

    }
}

1. 结合工具类的常用方法

2. 

3.