Java集合-Collection集合体系概述

文章目录

    • 一、集合概述及集合框架
      • 1. 对象数组
      • 2. 集合概述
      • 3. 集合的继承体系图
    • 二、Collection集合
      • 1. Collection集合概述
      • 2. Collection集合的增删功能
      • 3. Collection集合的判断与获取功能
      • 4. Collection集合的其他功能
    • 三、List集合
      • 1. List集合概述
      • 2. List集合的特殊方法
      • 3. Listiterator
      • 4. 并发修改异常产生原因及解决方案
    • 四、常见几种数据结构
      • 1. 栈和队列
      • 2. 数组和链表
    • 五、List集合的三个子类 ArrayList、Vector、LinkedList
      • 1. ArrayList集合
      • 2. Vector
      • 3. LinkedList
      • 4. 三个子类使用时选择
      • 5. 集合嵌套

一、集合概述及集合框架

1. 对象数组

  • 概述
    • 一个班级有多个学生,想存储学生的信息,现有一个已经封装好的学生类Student类,如果为每一个学生对象都创建一个变量,那么将会产生相当多的变量,变量的命名及每次变量的调用都会很麻烦,这时候我们就可以声明一个Student类型的数组,将每一个Student对象存储在数组中,调用时使用数组名和索引就可以了
    • 例如
 public static void main(String[] args) {
        //假设Student类是已经设计好的
        Student[] students = new Student[20];
        students[0] = new Student("张三", 17);
        students[1] = new Student("李四", 18);
        //等等,可以继续填下去
    }
  • 数组存储数据的特点
    • 数据类型不限,基本数据类型和引用数据类型(对象)都可以
    • 数组的长度一经确定就不可更改
    • 只能存储同一数据类型的数据

2. 集合概述

  • 概述
    • 与数组一样,集合也是存储和操作数据的一种容器,但集合允许存储不同的数据类型的数据,而且集合的长度可变
  • 集合与数组的异同点
    • 长度
      • 集合长度可变,数组长度定义后就固定了
    • 存储的数据类型
      • 集合只能存储引用数据类型,数据基本类型和引用类型都可以
    • 存储的数据内容
      • 数组只能存储定义时声明的那种类型的数据,集合没有限制

3. 集合的继承体系图

  • 集合的继承体系图
    Java集合-Collection集合体系概述_第1张图片

二、Collection集合

1. Collection集合概述

  • Collection集合概述
    • Collection层次结构的根接口,Collection接口表示一组对象,这些对象也叫做Collection接口的元素。JDK并不直接提供此接口的实现,因为有更具体的子接口去实现,Collection接口通常只传递有最大普遍性的集合。

2. Collection集合的增删功能

  • Collection集合的添加功能
    • boolean add(Object obj)
      • 向集合中添加一个元素,添加成功返回true,不成功返回false
    • boolean addAll(Collection c)
      • 将另一个集合中的元素添加进此集合中,添加成功返回true,不成功返回false
  • Collection集合的删除功能
    • void clear()
      • 清空集合,将集合中的所有元素移除
    • boolean remove(Object o)
      • 移除一个元素
    • boolean removeAll (Collection c)
      • 移除与另一个集合的交集元素,移除一个以上返回true,没有交集元素则返回false

3. Collection集合的判断与获取功能

  • Collection集合的判断功能

    • boolean contains(Object o)
      • 判断集合中是否包含指定元素
    • boolean containsAll(Collection c)
      • 判断集合是否包含另一个集合,全部包含返回true,否则返回false
    • boolean isEmpty()
      • 判断一个集合是否为空
  • Collection集合的迭代器

    • Iterator iterator()
      • 返回在此集合上进行迭代的迭代器
    • 利用迭代器对集合遍历
public class Students {//简单学生类
    public String name = "";
    public int age = 0;//实例域
    
    public Students(String name, int age) {//构造方法
        this.name = name;
        this.age = age;
    }
}

public class StudentsTest1 {//测试类,利用迭代器对集合遍历
    public static void main(String[] args) {
        Collection stuCollection = new ArrayList();//定义集合
        stuCollection.add(new Students("张三", 18));
        stuCollection.add(new Students("李四", 20));
        stuCollection.add(new Students("王五", 25));//对集合进行赋值

        Iterator stuIterator = stuCollection.iterator();//定义迭代器

        while (stuIterator.hasNext()) {//遍历输出
            Object next = stuIterator.next();
            Students stu = (Students) next;
            System.out.println("姓名:" + stu.name + "\t年龄:" + stu.age);
        }
    }
}
//输出结果:
//姓名:张三	年龄:18
//姓名:李四	年龄:20
//姓名:王五	年龄:25

4. Collection集合的其他功能

  • 长度功能
    • int size
      • 返回集合中的元素个数
  • 求两个集合交集
    • boolean retainAll(Collection c)
      • 获取两个元素的交集,并将交集元素存储在调用方法的集合内,如果调用方法的集合元素发生变化,返回true
  • 将集合转变为数组
    • Object[] toArray()
      • 将指定集合转换为数组

三、List集合

1. List集合概述

  • 有序的集合,也称之为序列,序列中的每一个元素都有对应的索引,可以根据索引访问元素。List中允许出现重复的元素

2. List集合的特殊方法

  • List集合继承自Collection集合,所以它可以使用Collection集合的公开方法,除此之外,List集合还有下列特有的方法

  • void add(int index,E element)

    • 给指定的索引处添加指定的元素
  • E get(int index)

    • 获取指定索引处的元素
  • E remove(int index)

    • 删除指定索引处的元素,并将这个元素返回
  • E set (int index,E element)

    • 使用指定的元素将指定索引处的元素替换,并将被替换的元素返回
  • 利用size()和get()方法结合对列表进行遍历

public class StudentsTest2 {//使用size()和get()方法对列表进行遍历
    public static void main(String[] args) {
        List stuList = new ArrayList();//定义列表
        stuList.add(new Students("张三", 18));
        stuList.add(new Students("李四", 20));
        stuList.add(new Students("王五", 25));//对列表进行赋值

        for (int i = 0; i < stuList.size(); i++) {//遍历
            Object o = stuList.get(i);
            Students stu = (Students) o;
            System.out.println("姓名:" + stu.name + "\t年龄:" + stu.age);
        }
    }
}
//运行结果:
//姓名:张三	年龄:18
//姓名:李四	年龄:20
//姓名:王五	年龄:25

3. Listiterator

  • 列表迭代器,允许按任一方向遍历列表,迭代期间修改列表,并获得迭代器在列表中的当前位置。长度为n的列表的迭代器有n+1个可能的位置,迭代器位于调用previous()方法返回的元素与调用next()方法所返回的元素之间
  • ListIterator特有方法
    • boolean hasPrevious()
      • 如果以逆向遍历列表,如果前面还有多个元素,返回true
    • E previous()
      • 返回列表中的前一个元素
    • 注:上述两个方法可以实现对列表的反向遍历,但是在反向遍历之前,必须对列表进行一次正向遍历,让指针指向最后一个元素。直接进行反向遍历指针默认位于最前方,而此时指针的前方并没有元素
  • 使用列表迭代器对列表进行遍历
public class StudentsTest3 {//利用列表迭代器对列表遍历
    public static void main(String[] args) {
        List stuList = new ArrayList();//定义列表
        stuList.add(new Students("张三", 18));
        stuList.add(new Students("李四", 20));
        stuList.add(new Students("王五", 25));//对列表进行赋值

        ListIterator stuListIterator = stuList.listIterator();//定义列表迭代器

        while (stuListIterator.hasNext()) {//先正向遍历将指针指向最后一个元素
            stuListIterator.next();
        }
        while (stuListIterator.hasPrevious()) {//从最后一个元素反向遍历
            Object previous = stuListIterator.previous();
            Students stu = (Students) previous;
            System.out.println("姓名:" + stu.name + "\t年龄:" + stu.age);
        }
    }
}
//运行结果:
//姓名:王五	年龄:25
//姓名:李四	年龄:20
//姓名:张三	年龄:18

4. 并发修改异常产生原因及解决方案

  • 问题描述
    • 当我们采用Iterator迭代器对集合进行遍历时,如果在此过程中对原集合的元素进行增删等处理,就会产生并发修改异常
  • 原因
    • 当我们给集合中添加完元素以后,采用Iterator迭代器对集合的元素进行遍历,此时迭代器已经得到了集合的原长度,如果在此时进行增删等操作,肯定会改变集合的长度,迭代器检测到集合长度发生变化,就会发生并发修改异常
  • 解决方案
    • 使用ListIterator迭代器
      • ListIterator迭代器有自己的增删改查方法,采用ListIterator提供的方法。不会产生并发修改异常
    • 不使用迭代器遍历修改
      • 可以使用for循环和size()和get()方法遍历

四、常见几种数据结构

1. 栈和队列

    • 先进栈的元素存放在栈底,后进栈的元素存放在栈顶,出栈时,栈顶元素先出栈
  • 队列
    • 后进来的元素排在队尾,排在前面的元素先出队列,

2. 数组和链表

  • 数组
    • 长度一经确认就不能更改,查询快,增删时要创建新的数组,故增删较慢
  • 链表
    • 链表中的每一个元素都由数据域和地址域两部分组成,数据域存放节点所存放的数据,地址域存放下一节点的地址,用来将一个个节点链接起来

五、List集合的三个子类 ArrayList、Vector、LinkedList

1. ArrayList集合

  • ArrayList 集合特点
    • 底层通过数组实现,查询快,增删慢
    • 线程不安全,效率快
  • 特有方法
    • void forEach(Consumer action)
      • ArrayList类自带的迭代器,可以对列表元素进行遍历
      • 将Consumer的匿名内部类作为参数传递
  • 举例
public class Test {//ArrayList类的forEach方法遍历列表
    public static void main(String[] args) {
        ArrayList list = new ArrayList();//创建一个ArrayList对象
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);//给ArrayList对象中添加元素

        list.forEach(new Consumer() {//使用ArrayList自带的迭代器对列表元素遍历
            @Override
            public void accept(Object o) {//将Consumer类的匿名内部类作为参数
                System.out.println(o);//打印
            }
        });
    }
}

2. Vector

  • Vector
    • 底层通过数组实现,查询快,增删慢
    • 线程安全,效率低
  • 特有方法
    • public void addElement (E obj)
      • 在列表的末尾添加一个元素
    • public E elementAt (int index)
      • 获取指定索引位置处的元素

3. LinkedList

  • LinkedList
    • 底层通过链表来实现,查询慢,增删快
    • 线程不安全,效率高
  • 特有方法
    • public void addFirst(E e)及addLast(E e)
      • 在列表的首尾添加元素
    • public E getFirst()及getLast()
      • 得到列表的首尾元素
    • public E removeFirst()及public E removeLast()
      • 移除列表的首尾元素,并将首尾元素返回
  • 举例:删除表中的重复元素
public class Test3 {//去除列表中的重复元素
    public static void main(String[] args) {
        LinkedList list = new LinkedList();//创建一个LinkedList对象

        list.addFirst(1);
        list.addFirst(4);
        list.addFirst(2);
        list.addFirst(4);
        list.addFirst(2);
        list.addFirst(3);
        list.addFirst(1);
        list.addFirst(4);
        list.addFirst(2);
        list.addFirst(4);
        list.addFirst(2);
        list.addFirst(4);
        list.addFirst(3);//添加元素
        
        System.out.println(list);//打印列表
        
        for (int i = 0; i < list.size(); i++) {//外层遍历每一个元素
            for (int j = i + 1; j < list.size(); j++) {//内层用外层元素与后面元素进行比较
                if ((int) list.get(i) == (int) list.get(j)) {//如果有相同元素,删除后面的元素
                    list.remove(j);
                    j--;//内层索引前移
                }
            }
        }
        System.out.println(list);//打印去重后的列表
    }
}

4. 三个子类使用时选择

  • 如果增删场景比较多,考虑LinkedList类
  • 如果线程安全要求较高,考虑Vector类
  • 如果查询场景比较多,且效率要求较高,考虑ArrayList类

5. 集合嵌套

  • 集合嵌套
    • 一个集合中的元素是另一个集合,叫做集合嵌套,类似于二维数组
    • 举例
      • 学校有多个班,一个班有多个学生。每个班学生的信息都是一个集合,而这些集合都是学校所有班这个大集合的元素

你可能感兴趣的:(JavaSE)