List-ArrayList 与LinkedList、Vector以及迭代器详解

最新推荐文章于 2023-12-11 21:46:04 发布

黑码哥

最新推荐文章于 2023-12-11 21:46:04 发布

阅读量1k

点赞数 2

分类专栏： Java研发进阶之路文章标签： Collection ArrayList LinkedList Vector List

本文链接：https://blog.csdn.net/liyunxiangrxm/article/details/54576172

版权

Java研发进阶之路专栏收录该内容

49 篇文章 12 订阅

订阅专栏

1. 集合

1.1. 什么是集合

存储对象的容器，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象最常用的一种方式。
集合的出现就是为了持有对象。集合中可以存储任意类型的对象, 而且长度可变。在程序中有可能无法预先知道需要多少个对象, 那么用数组来装对象的话, 长度不好定义, 而集合解决了这样的问题。

1.2. 集合和数组的区别

数组和集合类都是容器
数组长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象数组中存储数据类型是单一的，集合中可以存储任意类型的对象。
集合类的特点
用于存储对象，长度是可变的，可以存储不同类型的对象。

1.3. 集合的分类

这里写图片描述

1.4. 什么时候该使用什么样的集合

这里写图片描述

二. 集合类(Collection)

2.1. Collection接口的共性方法

增加：
        1：add() 将指定对象存储到容器中
                      add 方法的参数类型是Object 便于接收任意对象
        2：addAll() 将指定集合中的元素添加到调用该方法和集合中
删除：
        3：remove() 将指定的对象从集合中删除
        4：removeAll() 将指定集合中的元素删除
修改
        5：clear() 清空集合中的所有元素
判断
        6：isEmpty() 判断集合是否为空
        7：contains() 判断集合何中是否包含指定对象

        8：containsAll() 判断集合中是否包含指定集合
                            使用equals()判断两个对象是否相等  
获取:   9：int size()    返回集合容器的大小

转成数组10： toArray()   集合转换数组

2.1.1. 增加：

public static void main(String[] args) {
        Collection list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        System.out.println(list);
        // [计算机网络, 现代操作系统, java编程思想]

        // 增加2 将list容器元素添加到list2容器中
        Collection list2 = new ArrayList();
        list2.add("java核心技术");
        list2.addAll(list);
        list2.add("java语言程序设计");
        System.out.println(list2);
        // [java核心技术, 计算机网络, 现代操作系统, java编程思想, java语言程序设计]
    }

2.1.2. 删除：

// 删除1 remove
        boolean remove = list2.remove("java核心技术");
        System.out.println(remove); // true
        System.out.println(list2); //
        //删除2 removeAll() 将list中的元素删除
        boolean removeAll = list2.removeAll(list);
        System.out.println(removeAll);//true
        System.out.println(list2);//[java语言程序设计]

2.1.3. 修改：

public static void main(String[] args) {
        Collection list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // 修改 clear() 清空集合中的所有元素
        list.clear();
        System.out.println(list); //[] 
    }

2.1.4. 判断：

public static void main(String[] args) {
        Collection list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);

        boolean empty = list.isEmpty();
        System.out.println(empty);// false
        boolean contains = list.contains("java编程思想");
        System.out.println(contains);// true
        Collection list2 = new ArrayList();
        list2.add("水许传");
        boolean containsAll = list.containsAll(list2);
        System.out.println(containsAll);// false

    }

2.1.5. 获取：

public static void main(String[] args) {
        Collection list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // 获取  集合容器的大小 
        int size = list.size();
        System.out.println(size); 
    }

2.2. List

---| Iterable     接口 
          Iterator iterator()
    ----| Collection     接口
        ------| List      接口 元素可以重复，允许在指定位置插入元素，并通过索
引来访问元素

2.2.1. List集合特有方法

1：增加
        void add(int index, E element) 指定位置添加元素            
        boolean addAll(int index, Collection c) 指定位置添加集合  
2：删除
E remove(int index) 删除指定位置元素

3：修改
        E set(int index, E element)    返回的是需要替换的集合中的元素
4：查找：
        E get(int index)             注意： IndexOutOfBoundsException
        int indexOf(Object o)         // 找不到返回-1
        lastIndexOf(Object o) 
5：求子集合
         List<E> subList(int fromIndex, int toIndex) // 不包含toIndex

2.2.1.1. 增加

public static void main(String[] args) {
        List list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // add,在0角标位置添加一本书
        list.add(0, "舒克和贝塔");
        System.out.println(list);
        // 在list2集合的1角标位置添加list集合元素
        List list2 = new ArrayList();
        list2.add("史记");
        list2.add("资治通鉴");
        list2.add("全球通史");
        boolean addAll = list2.addAll(1, list);
        System.out.println(addAll); //true       System.out.println(list2);
    }

2.2.1.2. 删除

public static void main(String[] args) {
        List list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // 删除0角标元素
        Object remove = list.remove(0);
        System.out.println(remove);
    }

2.2.1.3. 修改：

public static void main(String[] args) {
        List list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // 修改2角标位置的书，返回的原来2角标位置的书
        Object set = list.set(2, "边城");
        System.out.println(set); //java编程思想
        System.out.println(list); 

    }

查找

    List list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // 查找： E get(int index)  注意角标越界
        Object set = list.get(list.size() - 1);
        System.out.println(set); // java语言程序设计
        System.out.println(list);
list.get(list.size()); //IndexOutOfBoundsException
    }

2.2.1.4. 查找

public static void main(String[] args) {
        List list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        list.add("java编程思想");
        System.out.println(list);
        // 查找： E get(int index) 注意角标越界
        Object set = list.get(list.size() - 1);
        System.out.println(set); // java语言程序设计
        System.out.println(list);
        // list.get(list.size()); //IndexOutOfBoundsException

        // indexOf(Object o) 返回第一次出现的指定元素的角标
        int indexOf = list.indexOf("java编程思想");
        System.out.println(indexOf); // 2
        // 没有找到，返回-1
        int indexOf2 = list.indexOf("三国志");
        System.out.println(indexOf2); // -1

        // lastIndexOf 返回最后出现的指定元素的角标
        int lastIndexOf = list.lastIndexOf("java编程思想");
        System.out.println(lastIndexOf); // 5
    }

2.2.2. ArrayList

--| Iterable
              ----| Collection
                 ------| List
                      ---------| ArrayList  底层采用数组实现，默认10。每次增长
60%,（(oldCapacity * 3)/2 + 1） 查询快，增删慢。
                 ---------| LinkedList

ArrayList:实现原理：

数组实现, 查找快, 增删慢数组为什么是查询快?因为数组的内存空间地址是连续的. ArrayList底层维护了一个Object[]
用于存储对象，默认数组的长度是10。可以通过 new ArrayList(20)显式的指定用于存储对象的数组的长度。
当默认的或者指定的容量不够存储对象的时候，容量自动增长为原来的容量的1.5倍。由于ArrayList是数组实现,
在增和删的时候会牵扯到数组增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快
可以考虑,假设向数组的0角标未知添加元素,那么原来的角标位置的元素需要整体往后移,并且数组可能还要增容,一旦增容,就需要要将老数组的内容拷贝到新数组中.所以数组的增删的效率是很低的.

练习：去除ArrayList集合中重复元素
        1：存入字符串元素
        2：存入自定义对象元素（如Perosn对象）
原理：
     循环遍历该集合，每取出一个放置在新的集合中，放置之前先判断新的集合是否以包含了新的元素。
思路:
 存入人的对象.
 1先定义person 类
 2将该类的实例存入集合
 3 将对象元素进行操作. 注意:自定义对象要进行复写toString 和 equals 方法.
 为什么? 因为object 是person 的父类,object 中的toString 返回的是哈希值,object 类中equals
 方法比较的是对象的地址值.
 思路
 1存入字符串对象 
 2存入自定义对象 如person
 2创建容器,用于存储非重复元素
 3对原容器进行遍历,在遍历过程中进行判断遍历到的元素是否在容器中存在.(contains)
 4如果存在,就不存入,否则存入.
 5 返回新容器

public class Demo6 {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList();
        Person p1 = new Person("jack", 20);
        Person p2 = new Person("rose", 18);
        Person p3 = new Person("rose", 18);
        arr.add(p1);
        arr.add(p2);
        arr.add(p3);
        System.out.println(arr);
        ArrayList arr2 = new ArrayList();
        for (int i = 0; i < arr.size(); i++) {
            Object obj = arr.get(i);
            Person p = (Person) obj;
            if (!(arr2.contains(p))) {
                arr2.add(p);
            }
        }
        System.out.println(arr2);
    }
}

class Person {
    private String name;
    private int age;

    public Person() {

    }

    public Person(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 int hashCode() {
        return this.name.hashCode() + age * 37;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person) obj;

        return this.name.equals(p.name) && this.age == p.age;
    }

    @Override
    public String toString() {
        return "Person@name:" + this.name + " age:" + this.age;
    }

}

在实际的开发中ArrayList是使用频率最高的一个集合。

2.2.3. LinkedList

--| Iterable
              ----| Collection
                 ------| List
                      ---------| ArrayList  底层采用数组实现，默认10。每次增长
60%,（(oldCapacity * 3)/2 + 1） 查询快，增删慢。
                 ---------| LinkedList  底层采用链表实现，增删快，查询慢。         
LinkedList:链表实现, 增删快, 查找慢

由于LinkedList:在内存中的地址不连续,需要让上一个元素记住下一个元素.所以每个元素中保存的有下一个元素的位置.虽然也有角标,但是查找的时候,需要从头往下找,显然是没有数组查找快的.但是,链表在插入新元素的时候,只需要让前一个元素记住新元素,让新元素记住下一个元素就可以了.所以插入很快.
由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高。
但查询时需要一个一个的遍历, 所以效率较低。

特有方法

1：方法介绍
            addFirst(E e) 
addLast(E e) 
getFirst() 
getLast() 
removeFirst() 
removeLast() 
如果集合中没有元素，获取或者删除元
素抛：NoSuchElementException
2：数据结构
                1：栈 （1.6）
                    先进后出
                    push() 
                    pop()
                2：队列（双端队列1.5）
                    先进先出
                    offer()
                    poll()
3：返回逆序的迭代器对象      
descendingIterator()   返回逆序的迭代器对象

基本方法

import java.util.Iterator;
import java.util.LinkedList;

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("西游记");
        list.add("三国演义");
        list.add("石头记");
        list.add("水浒传");
        list.add("全球通史");
        list.addFirst("史记");
        list.addLast("呐喊");
        // list.addFirst(null);
        // list.addLast(null);
        System.out.println(list);
        // 获取指定位置处的元素。
        String str = (String) list.get(0);
        // 返回此列表的第一个元素。
        String str2 = (String) list.getFirst();
        System.out.println(str.equals(str2));

        // 获取指定位置处的元素。
        String str3 = (String) list.get(list.size() - 1);
        // 返回此列表的最后一个元素。
        String str4 = (String) list.getLast();
        System.out.println(str3.equals(str4));

        // 获取但不移除此列表的头（第一个元素）。
        Object element = list.element();
        System.out.println(element);

        int size = list.size();
        System.out.println(size);
}

迭代

mport java.util.Iterator;
import java.util.LinkedList;

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("西游记");
        list.add("三国演义");
        list.add("石头记");
        list.add("水浒传");
        list.add("全球通史");
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String next = (String) it.next();
            System.out.println(next);
        }
    }
}

逆序迭代

import java.util.Iterator;
import java.util.LinkedList;

public class Demo6 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        Iterator dit = list.descendingIterator();
        while (dit.hasNext()) {
            System.out.println(dit.next());
        }
    }
}

注意：可以使用该集合去模拟出队列(先进先出) 或者堆栈(后进先出) 数据结构。堆栈(后进先出) //堆栈(后进先出) 数据结构

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        // 压栈，先进后出
        list.push("西游记");
        list.push("三国演义");
        list.push("石头记");
        list.push("水浒传");
        System.out.println(list);
        // 弹栈
        String str1 = (String) list.pop();
        System.out.println(str1);
        String str2 = (String) list.pop();
        System.out.println(str2);
        String str3 = (String) list.pop();
        System.out.println(str3);
        String str4 = (String) list.pop();
        System.out.println(str4);
        System.out.println(list.size());// 0
        System.out.println(list); //[]
    }
}

队列，先进先出

import java.util.LinkedList;

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        // 队列，先进先出
        list.offer("西游记");
        list.offer("三国演义");
        list.offer("石头记");
        list.offer("水浒传");
        System.out.println(list);
        // 出队列
        System.out.println(list.poll());
        System.out.println(list.poll());
        System.out.println(list.poll());
        System.out.println(list.poll());

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

        System.out.println(list.peek()); // 获取队列的头元素，但是不删除
        System.out.println(list.peekFirst()); // 获取队列的头元素，但是不删除
        System.out.println(list.peekLast()); // 获取队列的最后一个元素但是不删除

    }
}

ArrayList 和 LinkedList的存储查找的优缺点：
1、ArrayList是采用动态数组来存储元素的，它允许直接用下标号来直接查找对应的元素。但是，但是插入元素要涉及数组元素移动及内存的操作。总结：查找速度快，插入操作慢。
2、LinkedList是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快
问题：有一批数据要存储，要求存储这批数据不能出现重复数据，ArrayList、LinkedList都没法满足需求。解决办法：使用 set集合。

2.2.4. Vector

Vector: 描述的是一个线程安全的ArrayList。

ArrayList：单线程效率高
Vector ：多线程安全的，所以效率低
特有的方法：

 void addElement(E obj)  在集合末尾添加元素
 E elementAt( int index) 返回指定角标的元素
 Enumeration elements()  返回集合中的所有元素，封装到Enumeration对象中

Enumeration 接口：

boolean hasMoreElements()
测试此枚举是否包含更多的元素。
E nextElement()
如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

public static void main(String[] args) 
    {
        Vector v = new Vector();
        v.addElement("aaa");
        v.addElement("bbb");
        v.addElement("ccc");
        System.out.println( v );
        System.out.println( v.elementAt(2) );   // ccc
        // 遍历Vector遍历
        Enumeration ens = v.elements();
        while ( ens.hasMoreElements() )
        {
            System.out.println( ens.nextElement() );
        }
    }

2.3. 迭代器

    为了方便的处理集合中的元素,Java中出现了一个对象,该对象提供了一些方法专门处理集合中的元素.例如删除和获取集合中的元素.该对象就叫做迭代器(Iterator).
    对 Collection 进行迭代的类，称其为迭代器。还是面向对象的思想，专业对象做专业的事情，迭代器就是专门取出集合元素的对象。但是该对象比较特殊，不能直接创建对象（通过new），该对象是以内部类的形式存在于每个集合类的内部。如何获取迭代器？Collection接口中定义了获取集合类迭代器的方法（iterator（）），所以所有的Collection体系集合都可以获取自身的迭代器。
    正是由于每一个容器都有取出元素的功能。这些功能定义都一样，只不过实现的具体方式不同（因为每一个容器的数据结构不一样）所以对共性的取出功能进行了抽取，从而出现了Iterator接口。而每一个容器都在其内部对该接口进行了内部类的实现。也就是将取出方式的细节进行封装。

2.3.1. Utterable

    Jdk1.5之后添加的新接口, Collection的父接口. 实现了Iterable的类就是可迭代的.并且支持增强for循环。该接口只有一个方法即获取迭代器的方法iterator（）可以获取每个容器自身的迭代器Iterator。（Collection）集合容器都需要获取迭代器（Iterator）于是在5.0后又进行了抽取将获取容器迭代器的iterator（）方法放入到了Iterable接口中。Collection接口进程了Iterable，所以Collection体系都具备获取自身迭代器的方法，只不过每个子类集合都进行了重写（因为数据结构不同）

2.3.2. Iterator

    Iterator iterator() 返回该集合的迭代器对象
该类主要用于遍历集合对象，该类描述了遍历集合的常见方法
            1：java.lang. Itreable  
             ---| Itreable      接口 实现该接口可以使用增强for循环
                ---| Collection     描述所有集合共性的接口
                    ---| List接口     可以有重复元素的集合
                    ---| Set接口      不可以有重复元素的集合

public interface Iterable
Itreable 该接口仅有一个方法，用于返回集合迭代器对象。
1： Iterator iterator() 返回集合的迭代器对象

Iterator接口定义的方法

Itreator    该接口是集合的迭代器接口类，定义了常见的迭代方法
    1：boolean hasNext() 
                        判断集合中是否有元素，如果有元素可以迭代，就返回true。
    2： E next()  
                        返回迭代的下一个元素，注意： 如果没有下一个元素时，调用
next元素会抛出NoSuchElementException

    3： void remove()
                        从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操
作）。

思考：为什么next方法的返回类型是Object的呢？为了可以接收任意类型的对象,那么返回的时候,不知道是什么类型的就定义为object

2.3.3. 迭代器遍历

1：while循环

public static void main(String[] args) {
        ArrayList list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String next = (String) it.next();
            System.out.println(next);
        }
    }

2：for循环

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

public class Demo2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);

        for (Iterator it = list.iterator(); it.hasNext();) {
             //迭代器的next方法返回值类型是Object，所以要记得类型转换。
            String next = (String) it.next();
            System.out.println(next);
        }
    }
}

需要取出所有元素时，可以通过循环，java 建议使用for 循环。因为可以对内存进行一下优化。

3：使用迭代器清空集合

public class Demo1 {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
        System.out.println(coll);
        Iterator it = coll.iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
        System.out.println(coll);
    }
}

细节一：
如果迭代器的指针已经指向了集合的末尾，那么如果再调用next()会返回NoSuchElementException异常

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

public class Demo2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);

        Iterator it = list.iterator();
        while (it.hasNext()) {
            String next = (String) it.next();
            System.out.println(next);
        }
        // 迭代器的指针已经指向了集合的末尾
        // String next = (String) it.next();
        // java.util.NoSuchElementException
    }
}

细节二：
如果调用remove之前没有调用next是不合法的，会抛出IllegalStateException

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

public class Demo2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);

        Iterator it = list.iterator();
        while (it.hasNext()) {
            // 调用remove之前没有调用next是不合法的
            // it.remove();
            // java.lang.IllegalStateException
            String next = (String) it.next();
            System.out.println(next);
        }

    }
}

4：迭代器原理

查看ArrayList源码

private class Itr implements Iterator<E> {

        int cursor = 0;

        int lastRet = -1;

        int expectedModCount = modCount;

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

        public E next() {
            checkForComodification();
            try {
                E next = get(cursor);
                lastRet = cursor++;
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public void remove() {
            if (lastRet == -1)
                throw new IllegalStateException();
            checkForComodification();

            try {
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }


    }

5：注意在对集合进行迭代过程中，不允许出现迭代器以外的对元素的操作，因为这样会产生安全隐患，java会抛出异常并发修改异常（ConcurrentModificationException），普通迭代器只支持在迭代过程中的删除动作。

注意： ConcurrentModificationException:
当一个集合在循环中即使用引用变量操作集合又使用迭代器操作集合对象，会抛出该异常。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;  
public class Demo1 {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
        System.out.println(coll);
        Iterator it = coll.iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
            coll.add("abc"); // 出现了迭代器以外的对元素的操作
        }
        System.out.println(coll);
    }
}

如果是List集合，想要在迭代中操作元素可以使用List集合的特有迭代器ListIterator，该迭代器支持在迭代过程中，添加元素和修改元素。

2.3.4. List特有的迭代器ListIterator

public interface ListIterator extends Iterator

ListIterator<E> listIterator()
---| Iterator
        hasNext()
        next()
        remove()
       ------| ListIterator Iterator子接口 List专属的迭代器
                  add(E e)    将指定的元素插入列表（可选操作）。该元素直接插入到 next 返回的下一个元素的前面（如果有）
                  void set(E o)   用指定元素替换 next 或 previous 返回的最后一个元素
                  hasPrevious()    逆向遍历列表，列表迭代器有多个元素，则返回 true。
                  previous()       返回列表中的前一个元素。

Iterator在迭代时，只能对元素进行获取(next())和删除(remove())的操作。对于 Iterator
的子接口ListIterator 在迭代list 集合时，还可以对元素进行添加 (add(obj))，修改set(obj)的操作。

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

public class Demo2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
         // 获取List专属的迭代器
        ListIterator lit = list.listIterator();

        while (lit.hasNext()) {
            String next = (String) lit.next();
            System.out.println(next);
        }

    }
}

倒序遍历

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

public class Demo2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // 获取List专属的迭代器
        ListIterator lit = list.listIterator();
        while (lit.hasNext()) {
            String next = (String) lit.next();
            System.out.println(next);
        }
        System.out.println("***************");
        while (lit.hasPrevious()) {
            String next = (String) lit.previous();
            System.out.println(next);
        }

    }
}

Set方法：用指定元素替换 next 或 previous 返回的最后一个元素

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

public class Demo2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);

        ListIterator lit = list.listIterator();
        lit.next(); // 计算机网络
        lit.next(); // 现代操作系统
        System.out.println(lit.next()); // java编程思想
        //用指定元素替换 next 或 previous 返回的最后一个元素
        lit.set("平凡的世界");// 将java编程思想替换为平凡的世界
        System.out.println(list);

    }
}

add方法将指定的元素插入列表，该元素直接插入到 next 返回的元素的后

public class Demo2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);

        ListIterator lit = list.listIterator();
        lit.next(); // 计算机网络
        lit.next(); // 现代操作系统
        System.out.println(lit.next()); // java编程思想
        // 将指定的元素插入列表，该元素直接插入到 next 返回的元素的后
        lit.add("平凡的世界");// 在java编程思想后添加平凡的世界
        System.out.println(list);

    }
}