集合

集合

集合,简单的可以理解成就是元素为对象的数组。

但是,集合和数组还有以下区别:

  1. 长度区别:
    数组的长度是固定的而集合的长度是可变的
  2. 存储数据类型的区别:
    数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
  3. 内容区别:
    数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素

集合的继承体系图:

Collection集合的功能概述

添加功能:

  1. boolean add(Object obj):添加一个元素
  2. boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)

删除功能:

  1. void clear():移除所有元素
  2. boolean remove(Object o):移除一个元素
  3. boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素
    如果没有交集元素 则删除失败 返回false

判断功能:

  1. boolean contains(Object o):判断集合中是否包含指定的元素
  2. boolean containsAll(Collection c):判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
  3. boolean isEmpty():判断集合是否为空

获取功能:

​ Iterator iterator()(重点)

长度功能:

​ int size():元素的个数

交集功能:

​ boolean retainAll(Collection c):获取两个集合的交集元素(交集:两个集合都有的元素)

把集合转换为数组:

​ Object[] toArray(): 返回包含此 collection 中所有元素的数组。

返回包含此 collection 中所有元素的数组。

Collection集合的高级功能测试

  1. boolean addAll(Collection c):

    将指定 collection 中的所有元素都添加到此 collection 中(可选操作)。

  2. boolean removeAll(Collection c):

    移除此 collection 中那些也包含在指定 collection 中的所有元素(可选操作)。

  3. boolean containsAll(Collection c):

    如果此 collection 包含指定 collection 中的所有元素,则返回 true

  4. boolean retainAll(Collection c):

    仅保留此 collection 中那些也包含在指定 collection 的元素(可选操作)。

迭代器:

迭代器是行为类似指针的对象。按顺序访问容器内所含的元素,且不暴露该聚合物的内部表达方式。

List

概述:元素有序,并且每一个元素都存在一个索引.元素可以重复.

特有功能概述:

  1. void add(int index,E element): 在指定索引处添加元素
  2. E remove(int index):移除指定索引处的元素 返回的是移除的元素
  3. E get(int index):获取指定索引处的元素
  4. int indexOf(Object o):返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1。
  5. int lastIndexOf(Object o):返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1。

List集合的特有遍历功能:使用for循环 通过size()和get()方法结合使用遍历。

例:

class test{
    public static void main(String[] args) {
        /*1、请编写程序,将自定义对象存储到ArrayList集合,使用泛型并遍历
        a)使用迭代器遍历
        b)使用列表迭代器遍历
        c)使用size()和get()方法遍历
        d)使用增强for遍历*/

        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("吴国太",56));
        list.add(new Student("孙尚香",23));
        list.add(new Student("大乔",26));

        Iterator it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        ListIterator it2 = list.listIterator();
        while (it2.hasNext()) {
            System.out.println(it2.next());
        }

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

        for (Student student : list) {
            System.out.println(student);
        }

    }
}

class Student {
    private String name;
    private int age;
    public Student(){}
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void show () {
        System.out.println(name +"..."+age);
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }
}

ListIterator

ListIterator的特有功能:

  1. boolean hasPrevious(): 是否存在前一个元素
  2. E previous(): 返回列表中的前一个元素

注意:以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前 要先进行正向遍历 这样指针才能移到最后。如果直接反向遍历是没有效果的 因为指针默认位置就在最前面 他前面没有元素

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

用Iterator这个迭代器遍历采用hasNext方法和next方法,集合修改集合 会出现并发修改异常(ConcurrentModificationException)

原因:迭代器依赖于集合,在集合中添加元素完毕后,迭代器已经获取了集合元素数量,这时候要改变集合的长度,迭代器就会抛出错误。

解决方案:

  1. 用ListIterator迭代器遍历 用迭代器自带的add方法添加元素 那就不会报错了
  2. 使用for循环遍历集合即可

List的三个子类的特点:

  1. ArrayList:
    底层数据结构是数组,查询快,增删慢。
    线程不安全,效率高。
  2. Vector:
    底层数据结构是数组,查询快,增删慢。
    线程安全,效率低。
  3. LinkedList:
    底层数据结构是链表,查询慢,增删快。
    线程不安全,效率高。

具体选择:要安全还是要效率
查找多还是增删多

,查询快,增删慢。
线程不安全,效率高。
2. Vector:
底层数据结构是数组,查询快,增删慢。
线程安全,效率低。
3. LinkedList:
底层数据结构是链表,查询慢,增删快。
线程不安全,效率高。

具体选择:要安全还是要效率
查找多还是增删多

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值