集合框架详解之List接口实现类及泛型

最新推荐文章于 2024-07-24 15:12:14 发布

草原灰太狼666

最新推荐文章于 2024-07-24 15:12:14 发布

阅读量184

点赞数

文章标签： list java 数据结构

本文链接：https://blog.csdn.net/qq_60501861/article/details/125947870

版权

集合框架

1.集合概念

什么是集合
- 概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。

和数组的区别：
- 1.数组长度固定，集合长度不固定。
- 2.数组可以存储基本类型和引用类型，集合只能存储引用类型。
位置：Java.until.*
Collection体系集合结构图

集合的应用场合：
- 前后端数据库交互，党需要将相同结构的个体整合到一起的时候，需要集合。
- 实际应用场合：购物网站、招聘网站、邮件等等

2.Collection接口

2.1Collection接口概述

子接口：List接口，Set接口
- List接口的特点：有序、有下标、元素可重复（ArrayList、LinkedList、Vector）
- Set接口的特点：无序、无下标、元素不能重复（HashSet、TreeSet (在SortedSet下)）
- Collection父接口特点：代表一组任意类型的对象，无序，无下标，不能重复。

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

方法：
- boolean add(Object obj)//添加一个对象
- boolean remove(Object o)//在此集合中移除对象o
- boolean addAll(Collection c)//将一个集合中的所有对象添加到此集合中
- void clear()//清空此集合中的所有对象
- boolean contains(Object o)//检查此集合中的是否包含o对象
- boolean equals(Object o)//比较此集合是否与指定集合相等
- boolean isEmpty()//判断此集合是否为空
- int size()//返回此集合中元素的数量
- Object[] toArray()//将此集合转换成数组

2.2iterator迭代器

方法：
- boolean hasNext()//判断是否还有下一个元素
- E next()//取出当前元素
- void remove()//删除当前元素

2.21 Collection接口的使用简单代码演示

package collection.demo01;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
Collection接口的使用
 * （1）添加元素
 * （2）删除元素
 * （3）遍历元素
 * （4）判断

*/

public class CollectionTest {
    public static void main(String[] args) {
        //创建集合
        Collection arrayList = new ArrayList();
        //增加元素
        arrayList.add("西瓜");
        arrayList.add("苹果");
        arrayList.add("香蕉");
        System.out.println("集合的长度"+arrayList.size());
        System.out.println(arrayList);
        //删除元素
        arrayList.remove("苹果");
        System.out.println(arrayList);
        //arrayList.clear();
        //System.out.println("清空之后：" + arrayList.size());


        //遍历元素
        //遍历使用高级 for
        System.out.println("------------使用增强for----------------");
        for (Object o : arrayList) {
            System.out.println(o);
        }

        //使用迭代器（迭代专门用来遍历集合的一种方式）
        //hasNext():有没有下一个元素
        //next(): 获取下一个元素
        //remove(): 删除当前元素
        System.out.println("------------使用迭代器----------------");
        Iterator iterator = arrayList.iterator();

        while (iterator.hasNext()){
            String next =(String) iterator.next(); //强转
            System.out.println(next);
            //arrayList.remove(next);  // 迭代器迭代中无法使用 collection 的方法，会产生并发修改异常，若想删除当前元素，使用迭代器中的remove方法
            //iterator.remove();  // 可以使用it.remove(); 进行移除元素

        }
        System.out.println(arrayList.size());

        //判断
        System.out.println("是否为空：" + arrayList.isEmpty());
        System.out.println(arrayList.contains("西瓜"));


    }
}

运行结果

集合的长度3
[西瓜, 苹果, 香蕉]
[西瓜, 香蕉]
------------使用增强for----------------
西瓜
香蕉
------------使用迭代器----------------
西瓜
香蕉
2
是否为空：false
true

2.22 Collection接口的使用保存学生信息代码演示

package collection.demo01;

import java.util.Objects;

//Student  学生类
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //重写equals方法
    @Override
    public boolean equals(Object o) {
        //1.判断是不是同一个对象
        if (this == o) return true;
        //2.判断是否为空，判断是否是同一个类型
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;

        return age == student.age &&
                Objects.equals(name, student.name);
    }
    /*
     public boolean equals(Object o) {
     //1.判断是不是同一个对象
        if(this==o){
            return true;
        }
        //2.判断是否为空
        if(this==null){
            return false;
        }

        //3.判断是否是同一个类型
        if(o instanceof  Student){
            Student s = (Student)o;
            //4.比较属性
            if (this.name.equals(s.getName()) && this.age==s.getAge()){
                return true;
            }
        }
        //5.不满足条件返回false
        return  false;
    }




    */



    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

package collection.demo01;

import oopdemo01.demo02.Studen;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 * Collection的使用，保存学生的信息
 * @author dl
 */

public class CollectionTest2 {
    public static void main(String[] args) {
        //新建Collection对象
        Collection arrayList = new ArrayList();
        Student s1 = new Student("张三", 20);
        Student s2 = new Student("李四", 18);
        Student s3 = new Student("王二", 21);

        //添加数据
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println(arrayList);
        System.out.println("集合的长度："+arrayList.size());

        //删除
        arrayList.remove(s1);
        arrayList.remove(new Student("王二",21));/*这个是新new的 只是和前面的属性相同 和前面的并不是一个东西 并不能删除上面的那一个*/
        //arrayList.clear();

        //遍历
        //1.增强for
        System.out.println("-----------增强for-----------");
        for (Object o : arrayList) {
            Student o1 = (Student) o;
            System.out.println(o1.toString());
        }
        //2.迭代器： hasNext()  next()  remove()  迭代过程中不能使用collection的删除方法
        System.out.println("-----------迭代器-----------");
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Student next =(Student) iterator.next();
            System.out.println(next);
        }

        //判断
        System.out.println(arrayList.contains(s2));
        System.out.println(arrayList.isEmpty());


    }
}

运行结果

[Student{name='张三', age=20}, Student{name='李四', age=18}, Student{name='王二', age=21}]
集合的长度：3
-----------增强for-----------
Student{name='李四', age=18}
-----------迭代器-----------
Student{name='李四', age=18}
true
false

3.List接口与实现类

3.1.List接口

List子接口：List 继承了 Collection父类的所有方法；
- 特点：有序、有下标、元素可以重复
方法：
- 增加：void add(int index,Object o) //在index位置插入对象o
- 删除remove(int index) remove(Object o)
- 修改：set(int index, E element)
- 查看：get(int index)
- 遍历方式：普通for循环、增强for循环、迭代器
- void add(int index, Object o) //在index位置插入元素o
- boolean addAll(int index, Collection c) //将一个集合中的元素添加到此集合中的index位置
- Object get(int index) //返回集合中指定位置的元素
- List subList(int fromIndex, int toIndex) //返回fromIndex和toIndex之间的集合元素

3.1 List子接口的使用代码演示一：

package collection.demo01;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
 * List子接口的使用（一）
 * 特点：1.有序有下标 2.可以重复
 *
 * 1.添加元素
 * 2.删除元素
 * 3.遍历元素
 * 4.判断
 * 5.获取位置
 */
public class ListTest {
    public static void main(String[] args) {
        //创建集合
        List arrayList = new ArrayList();

        //添加元素
        arrayList.add("小米");
        arrayList.add("华为");
        arrayList.add("苹果");
        arrayList.add("一加");
        arrayList.add("三星");

        System.out.println(arrayList);
        System.out.println(arrayList.size());

        //删除元素
        arrayList.remove(0);
        System.out.println("删除之后：" + arrayList.size());
        System.out.println(arrayList.toString());

        //遍历
        //使用for
        System.out.println("==============使用for==============");
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));

        }

        //使用加强for
        System.out.println("=============使用加强for===============");
        for (Object o : arrayList) {
            System.out.println(o.toString());
        }
        //使用迭代器Iterator
        System.out.println("================使用迭代器============");
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //使用列表迭代器listIterator 和Iterator的区别，listIterator可以向前或者向后遍历、添加、删除、修改元素

        //使用列表迭代器从前往后
        System.out.println("=========list迭代器======");
        System.out.println("==============使用列表迭代器从前往后==============");
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.nextIndex()+":"+listIterator.next());
        }

        //使用列表迭代器从后往前
        System.out.println("===============使用列表迭代器从后往前=============");
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previousIndex()+":"+listIterator.previous());

        }

        //判断是否为空
        System.out.println(arrayList.isEmpty());
        //判断是否存在
        System.out.println(arrayList.contains("小米"));
        //返回下标 获取位置
        System.out.println(arrayList.indexOf("苹果"));
        //返回元素
        System.out.println(arrayList.get(3).toString());




    }
}

运行结果

[小米, 华为, 苹果, 一加, 三星]
5
删除之后：4
[华为, 苹果, 一加, 三星]
==============使用for==============
华为
苹果
一加
三星
=============使用加强for===============
华为
苹果
一加
三星
================使用迭代器============
华为
苹果
一加
三星
=========list迭代器======
==============使用列表迭代器从前往后==============
0:华为
1:苹果
2:一加
3:三星
===============使用列表迭代器从后往前=============
3:三星
2:一加
1:苹果
0:华为
false
false
1
三星

3.12 List子接口的使用代码演示二：

package collection.demo01;

import java.util.ArrayList;
import java.util.List;
/**
 * List子接口的使用（二）
 * 1.添加元素
 * 2.删除元素
 * 3.遍历元素
 * 4.判断
 * 5.获取位置
 */
public class ListTest2 {
    public static void main(String[] args) {
        //创建集合
        List list = new ArrayList();

        //添加数字数据（自动装箱）
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        list.add(70);

        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());

        //删除
        // list.remove(0);//根据下标

        //list.remove(0);
        //list.remove((Object) 20);
        list.remove(new Integer(20));//如果直接写20的话 这里会报错 因为超出下标范围了 所以要将20装箱 这样才能找到从而删除

        // 可以用 new 删除是因为如下代码，使用的整数已经被缓存，优先查找，引用的地址相同
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1.equals(integer2)); // true

        System.out.println(list.toString());

        //补充方法 subList()   返回子集合,含头不含尾
        List list1 = list.subList(1, 3);
        System.out.println(list1.toString());



    }

}

运行结果

元素个数：6
[20, 30, 40, 50, 60, 70]
true
[30, 40, 50, 60, 70]
[40, 50]

3.2. List实现类->ArrayList

ArrayList:
- 数组结构实现，查询快、增删慢；
- JDK1.2版本，运行效率快、线程不安全
源码分析：
- 源码类似：StringBuilder
- ArrayList实现类底层有两个基本要素：（1）Object类型的数组elementData，（2）size：数组的有效长度
- JDK1.7源码：底层数组，在调用构造器的时候，数组长度初始化为10；扩容时，扩展为原数组的1.5倍。
- JDK1.8源码：底层数组，在调用构造器时，底层数组为{0}，在调用add方法后底层数组才重新赋值新数组，新数组的长度为10–>节省了内存，在add后才创建长度为10的数组。
- ArrayList al = new ArrayList();在调用空构造器的时候，底层elementData数组的初始化为{}空;

3.21 ArrayList的使用代码演示：

package collection.demo01;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
/**
 * ArrayList的使用
 * 特点：有序、有下标、元素可以重复
 * 存储结构：数组、查找遍历速度快，增删速度慢
 *
 */
public class ArrayListTest {
    public static void main(String[] args) {
        //创建集合
        ArrayList arrayList = new ArrayList<>();

        //添加元素
        Student s1 = new Student("刘德华", 20);
        Student s2 = new Student("张学友", 21);
        Student s3 = new Student("郭富城", 22);
        Student s4 = new Student("张卫健", 18);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);

        System.out.println("元素个数:"+arrayList.size());
        System.out.println(arrayList.toString());
        //删除元素
        //根据学生类删除
        //arrayList.remove(s1);

        //根据下标删除
        //arrayList.remove(1);

        //特别注意的是下面这种做法 并不能删除元素 默认对比的是地址 当然我们自己可以重写equals 重写之后就可以正常删除了
        arrayList.remove(new Student("刘德华", 20));//重写 equals  可以删除
        System.out.println(arrayList.toString());


        //遍历元素
        System.out.println("===================使用迭代器==================");

        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Student next =(Student) iterator.next();
            System.out.println(next.toString());
        }

        //使用列表迭代器

        ListIterator listIterator = arrayList.listIterator();
        System.out.println("===================使用列表迭代器==================");
        //从前往后遍历
        while (listIterator.hasNext()){
            Student next =(Student) listIterator.next();
            System.out.println(next.toString());

        }

        System.out.println("===================使用列表迭代器逆序==================");
        //从后往前遍历
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }

        //判断元素
        System.out.println(arrayList.contains(s2));
        System.out.println(arrayList.isEmpty());

        //查找元素
        System.out.println(arrayList.indexOf(s2));
        System.out.println(arrayList.get(1).toString());
    }
}

运行结果

元素个数:4
[Student{name='刘德华', age=20}, Student{name='张学友', age=21}, Student{name='郭富城', age=22}, Student{name='张卫健', age=18}]
[Student{name='张学友', age=21}, Student{name='郭富城', age=22}, Student{name='张卫健', age=18}]
===================使用迭代器==================
Student{name='张学友', age=21}
Student{name='郭富城', age=22}
Student{name='张卫健', age=18}
===================使用列表迭代器==================
Student{name='张学友', age=21}
Student{name='郭富城', age=22}
Student{name='张卫健', age=18}
===================使用列表迭代器逆序==================
Student{name='张卫健', age=18}
Student{name='郭富城', age=22}
Student{name='张学友', age=21}
true
false
0
Student{name='郭富城', age=22}

3.3 List实现类->Vector

Vector:
- 数组结构实现，查询快、增删慢；
- JDK1.0版本，运行效率慢、线程安全。
与ArrayList实现类的对比：
- 联系：底层都是数组的扩容
- 区别：（1）ArrayList底层扩容长度时原数组的1.5倍，线程不安全 -->效率高（2）Vector底层扩容长度时原数组的2倍，线程安全–> 效率低（已淘汰）

3.31 Vector集合的使用代码演示：

package collection.demo01;

import java.util.Enumeration;
import java.util.Vector;
/**
 * Vector集合的使用
 * 存储结构：数组
 *
 */
public class VectorTest {
    public static void main(String[] args) {
        //创建集合
        Vector objects = new Vector<>();

        //1.添加元素
        objects.add("西瓜");
        objects.add("芒果");
        objects.add("草莓");
        objects.add("菠萝");

        //2.删除
        //objects.remove("西瓜");.
        //objects.remove(0);
        //objects.clear();

        //3.遍历
        //使用枚举器
        Enumeration elements = objects.elements();
        while (elements.hasMoreElements()){
            String o = (String) elements.nextElement();
            System.out.println(o.toString());
        }

        //4.判断
        System.out.println(objects.isEmpty());
        System.out.println(objects.contains("菠萝"));

        //5.其他方法
        System.out.println(objects.firstElement());
        System.out.println(objects.lastElement());
        System.out.println(objects.elementAt(1));

    }
}

运行结果

西瓜
芒果
草莓
菠萝
false
true
西瓜
菠萝
芒果

3.4 List实现类->LinkedList

LinkedList:
- 链表结构(双向链表)实现，增删块、查询慢。
ArrayList和LinkedList的区别：
- ArrayList：必须开辟连续空间，查询快，增删慢。
- 物理结构：紧密结构逻辑结构：线性表（数组）
- LinkedList：无需开辟连续空间，查询慢，增删快。
- 物理结构：跳转结构逻辑结构：线性表（链表，双向链表）

3.41 LinkedList的使用代码演示：

package collection.demo01;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
/**
 * LinkedList的使用
 * 存储结构：双向链表
 *
 */
public class LinkedListTest {
    public static void main(String[] args) {
        //创建集合
        LinkedList objects = new LinkedList<>();

        //1.添加元素
        objects.add("成龙");
        objects.add("星驰");
        objects.add("德华");
        objects.add("润发");

        //2.删除
        System.out.println("元素个数:"+objects.size());
        System.out.println(objects.toString());


//        objects.remove(1);
//        objects.clear();
//

        //3遍历
        //3.1for遍历

        for (int i = 0; i <objects.size() ; i++) {
            System.out.println(objects.get(i));

        }

        //3.2增强for
        for (Object object : objects) {
            Student object1 =(Student)object;
            System.out.println(object1.toString());

        }

        //3.3迭代器
        Iterator iterator = objects.iterator();
        while (iterator.hasNext()){
            Student next =(Student) iterator.next();
            System.out.println(next.toString());
        }

        //3.4 列表迭代器
        ListIterator listIterator = objects.listIterator();
        while (listIterator.hasNext()){
            Student next = (Student) listIterator.next();
            System.out.println(next.toString());
        }


        //4.判断
        System.out.println(objects.isEmpty());
        System.out.println(objects.contains("润发"));

        //5.查询
        System.out.println(objects.indexOf(1));


    }
}

运行结果

元素个数:4
[成龙, 星驰, 德华, 润发]
成龙
星驰
德华
润发

4.泛型

4.1.泛型概述

引言
- 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决，因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的。因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。
- 如果不使用泛型的话，有缺点：一般我们在使用的时候基本上往集合中存入的都是相同类型的数据 —>便于管理，所以现在什么引用数据类型都可以存入集合—>不方便！
- 加入泛型的优点：在编译时期就会对类型进行检查，不是泛型对应的类型就不可以添加入这个集合。
Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。

常见形式有泛型类、泛型接口、泛型方法。

语法：
<T,…>T称为类型占位符，表示一种引用类型。
好处：
- 提高代码的重用性
- 防止类型转换异常，提高代码的安全性

4.11 泛型类代码演示：

package collection.demo02;
/**
 * 泛型类
 * 语法：类名<T>
 * T是类型占位符，表示一种引用类型，编写多个使用逗号隔开
 *
 */
public class MyGeneric<T> {
    //1.创建泛型变量
    //不能使用new来创建，因为泛型是不确定的类型，也可能拥有私密的构造方法。
    T t;

    //2.泛型作为方法的参数
    public void show(T t){
        System.out.println(t);
    }
    //泛型作为方法的返回值

    public T getT(){
        return t ;
    }
}


//使用泛型类来创建对象
//使用泛型类
 class MyGenericTest {
    public static void main(String[] args) {

        //使用泛型类创建对象
        // 注意： 1. 泛型只能使用引用类型
        //		2. 不用泛型类型对象之间不能相互赋值

        MyGeneric<String> stringMyGeneric = new MyGeneric<>();
        stringMyGeneric.show("一定要加油");
        stringMyGeneric.t="an";
        String t = stringMyGeneric.getT();

        //使用Integer类型
        MyGeneric<Integer> integerMyGeneric = new MyGeneric<>();
        integerMyGeneric.t=50;
        integerMyGeneric.show(50);
        Integer t1 = integerMyGeneric.getT();


    }

}

运行结果

一定要加油
50

4.12 泛型接口代码演示：

package collection.demo02;
/**
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能创建泛型静态常量
 * T表示类型占位符，表示一种引用类型，可编写多个用，隔开
 */
public interface MyInterface<T> {
    //创建常量
    public static final String name="xiaoming";

     public abstract  T service (T t);


}

package collection.demo02;
/**
 * 实现类：实现接口时确定泛型类
 */
public class MyInterfaceImpl implements MyInterface<String>{

    @Override
    public String service(String s) {
        System.out.println(s);

        return s;
    }
}

package collection.demo02;
/**
 * 实现接口时不确定泛型类
 */
//在实现接口时，不确定泛型类型的操作
//将实现类也变成泛型类MyInterfaceImpl2<T>
public class MyInterfaceImpl2<T> implements MyInterface<T>{

    @Override
    public T service(T t) {
        System.out.println(t);
        return t;
    }
}

package collection.demo02;
//测试类:测试接口
public class InterfaceImplTest {
    public static void main(String[] args) {


        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        myInterface.service("heii");

        MyInterfaceImpl2<Integer> integerMyInterfaceImpl2 = new MyInterfaceImpl2<>();
        integerMyInterfaceImpl2.service(200);


    }
}

运行结果

heii
200

4.13 泛型方法代码演示：

package collection.demo02;

/**
 * 泛型方法
 * 语法：<T> 方法返回值
 * 注意调用方法时，类型由传入的数据决定。如传入字符串型数据，则类型即为字符串
 */
public class MyGenericMothed {

    //<T>  声明泛型方法，  T t   作为泛型，参数，   T 作为返回值类型
    //泛型方法，可以是静态也可以是非静态
    //泛型方法的创建
    public <T> T show(T t){


        System.out.println("泛型方法"+t);
        return t;
    }

    public <T> void shou(T t){
        System.out.println("泛型方法无返回值"+t);
    }
}

package collection.demo02;
//泛型方法的使用
public class MothedTest {
    public static void main(String[] args) {


        MyGenericMothed myGenericMothed = new MyGenericMothed();
        //自动装箱，输入的类型是根据你传入的数据类型决定的
        myGenericMothed.show("hello");//数据的类型不用传递，数据的类型由传递的数据来决定
        myGenericMothed.show(200);   //不用方法的重载也能实现类似重载的功能

        myGenericMothed.shou("world");//不用方法的重载也能实现类似重载的功能
        myGenericMothed.shou(300);
        myGenericMothed.shou(3.14);

    }

}

运行结果

泛型方法hello
泛型方法200
泛型方法无返回值world
泛型方法无返回值300
泛型方法无返回值3.14

4.2. 泛型集合

引言
- 之前我们在创建LinkedList类型对象的时候并没有使用泛型，但是进到它的源码中会发现它是一个泛型类，而我之前使用的时候并没有传递，说明java语法是允许的，这个时候传递的类型是Object类，虽然它是所有类的父类，可以存储任意的类型，但是在遍历、获取元素时需要原来的类型就要进行强制转换。这个时候就会出现一些问题，假如往链表里存储了许多不同类型的数据，在强转的时候就要判断每一个原来的类型，这样就很容易出现错误。
概念：参数化类型、类型安全的集合、强制集合元素的类型必须一致；
特点：
- 编译的时候就可以检查，而非运行时抛出异常；
- 访问时，不必类型转换（拆箱）；
- 不同泛型之间引用不能相互赋值，泛型不存在多态；

4.21 泛型集合码演示：

package collection.demo02;

import collection.demo01.Student;

import java.util.ArrayList;
import java.util.Iterator;
/**
 * 泛型集合
 */

public class Testone {
    public static void main(String[] args) {

        //不使用泛型集合必须强转演示
        ArrayList arrayList = new ArrayList<>();

        arrayList.add("小龙虾");
        arrayList.add("大鲤鱼");

        arrayList.add(20);
        arrayList.add(50);

        /*

        //当传入多种类型的数据，会出现类型转换异常
        //Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
        for (Object o : arrayList) {
            String  s1 =(String) o;
            System.out.println(s1.toString());
        }
       */

        //创建集合时就设置为泛型集合，这样就不能再添加其它类型的元素了
        ArrayList<String> arrayList1 = new ArrayList<>();

        arrayList1.add("大吉");
        arrayList1.add("大利");
        arrayList1.add("吉祥");
        arrayList1.add("如意");
        //体现了编译时即可检查，而非运行时抛出异常
        //arrayList1.add(20);  已经提前确定集合元素为String类型，其他类型元素不能继续添加，会报错
        for (String s : arrayList1) {
            System.out.println(s.toString());
        }


        ArrayList<Student> arrayList2=new ArrayList<Student>();
        Student s1 = new Student("刘德华", 20);
        Student s2 = new Student("张学友", 21);
        Student s3 = new Student("郭富城", 22);
        Student s4 = new Student("张卫健", 18);
        arrayList2.add(s1);
        arrayList2.add(s2);
        arrayList2.add(s3);
        arrayList2.add(s4);

        System.out.println("===================增强for遍历==============");
        for (Student student : arrayList2) {
            System.out.println(student.toString());
        }

        System.out.println("===================遍历器遍历==============");
        //可以通过泛型，输出多个不同的数据类型
        Iterator<Student> it = arrayList2.iterator();//迭代器也是泛型的
        while (it.hasNext()){

            //可以省略一步强制类型转换
            Student next = it.next();//不再需要强转
            System.out.println(next.toString());
        }


    }
}

运行结果

大吉
大利
吉祥
如意
===================增强for遍历==============
Student{name='刘德华', age=20}
Student{name='张学友', age=21}
Student{name='郭富城', age=22}
Student{name='张卫健', age=18}
===================遍历器遍历==============
Student{name='刘德华', age=20}
Student{name='张学友', age=21}
Student{name='郭富城', age=22}
Student{name='张卫健', age=18}

————————————————————————————————————————————————————————————————————————————