Collection 集合与泛型

第一章 Collection 集合

1、集合和数组

集合和数组的区别?
    A.长度
    	a. 数组的长度是固定的，运行期间不可以改变
    	b. 集合的长度是可变的，可以添加，也可以删除
    B.内容
    	a. 数组可以存储任意类型（基本数据类型和引用数据类型） 
    		//int[] arr1 = new int[3];   
    		//Student[] stuArr = new Student[3];  对象数组
    	b. 集合只能存储对象类型数据
    		//ArrayList<String> list1 = new ArrayList<>();  //字符串对象
    		//ArrayList<Integer> list2 = new ArrayList<>(); //存放的是Integer的对象,自动装箱
    		
推荐的用法:
	后期课程,推荐使用集合
	//数组只是为了引出集合,以及引用数据类型的特点（地址值和默认值）

2、集合的常用方法

1. 增
	public abstract boolean add(E e); //添加元素
2. 删
	public abstract boolean remove(Object o); //删除某个元素
	public abstract void clear(); //删除所有的元素
3. 改
	public abstract Object[] toArray();  //将集合转换成为Object类型的数组
	public abstract <T> T[] toArray(T[] a); //将集合转换成为 具体的某个类型的数组
4. 查
	public abstract boolean contains(Object o);  //查看是否包含某个元素
	public abstract boolean isEmpty(); //判断是否为空
	public abstract int size(); //获取集合的长度大小,存放元素的个数

3、并发修改异常

1. 并发修改异常
	名称: ConcurrentModificationException
	原因: 在使用迭代器遍历集合的过程当中，对集合数据进行 增和删 操作，会导致并发修改异常
	解决: 不要随意在迭代器遍历的过程当中，增删数据
	
2. 生活实例 ---> "修改需求"
	"装修房子". 请装修公司帮我装修房子。在装修到一半的时候，突然我说要换成XXX风格样子.
    "做项目的过程当中，频繁修改需求"

4、集合的三种遍历方式

public static void main(String[] args) {
    //创建集合的对象  左父右子 就是多态
    Collection<String> c = new ArrayList<>();
    //添加数据
    c.add("迪丽热巴");
    c.add("古力娜扎");
    c.add("马尔扎哈");
    c.add("真皮沙发");
    System.out.println("======= [1]方式1:转数组 ====");
    //定义一个数组,数组的类型和集合的泛型一致
    String[] arr = new String[c.size()];
    c.toArray(arr); //转数组
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
    System.out.println("======= [2]方式2:迭代器 ====");
    //快捷键 it itit
    Iterator<String> iter = c.iterator();
    while (iter.hasNext()) {
        String next = iter.next();
        System.out.println(next);
    }
    System.out.println("======= [3]方式3:增强for ===");
    //快捷键 集合名称.for 回车 c.for
    for (String s : c) {
        System.out.println(s);
    }
}

第二章 泛型

1、泛型的概念

1. 为什么要使用泛型？
	我知道这里存在一个数据类型，但是不知道具体是什么类型，这里就使用泛型代替它。
	
2. 例如:
	ArrayList 我们知道他可以存放对象。但是不清楚具体需要存放的是什么对象。
	作为 ArrayList 类的作者。Josh Bloch 设计类的时候，定义成为泛型，由使用者（Java程序员）去指明类型。
	
3. 泛型有什么好处？
	A. 好处:
		a. 将运行时期异常提升到编译时期。//例如:ArrayList的add方法如果使用泛型，存放数据的时候,可以校验
        b. 避免了类型转换异常。 //类型转换异常,向下转型的时候出现的异常 ClassCastException
    B. 缺点:
		刚开始写代码的时候，比较麻烦。 //例如： ArrayList 创建对象的时候,需要写上尖括号,写上具体的类型

2、泛型类

泛型类的定义

//在类的后面加上尖括号就是泛型
//泛型类的定义
public class Car<NIUBEA> {
    //定义变量
    private NIUBEA nb;

    public NIUBEA getNb() {
        return nb;
    }

    public void setNb(NIUBEA nb) {
        this.nb = nb;
    }
}

泛型类的使用

//测试类
//泛型类的使用
public class Test {
    public static void main(String[] args) {
        //想一想: ArrayList 如何使用泛型?
        //在创建对象的时候,指明具体的数据类型
        Car<String> c1 = new Car<>();
        c1.setNb("玛莎拉蒂");
        String nb1 = c1.getNb();
        System.out.println("nb1 = " + nb1); //nb1 = 玛莎拉蒂
        System.out.println("===========================");
        //在创建对象的时候,指明具体的数据类型
        Car<Double> c2 = new Car<>();
        c2.setNb(288.88);
        Double nb2 = c2.getNb();
        System.out.println("nb2 = " + nb2); //nb2 = 288.88
    }
}

3、泛型方法

泛型方法的定义

//狗吧类
//泛型方法的定义
public class DogBa {
    //定义泛型方法
    public static <HEHE> void method(HEHE hehe){
        //打印信息
        System.out.println(hehe);
        //获取字节码的对象
        System.out.println(hehe.getClass());
    }
}

泛型方法的使用

//测试类
//泛型方法的使用
public class Test {
    public static void main(String[] args) {
        DogBa.method("嘿嘿,你看的到我吗?");
        //嘿嘿,你看的到我吗?
        //class java.lang.String
        System.out.println("===========================");
        DogBa.method(666);
        //666
        //class java.lang.Integer
        System.out.println("===========================");
        DogBa.method(3.14F);
        //3.14
        //class java.lang.Float
    }
}

4、泛型接口

泛型接口的定义

//动物接口. 泛型接口
public interface IAnimal<SUIBIAN> {
    //定义的抽象方法
    public abstract void eat(SUIBIAN sb);
}

泛型接口的使用

//使用方式1: 把儿子变成泛型类,创建儿子对象的时候,指定具体类型
public class Ma<SUIBIAN> implements IAnimal<SUIBIAN> {
    @Override
    public void eat(SUIBIAN sb) {
        System.out.println(sb);
        System.out.println(sb.getClass());
    }
}

//使用方式2: 把儿子变成具体的类型
public class Lu implements IAnimal<String>{
    @Override
    public void eat(String sb) {
        System.out.println(sb);
        System.out.println(sb.getClass());
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //方式1: 创建子类/实现类 对象的时候,指定具体的类型
        Ma<String> make = new Ma<>();
        make.eat("菠萝");
        //菠萝
        //class java.lang.String
        System.out.println("-----");
        Ma<Integer> madongmei = new Ma<>();
        madongmei.eat(666);
        //666
        //class java.lang.Integer
        System.out.println("==========");
        //方式2: 直接创建实现类的对象,实现类,已经指定具体的类型
        Lu luhan = new Lu();
        luhan.eat("饭饭");
        //饭饭
        //class java.lang.String
    }
}

5、泛型通配符

1. 通配符是 ?
    不知道具体是什么泛型的时候，采用泛型通配符?
    主要使用在方法上面。//不知道List当中具体的泛型是什么，可以使用?去代替它
    例如:  public static void printList(List<?> list){ .... }  

2. 泛型的上限和下限  Integer extends Number extends Object //不管是上限还是下限，自己都是可以传入
	A. 上限: 可以是儿子,也可以是自己
		 public static void printList(List<? extends Number> list){ .... }  
		//这里可以传入的是 Number 以及 Number 的子类(Number\Integer)
	B. 下限: 可以是父亲,也可以是自己
		public static void printList(List<? super Number> list){ .... }  
		//可以传入的是 Number 以及 Number 的父类（Number\Object）