Day16_集合与迭代器

小鱼儿y

已于 2024-07-18 10:37:08 修改

阅读量718

点赞数 13

分类专栏： javase 文章标签： java 开发语言

于 2024-07-17 21:22:37 首次发布

本文链接：https://blog.csdn.net/cainiao_123456/article/details/140504868

版权

javase 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Day16-集合

Day16 集合与迭代器
- - 1.1 集合的概念
集合继承图

Day16 集合与迭代器

1.1 集合的概念

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

集合和数组既然都是容器，它们有啥区别呢？

数组的长度是固定的。
集合的长度是可变的。
数组中可以存储基本数据类型值，也可以存储对象，而集合中只能存储对象

集合主要分为两大系列：Collection和Map，Collection 表示一组对象，Map表示一组映射关系或键值对。

集合继承图

在这里插入图片描述

集合框架: 有序无序取决于能否用编号操作他

Collection: 存储的是一个一个的数据
    -- List: 元素有序且允许重复
        -- ArrayList: 底层使用数组结构，查询快增删慢
        -- LinkedList: 底层使用双向链表结构，查询慢增删快
    -- Set: 元素无序且不允许重复
        -- HashSet: 底层使用哈希表结构
        -- TreeSet: 底层使用红黑树结构
        
Map: 存储一对一对的数据
    -- HashMap:
    -- TreeMap:
    -- Hashtable:

1.2 Collection接口

Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List、Queue）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

1、添加元素

（1）add(E obj)：添加元素对象到当前集合中

（2）addAll(Collection<? extends E> other)：添加other集合中的所有元素对象到当前集合中，即this = this ∪ other

2、删除元素

（1） boolean remove(Object obj) ：从当前集合中删除第一个找到的与obj对象equals返回true的元素。

（2）boolean removeAll(Collection<?> coll)：从当前集合中删除所有与coll集合中相同的元素。即this = this - this ∩ coll

（3）boolean retainAll(Collection<?> coll)：从当前集合中删除两个集合中不同的元素，使得当前集合仅保留与c集合中的元素相同的元素，即当前集合中仅保留两个集合的交集，即this = this ∩ coll；

（4）void clear()：清空集合

（5）boolean removeIf(Predicate<? super E> filter) ：删除满足给定条件的此集合的所有元素。removeIf方法是Java8引入的。

3、查询与获取元素

（1）boolean isEmpty()：判断当前集合是否为空集合。

（2）boolean contains(Object obj)：判断当前集合中是否存在一个与obj对象equals返回true的元素。

（3）boolean containsAll(Collection<?> c)：判断c集合中的元素是否在当前集合中都存在。即c集合是否是当前集合的“子集”。

（4）int size()：获取当前集合中实际存储的元素个数

（5）Object[] toArray()：返回包含当前集合中所有元素的数组

不过当我们实际使用都是使用的他的子类Arraylist！！！

因为Java中使用ArrayList作为集合的一个常见选择，主要基于以下几个原因：

动态数组：ArrayList内部是通过一个动态数组来实现的，这意呀着它可以自动调整其大小以存储更多的元素。这种自动扩容的特性使得ArrayList在处理未知大小的数据集时非常方便。
随机访问：由于ArrayList是基于数组的，所以它可以提供快速的随机访问能力。也就是说，你可以通过索引（位置）直接访问或修改元素，这种操作的时间复杂度是O(1)。
易用性：ArrayList提供了丰富的API，使得添加、删除、查找元素等操作变得简单直观。它实现了List接口，因此可以使用所有List接口提供的方法。
广泛的使用场景：ArrayList适用于大多数需要列表功能的场景，包括存储对象集合、作为栈或队列的简单实现（尽管有专门的Stack和Queue接口及其实现），以及作为其他集合（如HashSet）的基础数据结构等。
性能考虑：尽管ArrayList在插入和删除元素时可能需要移动其他元素（这会影响性能，特别是在列表的开头或中间位置进行这些操作时），但在许多实际应用中，这种性能开销是可以接受的，特别是当元素添加和删除操作不频繁时。
与Java集合框架的兼容性：ArrayList是Java集合框架（Java Collections Framework）的一部分，这意味着它可以与其他集合类型（如Set、Map等）无缝协作，支持通过Collections类提供的静态方法（如排序、查找等）进行进一步的操作。

然而，值得注意的是，ArrayList并不是所有情况下的最佳选择。例如，如果你需要频繁地在列表的开头或中间插入和删除元素，那么LinkedList可能会是更好的选择，因为它在这些操作上更加高效。同样，如果你需要一个不允许重复元素的列表，那么HashSet（通过其Set接口）或LinkedHashSet（保持元素插入顺序）可能是更合适的选择。选择哪种集合类型取决于你的具体需求和性能考虑。

1.3 API演示

1、演示添加

注意：add和addAll的区别

package com.atguigu.collection;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

public class TestCollectionAdd {
    @Test
    public void testAdd(){
        //ArrayList是Collection的子接口List的实现类之一。
        Collection<String> coll = new ArrayList<>();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        System.out.println(coll);
    }

    @Test
    public void testAddAll(){
        Collection<String> c1 = new ArrayList<>();
        c1.add(1);
        c1.add(2);
        System.out.println("c1集合元素的个数：" + c1.size());//2
        System.out.println("c1 = " + c1);

        Collection<String> c2 = new ArrayList<>();
        c2.add(1);
        c2.add(2);
        System.out.println("c2集合元素的个数：" + c2.size());//2
        System.out.println("c2 = " + c2);

        Collection<String> other = new ArrayList<>();
        other.add(1);
        other.add(2);
        other.add(3);
        System.out.println("other集合元素的个数：" + other.size());//3
        System.out.println("other = " + other);
        System.out.println();

        c1.addAll(other);
        System.out.println("c1集合元素的个数：" + c1.size());//5
        System.out.println("c1.addAll(other) = " + c1);

        c2.add(other);
        System.out.println("c2集合元素的个数：" + c2.size());
        System.out.println("c2.add(other) = " + c2);
    }
}

注意：coll.addAll(other);与coll.add(other);

在这里插入图片描述

2、演示删除

注意几种删除方法的区别

package com.atguigu.collection;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Predicate;

public class TestCollectionRemove {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll = " + coll);

        coll.remove("小李广");
        System.out.println("删除元素\"小李广\"之后coll = " + coll);

        coll.removeIf(new Predicate() {
            @Override
            public boolean test(Object o) {
                String str = (String) o;
                return str.contains("地");
            }
        });
        System.out.println("删除包含\"地\"字的元素之后coll = " + coll);

        coll.clear();
        System.out.println("coll清空之后，coll = " + coll);
    }

    @Test
    public void test02() {
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll = " + coll);

        Collection other = new ArrayList();
        other.add("小李广");
        other.add("扫地僧");
        other.add("尚硅谷");
        System.out.println("other = " + other);

        coll.removeAll(other);
        System.out.println("coll.removeAll(other)之后，coll = " + coll);
        System.out.println("coll.removeAll(other)之后，other = " + other);
    }

    @Test
    public void test03() {
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll = " + coll);

        Collection other = new ArrayList();
        other.add("小李广");
        other.add("扫地僧");
        other.add("尚硅谷");
        System.out.println("other = " + other);

        coll.retainAll(other);
        System.out.println("coll.retainAll(other)之后，coll = " + coll);
        System.out.println("coll.retainAll(other)之后，other = " + other);
    }

}

3、演示查询与获取元素

package com.atguigu.collection;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class TestCollectionContains {
    @Test
    public void test01() {
        Collection coll = new ArrayList();
        System.out.println("coll在添加元素之前，isEmpty = " + coll.isEmpty());
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll的元素个数" + coll.size());
        Object[] objects = coll.toArray();
        System.out.println("用数组返回coll中所有元素：" + Arrays.toString(objects));
        System.out.println("coll在添加元素之后，isEmpty = " + coll.isEmpty());
        coll.clear();
        System.out.println("coll在clear之后，isEmpty = " + coll.isEmpty());
    }

    @Test
    public void test02() {
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");
        coll.add("佛地魔");
        System.out.println("coll = " + coll);
        System.out.println("coll是否包含“小李广” = " + coll.contains("小李广"));
        System.out.println("coll是否包含“宋红康” = " + coll.contains("宋红康"));

        Collection other = new ArrayList();
        other.add("小李广");
        other.add("扫地僧");
        other.add("尚硅谷");
        System.out.println("other = " + other);

        System.out.println("coll.containsAll(other) = " + coll.containsAll(other));
    }

    @Test
    public void test03(){
        Collection c1 = new ArrayList();
        c1.add(1);
        c1.add(2);
        System.out.println("c1集合元素的个数：" + c1.size());//2
        System.out.println("c1 = " + c1);

        Collection c2 = new ArrayList();
        c2.add(1);
        c2.add(2);
        System.out.println("c2集合元素的个数：" + c2.size());//2
        System.out.println("c2 = " + c2);

        Collection other = new ArrayList();
        other.add(1);
        other.add(2);
        other.add(3);
        System.out.println("other集合元素的个数：" + other.size());//3
        System.out.println("other = " + other);
        System.out.println();

        c1.addAll(other);
        System.out.println("c1集合元素的个数：" + c1.size());//5
        System.out.println("c1.addAll(other) = " + c1);
        System.out.println("c1.contains(other) = " + c1.contains(other));
        System.out.println("c1.containsAll(other) = " + c1.containsAll(other));
        System.out.println();

        c2.add(other);
        System.out.println("c2集合元素的个数：" + c2.size());
        System.out.println("c2.add(other) = " + c2);
        System.out.println("c2.contains(other) = " + c2.contains(other));
        System.out.println("c2.containsAll(other) = " + c2.containsAll(other));
    }

}

2 Iterator迭代器

2.1 Iterator接口

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，下面介绍一下获取迭代器的方法：

public Iterator iterator(): iterator(): 获取到集合的迭代器，用来遍历集合里的元素。方法返回的结果是 Iterator类型的对象

下面介绍一下迭代的概念：

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

Iterator接口的常用方法如下：

public E next():返回迭代的下一个元素。
public boolean hasNext():如果仍有元素可以迭代，则返回 true。

接下来我们通过案例学习如何使用Iterator迭代集合中元素：

public class IteratorDemo {
    public static void main(String[] args) {
        // List<String> names = new ArrayList<>();
        Set<String> names = new HashSet<>();
        names.add("tom");
        names.add("jack");
        names.add("jerry");
        names.add("rose");

        // 遍历集合元素的方式一: 使用 for循环(只能用于list)
        /*for (int i = 0; i < names.size(); i++) {
            System.out.println(names.get(i));
        }*/

        // 遍历集合元素的方式二: 使用迭代器+while循环遍历
        /*Iterator<String> itr = names.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }*/

        // 遍历集合元素的方式三: 使用迭代器+for循环遍历
        /*for (Iterator<String> itr = names.iterator(); itr.hasNext(); ) {
            String name = itr.next();
            System.out.println(name);
        }*/

        /*遍历集合元素的方式四: 增强for循环(迭代器的语法糖)
        for(元素数据类型 元素变量名: 集合) {
        }*/
        for (String name : names) {
            System.out.println(name);
        }

        int[] nums = {56, 78};
        /*for (int i = 0; i < nums.length; i++) {
            int num = nums[i];
            System.out.println(num);
        }*/
        for (int num : nums) {  // 数组没有迭代器，数组的增强for循环是fori循环的语法糖
            System.out.println(num);
        }

    }
}

提示：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。

2.2 迭代器的实现原理

我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时，首先通过调用集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。

Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，接下来通过一个图例来演示Iterator对象迭代元素的过程：

在这里插入图片描述

在调用Iterator的next方法之前，迭代器指向第一个元素，当第一次调用迭代器的next方法时，返回第一个元素，然后迭代器的索引会向后移动一位，指向第二个元素，当再次调用next方法时，返回第二个元素，然后迭代器的索引会再向后移动一位，指向第三个元素，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

2.3 Iterable接口

1、 Iterable接口依赖Iterator接口

java.lang.Iterable接口的抽象方法：

public Iterator iterator(): 获取对应的迭代器，用来遍历集合中的元素的。

凡是实现了 Iterable接口的集合，就必须重写 iterator()方法，即还必须为该集合提供一个Iterator接口的实现类，否则就无法完成该方法的重写。

2、forEach方法

java.lang.Iterable接口在Java8还提供了一个forEach默认方法：

public default void forEach(Consumer<? super T> action)：传入Consumer接口的实现类对象，完成集合元素的迭代

java.util.function.Consumer接口的抽象方法：

void accept(T t)：对元素t执行给定的操作

package com.atguigu.iter;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

public class TestForEachMethod {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");

        coll.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
    }
}

3、新语法糖：foreach循环（增强for循环）

Java5（JDK1.5）中增加了java.lang.Iterable接口，实现这个接口允许对象成为 “foreach” 语句的目标。 Java 5时Collection接口继承了java.lang.Iterable接口，因此Collection系列的集合就可以直接使用foreach循环遍历。

foreach循环的语法格式：

for(元素类型 元素名 : 集合名等){
}
//这里元素名就是一个临时变量，自己命名就可以

对于集合类型来说，foreach循环其实就是使用Iterator迭代器来完成元素的遍历的。

package com.atguigu.iterator;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

public class TestForeach {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add("小李广");
        coll.add("扫地僧");
        coll.add("石破天");

        for (Object o : coll) {
            System.out.println(o);
        }
    }
}

在这里插入图片描述

Java中的数组也支持这种语法糖。只不过编译器在处理foreach遍历数组时，是转换为普通for循环的。

代码示例：

package com.atguigu.api;

public class TestForeach {
    public static void main(String[] args) {
        int[] nums = {1,2,3,4,5};
        for (int num : nums) {
            System.out.println(num);
        }
        System.out.println("-----------------");
        String[] names = {"张三","李四","王五"};
        for (String name : names) {
            System.out.println(name);
        }
    }
}

2.4 使用Iterator迭代器删除元素

java.util.Iterator迭代器中有一个方法：

void remove() ;

那么，既然Collection已经有remove(xx)方法了，为什么Iterator迭代器还要提供删除方法呢？

因为在JDK1.8之前Collection接口没有removeIf方法，即无法根据条件删除。

例如：要删除以下集合元素中的偶数

package com.atguigu.iterator;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class TestIteratorRemove {
    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add(1);
        coll.add(2);
        coll.add(3);
        coll.add(4);

//		coll.remove(?)//没有removeIf方法无法实现删除“偶数”

        Iterator iterator = coll.iterator();
        while(iterator.hasNext()){
            Integer element = (Integer) iterator.next();
            if(element%2 == 0){
                iterator.remove();
            }
        }
        System.out.println(coll);
    }
}

2.5 Iterator迭代器的快速失败（fail-fast）机制

如果在Iterator、ListIterator迭代器创建后的任意时间从结构上修改了集合（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。

这样设计是因为，迭代器代表集合中某个元素的位置，内部会存储某些能够代表该位置的信息。当集合发生改变时，该信息的含义可能会发生变化，这时操作迭代器就可能会造成不可预料的事情。因此，果断抛异常阻止，是最好的方法。这就是Iterator迭代器的快速失败（fail-fast）机制。

1、ConcurrentModificationException异常

public class IteratorTest {
    public static void main(String[] args) {
        List<String> heroes = new ArrayList<>();

        heroes.add("张飞");
        heroes.add("诸葛亮");
        heroes.add("赵云");
        heroes.add("李白");
        heroes.add("诸葛亮");
        heroes.add("诸葛亮");
        heroes.add("东皇太一");
        heroes.add("鲁班");
        heroes.add("诸葛亮");
        heroes.add("夏侯惇");
        System.out.println(heroes);

        /*for (int i = 0; i < heroes.size(); i++) {
            if ("诸葛亮".equals(heroes.get(i))) {
                heroes.remove(i);
                i--;
            }
        }*/

        /*for (int i = 0; i < heroes.size(); ) {
            if ("诸葛亮".equals(heroes.get(i))) {
                heroes.remove(i);
            } else {
                i++;
            }
        }*/

        /*for (int i = heroes.size() - 1; i >= 0; i--) {
            if ("诸葛亮".equals(heroes.get(i))) heroes.remove(i);
        }*/

        /*迭代器循环里，不能调用集合的remove/add等方法进行增删操作
            调用next()方法时，第一件事就是比较 modCount 和 expectedModCount
            如果 modCount != expectedModCount,立马抛出ConcurrentModificationException
        只要调用了集合的 remove/add等方法对集合进行了增删，modCount会自增，
        但是迭代器里的 expectedModCount没有同步更新，再次调用next()方法就会抛出异常

        如果不是调用集合的 remove/add方法对集合增删，而是调用了迭代器的remove()方法删除元素，
        不会抛出 并发修改异常，迭代器的remove()方法就是调用了集合的remove()方法删除元素(modCount会自增)，
        然后再将 expectedModCount = modCount,同时还调整 cursor 和 lastRet*/
        Iterator<String> itr = heroes.iterator();
        for (; itr.hasNext(); ) {
            String h = itr.next();
            // if ("诸葛亮".equals(h)) heroes.remove(h);
            if ("诸葛亮".equals(h)) itr.remove();  // 可以调用迭代器的remove()方法删除元素
        }
        System.out.println(heroes);

    }

2、modCount变量

那么迭代器如何实现快速失败（fail-fast）机制的呢？

在ArrayList等集合类中都有一个modCount变量。它用来记录集合的结构被修改的次数。
当我们给集合添加和删除操作时，会导致modCount++。
然后当我们用Iterator迭代器遍历集合时，创建集合迭代器的对象时，用一个变量记录当前集合的modCount。例如：int expectedModCount = modCount;，并且在迭代器每次next()迭代元素时，都要检查 expectedModCount != modCount，如果不相等了，那么说明你调用了Iterator迭代器以外的Collection的add,remove等方法，修改了集合的结构，使得modCount++，值变了，就会抛出ConcurrentModificationException。

下面以AbstractList和ArrayList.Itr迭代器为例进行源码分析：

AbstractList类中声明了modCount变量：

    /**
     * The number of times this list has been <i>structurally modified</i>.
     * Structural modifications are those that change the size of the
     * list, or otherwise perturb it in such a fashion that iterations in
     * progress may yield incorrect results.
     *
     * <p>This field is used by the iterator and list iterator implementation
     * returned by the {@code iterator} and {@code listIterator} methods.
     * If the value of this field changes unexpectedly, the iterator (or list
     * iterator) will throw a {@code ConcurrentModificationException} in
     * response to the {@code next}, {@code remove}, {@code previous},
     * {@code set} or {@code add} operations.  This provides
     * <i>fail-fast</i> behavior, rather than non-deterministic behavior in
     * the face of concurrent modification during iteration.
     *
     * <p><b>Use of this field by subclasses is optional.</b> If a subclass
     * wishes to provide fail-fast iterators (and list iterators), then it
     * merely has to increment this field in its {@code add(int, E)} and
     * {@code remove(int)} methods (and any other methods that it overrides
     * that result in structural modifications to the list).  A single call to
     * {@code add(int, E)} or {@code remove(int)} must add no more than
     * one to this field, or the iterators (and list iterators) will throw
     * bogus {@code ConcurrentModificationExceptions}.  If an implementation
     * does not wish to provide fail-fast iterators, this field may be
     * ignored.
     */
    protected transient int modCount = 0;

翻译解释：modCount是这个list被结构性修改的次数。子类使用这个字段是可选的，如果子类希望提供fail-fast迭代器，它仅仅需要在add(int, E),remove(int)方法（或者它重写的其他任何会结构性修改这个列表的方法）中添加这个字段。调用一次add(int,E)或者remove(int)方法时必须且仅仅给这个字段加1，否则迭代器会抛出伪装的ConcurrentModificationExceptions错误。如果一个实现类不希望提供fail-fast迭代器，则可以忽略这个字段。

Arraylist的Itr迭代器：

   private class Itr implements Iterator<E> {
        int cursor;      
        int lastRet = -1; 
        int expectedModCount = modCount;//在创建迭代器时，expectedModCount初始化为当前集合的modCount的值

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();//校验expectedModCount与modCount是否相等
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
       	final void checkForComodification() {
            if (modCount != expectedModCount)//校验expectedModCount与modCount是否相等
                throw new ConcurrentModificationException();//不相等，抛异常
        }
}

ArrayList的remove方法：

    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }


    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

在这里插入图片描述

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：*迭代器的快速失败行为应该仅用于检测 bug。*例如：

package com.atguigu.iterator;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class TestNoConcurrentModificationException {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("hello");
        coll.add("world");
        coll.add("java");
        coll.add("haha");

        Iterator iterator = coll.iterator();
        while (iterator.hasNext()) {
            String str = (String) iterator.next();
            if (str.contains("a")) {
                coll.remove(str);
                //Iterator遍历集合过程中，调用集合的remove方法
            }
        }
    }
}

在这里插入图片描述

3 元素要求

3.1 有序、可重复

Collection 层次结构中的根接口。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List、Queue）实现。我们掌握了Collection接口的使用后，再来看看Collection接口中的子接口，他们都具备那些特性呢？

1、List接口介绍

java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。

List的常用实现类有：ArrayList、Vector、LinkedList、Stack等。

List接口特点：

List集合所有的元素是以一种线性方式进行存储的
它是一个元素存取有序的集合。即元素的存入顺序和取出顺序有保证。
它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
集合中可以有重复的元素

List集合类中元素有序、且可重复。这就像银行门口客服，给每一个来办理业务的客户分配序号：第一个来的是“张三”，客服给他分配的是0；第二个来的是“李四”，客服给他分配的1；以此类推，最后一个序号应该是“总人数-1”。

在这里插入图片描述

注意：

List集合关心元素是否有序，而不关心是否重复，请大家记住这个原则。例如“张三”可以领取两个号。

在JavaSE中List名称的类型有两个，一个是java.util.List集合接口，一个是java.awt.List图形界面的组件，别导错包了。

2、List接口中常用方法

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法，如下：

List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法。

1、添加元素

void add(int index, E ele)：把元素添加到指定位置
boolean addAll(int index, Collection<? extends E> eles)：把一组元素添加到指定位置

2、删除元素

E remove(int index)：删除指定位置的元素

3、修改元素

E set(int index, E ele)：替换[index]位置的元素
default void replaceAll(UnaryOperator operator)：按指定操作的要求替换元素

4、获取元素

E get(int index)：返回[index]位置的元素
List subList(int fromIndex, int toIndex)：返回[fromIndex, toIndex)范围的元素
int indexOf(Object obj)：查询obj在列表中的位置，如果有重复，返回第1个
int lastIndexOf(Object obj)：查询obj在列表中的位置，如果有重复，返回最后1个

示例代码：

package com.atguigu.list;

import org.junit.Test;

import java.util.*;
import java.util.function.UnaryOperator;

public class TestListMethod {

    @Test
    public void test08(){
        /*
        演示foreach和Iterator迭代器
         */
        List list = new ArrayList();
        list.add("hello");
        list.add("java");
        list.add("world");
        list.add("mysql");
        list.add("java");

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

    @Test
    public void test07(){
        /*
        演示foreach和Iterator迭代器
         */
        List list = new ArrayList();
        list.add("hello");
        list.add("java");
        list.add("world");
        list.add("mysql");
        list.add("java");

        for (Object o : list) {
            System.out.println(o);
        }
    }

    @Test
    public void test6() {
         /*
        ArrayList是List接口的实现类.
        演示查询，截取
         */
        List list = new ArrayList();
        list.add("hello");
        list.add("java");
        list.add("world");
        list.add("mysql");
        list.add("java");

        System.out.println(list.get(1));//java
        System.out.println(list.indexOf("java"));//1
        System.out.println(list.lastIndexOf("java"));//4

        List subList = list.subList(1, 3);//[1,3)下标范围的元素
        System.out.println("subList = " + subList);//[java, world]

    }

    @Test
    public void test5(){
        List list = new ArrayList();
        list.add("hello");
        list.add("java");
        list.add("world");
        list.add("mysql");
        list.add("java");

        list.replaceAll(new UnaryOperator() {
            @Override
            public Object apply(Object o) {
                return "java".equals(o) ? "atguigu" : o;
            }
        });

        System.out.println(list);
    }

    @Test
    public void test4(){
         /*
        ArrayList是List接口的实现类。
        演示修改替换
         */
        List list = new ArrayList();
        list.add("hello");
        list.add("java");

        list.set(0,"hi");
        System.out.println(list);//[hi, java]
    }
    @Test
    public void test03(){
       /*
        ArrayList是List接口的实现类。
        演示删除
         */
        List list =new ArrayList();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);

        list.remove(1);//删除[1]位置的元素
        System.out.println(list);//[10, 30, 40]

        //list.remove(30);//删除元素值为30的元素
        list.remove(Integer.valueOf(30));//手动装箱
        System.out.println(list);//[10, 40]

    }

    @Test
    public void test2(){
         /*
        ArrayList是List接口的实现类。
        演示删除
         */
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("java");

        list.remove(0);
        System.out.println(list);
    }

    @Test
    public void test01(){
        /*
        ArrayList是List接口的实现类。
        演示添加
         */
        List list = new ArrayList();
        list.add("hello");
        list.add("java");

        list.add(0,"atguigu");
        list.add(2,"world");

        System.out.println(list);//[atguigu, hello, world, java]


        List list2 = Arrays.asList("chai", "lin", "yan");

        list.addAll(1,list2);
        System.out.println(list);//[atguigu, chai, lin, yan, hello, world, java]

    }
}

3、ListIterator迭代器

List 集合额外提供了一个 listIterator() 方法，该方法返回一个 ListIterator 列表迭代器对象， ListIterator 接口继承了 Iterator 接口，提供了专门操作 List 的方法：

void add()：通过迭代器添加元素到对应集合
void set(Object obj)：通过迭代器替换正迭代的元素
void remove()：通过迭代器删除刚迭代的元素
boolean hasPrevious()：如果以逆向遍历列表，往前是否还有元素。
Object previous()：返回列表中的前一个元素。
int previousIndex()：返回列表中的前一个元素的索引
boolean hasNext()
Object next()
int nextIndex()

package com.atguigu.list;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class TestListIterator {
    @Test
    public void test7() {
         /*
        ArrayList是List接口的实现类。
        演示ListIterator迭代器
         */
        List list = new ArrayList();
        list.add("hello");
        list.add("java");
        list.add("world");
        list.add("mysql");
        list.add("java");

        ListIterator stringListIterator = list.listIterator();
        while(stringListIterator.hasNext()){
            int index = stringListIterator.nextIndex();
            Object next = stringListIterator.next();

            if(next.equals("java")){
                stringListIterator.set("JavaEE");
            }
        }

        System.out.println(list);//[hello, JavaEE, world, mysql, JavaEE]
    }

    @Test
    public void test6() {
         /*
        ArrayList是List接口的实现类。
        演示ListIterator迭代器
         */
        List list = new ArrayList();
        list.add("hello");
        list.add("java");
        list.add("world");
        list.add("mysql");
        list.add("java");

        ListIterator stringListIterator = list.listIterator();
        while(stringListIterator.hasNext()){
            int index = stringListIterator.nextIndex();
            Object next = stringListIterator.next();
            System.out.println("index = " + index +"，next = " + next);
        }

        System.out.println("---------------");
        while(stringListIterator.hasPrevious()){
            int index = stringListIterator.previousIndex();
            Object previous = stringListIterator.previous();
            System.out.println("index = " + index +"，previous = " + previous);
        }

        System.out.println("---------------");
        stringListIterator = list.listIterator(2);
        while(stringListIterator.hasNext()){
            int index = stringListIterator.nextIndex();
            Object next = stringListIterator.next();
            System.out.println("index = " + index +"，next = " + next);
        }
    }
}

3.2 无序、不可重复

1、Set接口介绍

Set接口是Collection的子接口，set接口没有提供额外的方法。但是比Collection接口更加严格了。

Set 集合不允许包含相同的元素，即元素不可重复。

Set集合支持的遍历方式和Collection集合一样：foreach和Iterator。

Set的常用实现类有：HashSet、TreeSet、LinkedHashSet等。

1.1HashSet

/*
Set在Collection的基础上，没有新增方法
Set集合特点:  存储的元素无序，且不允许重复(判断元素是否重复的依据)
    HahSet判断元素是否重复的依据:
        1. 先调用HashCode方法，看哈希值是否相同。如果哈希值不同，直接存入
        2. 哈希值相同，再调用equals方法。如果equals返回true,就认为是同一个元素，就不再存入
*/
public class HashSetDemo {
    public static void main(String[] args) {
        Set<Dog> set = new HashSet<>();

        set.add(new Dog("2pj", "黄色", 3, "公", 12.5));

        set.add(new Dog("来福", "黑色", 1, "母", 5.1));

        set.add(new Dog("大黄", "黄色", 2, "公", 10.5));
        set.add(new Dog("旺财", "黄色", 3, "公", 12.5));

        set.add(new Dog("来福", "黑色", 1, "母", 5.1));
        set.add(new Dog("3Qj", "黄色", 3, "公", 12.5));

        System.out.println(set);
    }
}

1.2TreeSet

/*
TreeSet底层使用的红黑树结构:
    判断元素是否重复的依据: 将元素转换成为Comparable类型，然后再调用元素的 compareTo()方法   //笔记记得记一下这两个接口
        结果如果是 0就认为是同一个元素，就不再存入

TreeSet在存储元素时，要么元素实现 Comparable接口，并实现compareTo()方法
要么在创建TreeSet对象时，调用 TreeSet(Comparator c) 构造方法，传入一个比较器
*/
public class TreeSetDemo {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("hello");
        set.add("good");
        set.add("ok");
        set.add("xyz");
        set.add("yes");
        set.add("go");
        set.add("abc");
        set.add(new String("go"));
        set.add("hi");

        System.out.println(set);

        Set<Integer> nums = new TreeSet<>();
        nums.add(90);
        nums.add(73);
        nums.add(128);
        nums.add(65);
        nums.add(99);
        nums.add(83);
        nums.add(77);
        System.out.println(nums);

        Set<Student> students = new TreeSet<>();
        students.add(new Student("jack", 18, 90));
        students.add(new Student("tom", 20, 78));
        students.add(new Student("rose", 18, 94));
        System.out.println(students);

        Set<Dog> dogs = new TreeSet<>(new Comparator<Dog>() {
            @Override
            public int compare(Dog o1, Dog o2) {
                return o1.getAge() - o2.getAge();
            }
        });

        dogs.add(new Dog("大黄", "黄色", 2, "公", 10.8));

    }
}

2、元素相等和重复问题：equals和hashCode方法

HashSet和LinkedHashSet元素不可重复是依赖于equals和hashCode方法

package com.atguigu.set;

public class Circle {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public String toString() {
        return "Circle{" +
                "radius=" + radius +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Circle circle = (Circle) o;

        return Double.compare(circle.radius, radius) == 0;
    }

    @Override
    public int hashCode() {
        long temp = Double.doubleToLongBits(radius);
        return (int) (temp ^ (temp >>> 32));
    }
}

 @Test
    public void test08(){
        HashSet<Circle> set = new HashSet<>();
        set.add(new Circle(1));
        set.add(new Circle(1));
        System.out.println(set);
    }

3、大小顺序和重复问题：Comparable和Comparator接口

TreeSet元素不可重复是依赖于元素大小关系的。

（1）要么元素类型实现Comparable接口，重写compareTo方法，

（2）要么创建TreeSet时，指定Comparator接口实现类对象，重写compare方法

package com.atguigu.set;

public class Rectangle implements Comparable<Rectangle> {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double area(){
        return length * width;
    }

    @Override
    public String toString() {
        return "Rectangle{" +
                "length=" + length +
                ", width=" + width +
                ", area=" + area() +
                '}';
    }

    @Override
    public int compareTo(Rectangle o) {
        return Double.compare(this.area(), o.area());
//        int result = Double.compare(this.length, o.length);
//        return result != 0 ? result : Double.compare(this.width, o.width);
    }
}

   @Test
    public void test06(){
        TreeSet<Rectangle> set = new TreeSet<>();
        set.add(new Rectangle(5,3));
        set.add(new Rectangle(4,2));
        set.add(new Rectangle(6,1));
        set.add(new Rectangle(3,2));//进不去，因为Rectangle里面的compareTo方法按照面积比较大小
                                                //认为面积相同的就是相同的矩形对象

        System.out.println(set);
        /*'
        [Rectangle{length=6.0, width=1.0, area=6.0}, Rectangle{length=4.0, width=2.0, area=8.0}, Rectangle{length=5.0, width=3.0, area=15.0}]
         */
    }

    @Test
    public void test05(){
        TreeSet<Circle> set = new TreeSet<>(new Comparator<Circle>() {
            @Override
            public int compare(Circle o1, Circle o2) {
                return Double.compare(o1.getRadius(),o2.getRadius());
            }
        });
        set.add(new Circle(1.5));
        set.add(new Circle(1.0));
        set.add(new Circle(2.3));

        System.out.println(set);
        //[Circle{radius=1.0}, Circle{radius=1.5}, Circle{radius=2.3}]
    }

4 CollectionArray

4.1数组转换为集合的方法及注意事项

/*
数组转换成为集合:
    调用 Arrays.asList(T...elements) 会得到一个 List集合
        只能传入一个引用数据类型的数组，如果传入的是一个基本数据类型的数组，会把它当做一个元素
        int[] arr = {89, 45, 67, 88, 90, 76};
        List<int[]> list = Arrays.asList(arr); 不会将数组展开

集合转换成为数组:
    调用集合的toArray()方法
*/
public class CollectionArrayDemo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(89, 45, 67, 88, 90, 76);
        System.out.println(list.getClass());  // java.util.Arrays$ArrayList
        // Arrays.asList方法返回的List集合是一个内部类，不支持 add/remove方法
        // list.add(81); 尝试添加会报UnsupportedOperationException
        //它表示尝试执行了某个操作，但该操作在当前上下文中不被支持
        //但是编译不会报错，因为多态编译看左边，list集合有add方法
        System.out.println(list.get(0));//alist 不能增/删，只可以查
		
		//解决办法：new一个新的集合，再进行操作。
        List<Integer> x = new ArrayList<>(list);
        // x.addAll(list);
       // x.add(83);
        System.out.println(x);

        List<Integer> y = new ArrayList<>(Arrays.asList(89, 45, 67, 88, 90, 76));

        List<String> fruits = new ArrayList<>();
        fruits.add("apple");
        fruits.add("orange");
        fruits.add("peach");
        fruits.add("pear");

        // Object[] objects = fruits.toArray();
        // String[] objects = (String[])fruits.toArray();
        //类型转换不能数组之间转

        String[] arr = new String[fruits.size()];
        fruits.toArray(arr);
        System.out.println(Arrays.toString(arr));
    }
}

5removeif的使用

public class RemoveDemo {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("jack");
        names.add("tom");
        names.add("jerry");
        names.add("rose");
        names.add("mike");
        names.add("jordan");

       /* names.removeIf(s -> s.length() == 4);*/
        names.removeIf(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() == 4;
            }
        });//这个和他上面那个一样，上面是一个lambda表达式
        System.out.println(names);

        /*remove(names, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() == 4;
            }
        });
        System.out.println(names);*/
    }

    public static void remove(List<String> list, Predicate<String> predicate) {
        //Predicate是一个接口，使用removeif 需要实现他
        //它接受一个输入参数并返回一个布尔值结果
        Iterator<String> itr = list.iterator();
        while (itr.hasNext()) {
            String element = itr.next();
            // if (element.length() == 4) itr.remove();
            if (predicate.test(element)) itr.remove();
        }
    }
}

6 Collections 集合工具类

有关他的方法详细说明
更多内容可以参考这篇

/*
Collection 是集合，是一个容器，有两个子接口 List 和 Set,可以用来存储数据
Collections 是工具类，用来快速操作集合容器。

常见方法:
    addAll(Collection<T> c,T...elements): 将可变参数的元素都添加进集合c里
        如果传入的是一个基本数据类型的数组，会将基本数据类型数组当做一个参数
*/
public class CollectionsDemo {
    public static void main(String[] args) {
        Set<String> fruits = new HashSet<>();

        String[] arr = {"apple", "banana", "orange"};
        Collections.addAll(fruits, arr);  // 可以直接传入一个数组
        // fruits.addAll("peach","pear");
        System.out.println(fruits);

        List<Integer> nums = new ArrayList<>();
        nums.add(45);
        nums.add(89);

        Collections.addAll(nums, 88, 90, 78, 56);
        System.out.println(nums);

        int[] x = {84, 79};
         //Collections.addAll(nums,x);  //会报错，基本数据类型的数组，在传入到 Object可变参数时，会被当做一个整体
        System.out.println("nums: " + nums);
        Integer[] y = {66, 93};
        Collections.addAll(nums, y);  // 引用数据类型的数组会展开

        int[] arr1 = {92, 86};
        int[] arr2 = {88, 96};

        List<int[]> list = new ArrayList<>();
        Collections.addAll(list, arr1, arr2);

        List<String> names = new ArrayList<>();
        /*for (int i = 0; i < 10; i++) {
            names.set(i,"jack");
        }*/
        Collections.fill(names,"jack");
        System.out.println(names);
    }
}