泛型与Java集合

集合是Java中提供的一种容器，可以用来存储多个数据。

数组：存储一组相同类型的数据结构

​ 局限：定长

集合：动态存放多个对象。

​ 动态：集合的大小随着存储的数据量而改变。

​ 多个：0~多个数据

​ 对象：存储类的实例。基本数据类型—>包装类对象。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7MW7do0N-1633501776094)(C:Users24329Desktop集合框架.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dGCS1XOj-1633501776096)(C:Users24329Desktop屏幕截图 2021-10-01 173105.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-exYThUji-1633501776097)(C:Users24329Desktop2.png)]

示例：

class Person{}

public class CollectionDemo {
    public static void main(String[] args) {
        //1.创建对象
        Collection con = new ArrayList();
        //添加元素
        con.add(123);//向上转型，int...>Integer...>Object
        con.add(true);
        con.add("hello");
        con.add(new Person());

        Collection subCol = new ArrayList();
        subCol.add(1);
        subCol.add(2);
        System.out.println("subCol:"+ subCol);

        con.add(subCol);//添加一个集合
        System.out.println("con:"+con);

        //清空
//        con.clear();
        System.out.println("清空之后得到con:"+con);

        //是否包含某个元素
        boolean contains = con.contains("hello");
        System.out.println("是否包含contains:"+contains);

        //equals
        Collection collection = new ArrayList();
        collection.add("1");
        collection.add("2");
        System.out.println("collection:"+ collection);
        boolean equals = subCol.equals(collection);//比较的是内容
        System.out.println("两个集合是否equals："+ equals);

//        con.clear();
//        System.out.println("是否为空："+con.isEmpty());

        //删除某个元素
        con.remove("1");
        System.out.println("删除元素之后："+ con);
        System.out.println("集合里面有多少个元素："+ con.size());

        //集合转数组
        Object[] objects = con.toArray();
        System.out.println("集合转数组："+ Arrays.toString(objects));
    }
}

在程序开发中，经常需要遍历集合中的所有元素。

迭代：即Collection集合元素的通用获取手段，在获取元素之前需要先判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有旧在取出来，一直把集合中的所有元素全部取出，这种取出的方式专业术语上称为迭代。

Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素。而Iterator主要用于迭代访问（即遍历）Collection中的元素。因此Iterator对象也被称为迭代器。

迭代器的常用方法

public Iterator iterator(); //获取集合对应的迭代器，用来遍历集合中的元素。
Iterator接口的常用方法
public E next(); //返回迭代的下一个元素
public boolean hasNext(); //如果仍有元素可以迭代，则返回true
step1:先获取集合上的迭代器
	Iterator it = c1.iterator();
step2:先判断迭代器后是否有数据
	it.hasNext()-->boolean
step3:通过迭代器获取集合的元素
	it.next()-->E

示例：

public class CollectionDemo2 {
    public static void main(String[] args) {
        //1.创建对象
        Collection col = new ArrayList();//可变长度
        //添加元素
        col.add(123); //向上转型，int-->Integer-->Object
        col.add(true);
        col.add("hello");
        //集合的遍历 for
//        for (int i = 0; i < col.size(); i++) {
//            //Collection这个父接口没有与下标相关的方法 所以不用fori循环
//        }
        //foreach
//        for (Object o : col) {
//            System.out.println(o);
//        }
        //迭代器 简化
        Iterator iterator = col.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println("obj:"+obj);
            //不要在迭代的过程中删除元素
            //col.remove("hello"); //java.util.ConcurrentModificationException
            //需要这样用迭代器删除
            iterator.remove();
        }
        System.out.println("col:"+col);
//        //迭代器
//        Iterator iterator = col.iterator();
//        boolean b = iterator.hasNext();
//        if (b) {
//            Object obj = iterator.next();
//            System.out.println("obj:"+obj);
//        }
//
//        b = iterator.hasNext();
//        if (b) {
//            Object obj = iterator.next();
//            System.out.println("obj:"+obj);
//        }
//
//        b = iterator.hasNext();
//        if (b) {
//            Object obj = iterator.next();
//            System.out.println("obj:"+obj);
//        }
//
//        //当判断到第四个元素是否存在的时候，会返回false
        b = iterator.hasNext();
        if (b) {
            Object obj = iterator.next();
            System.out.println("obj:"+obj);
        }
//        Object next = iterator.next(); //java.util.NoSuchElementException
//        System.out.println("next:"+next);

    }
}

集合可以任意存放对象，只要把对象存储集合后，那么这时他们会被提升成Object类型，当我们再取出每一个对象，并且进行相应的操作，这时候就必须采用类型转换。

没有泛型的话，取出来的话，需要向下转型，效率低下，容易产生错误。

泛型：保护数据类型的安全。

语法：

Collection<数据类型> 对象 = new ArrayList();

示例：

Collection c = new ArrayList();
c.add("hello");
c.add("world");
//c.add(123);
System.out.println(c);

定义格式：

修饰符 class 类名<代表泛型的变量>{}

什么时候确定泛型？在创建对象的时候确定泛型

示例：

//定义带有泛型的类
public class Point {
    private T x;
    private T y;
   	//在方法上定义含有泛型的方法
    public static  void getValue(K k){
        System.out.println("k:"+k);
    }
    //在方法上定义含有泛型的方法
    public static  void test(M m){ //
        System.out.println("检测到了静态方法上的泛型："+ m);
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }
}


public class PointTest {
    public static void main(String[] args) {
        //创建对象的时候确定泛型的类型
        Point point = new Point<>();
        point.setX(34);
        point.setY(123);
        System.out.println("---------------");

        Point point2 = new Point<>();
        point2.setX("长34");
        point2.setY("宽12");

        //定义在方法的泛型，在调用时才确定类型
        Point.test("wowo");
        point.test(23);
        Point.getValue(67);
        Point.getValue("zhangsan");
    }
}

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){}

什么时候确定泛型？调用方法时，确定泛型的类型

示例：

    //在方法上定义含有泛型的方法
    public static  void getValue(K k){
        System.out.println("k:"+k);
    }
    
    //在方法上定义含有泛型的方法
    public static  void test(M m){
        System.out.println("检测到了静态方法上的泛型："+ m);
    }
        //定义在方法的泛型，在调用时才确定类型
        Point.test("wowo");
        point.test(23);
        Point.getValue(67);
        Point.getValue("zhangsan");

​

定义格式：

修饰符 interface 接口名<代表泛型的变量> {}

示例：

public interface Door {
    public T getType();
}


class  DoorImpl implements Door  {

    @Override
    public String getType() {
        return null;
    }
}

class  DoorImpl2 implements Door  {

    @Override
    public Integer getType() {
        return null;
    }
}

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以，可以通过通配符表示。但是一旦使用了泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

？：通配符，不确定类型，代表集合中可以存储任意类型的数据。

List :该容器有数据类型Object。

? extends E  确定了上限，集合的泛型，E以及E的子类

? super E   确定了下限，集合泛型，E以及E的父类

示例：

class Person{}
class Student extends Person{}
public class Demo3 {

    //代表可以接受任意类型
    public static void test1(List list) {

    }

    //代表可以接受任意类型
    public static void test2(List