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

集合框架

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}



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

更多参考

千峰教育-集合框架详解

posted @ 2022-07-23 15:01  哼哼哈¥  阅读(95)  评论(0编辑  收藏  举报