黑马程序员---集合一

最新推荐文章于 2022-11-29 13:49:05 发布

小平_2015

最新推荐文章于 2022-11-29 13:49:05 发布

阅读量834

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/Ws11352369/article/details/17174323

版权

Java基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

集合一

----------- android培训、java培训、java学习型技术博客期待与您交流！ ------------

1.集合概述

1.1 概念

存储对象的容器。

1.2 集合出现的原因

1）面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象的最常用的一种方式。

2）集合之前有数组，但数组的长度是固定的，不方便操作。

3）而集合就是可以持有任意量的对象，长度可变。

1.3 集合与数组的异同

1）数组和集合类都是容器。

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

3）数组中存储的数据类型是单一的，集合中可以存储任意类型的对象。

1.3.1 集合类的特点

存储对象，长变可变，可存储不同类型的对象。

1.4 集合的分类（集合能做什么）

1）将对象添加到集合

2）从集合中删除对象

3）从集合中查找一个对象

4）从集合中修改一个对象

注：集合和数组中存放的都是对象的引用而非对象本身。

1.5 集合框架体系

文字概念如

---|Collection: 单列集合
         ---|List: 有存储顺序, 可重复
            ---|ArrayList:  数组实现, 查找快, 增删慢
                                由于是数组实现, 在增和删的时候会牵扯到数组
增容, 以及拷贝元素. 所以慢。数组是可以直接
按索引查找, 所以查找时较快
            ---|LinkedList: 链表实现, 增删快, 查找慢
                                由于链表实现, 增加时只要让前一个元素记住自
己就可以, 删除时让前一个元素记住后一个元
素, 后一个元素记住前一个元素. 这样的增删效
率较高但查询时需要一个一个的遍历, 所以效率
较低
            ---|Vector: 和ArrayList原理相同, 但线程安全, 效率略低
                            和ArrayList实现方式相同, 但考虑了线程安全问
题, 所以效率略低
         ---|Set: 无存储顺序, 不可重复
            ---|HashSet
            ---|TreeSet
            ---|LinkedHashSet
---| Map: 键值对
      ---|HashMap
      ---|TreeMap
      ---|HashTable
      ---|LinkedHashMap

为什么要出现这么多的集合容器，因为每一个容器对数据的存储方式不同，这种存储方式称之为数据结构（data structure）

1.6 什么时候使用什么的集合

1）我们需要保存若干个对象的时候使用集合。

2）如果我们需要保留存储顺序，并且保留重复的元素，使用List.

1. 如果查询较多，使用ArrayList

2. 如果存储较多，使用LinkedList

3. 如果需要线程安全，使用Vector

3）如果我们不需要存储顺序，并且需要去掉重复的元素，使用Set

1. 如果我们需要将元素排序，那么使用TreeSet

2. 如果不需要排序，使用HashSet

3. 如果我们需要保留存储顺序，又要过滤重复元素，那么使用LinkedHashSet

2. 集合类（Collection）

2.1 概念

集合共有的功能

Collection有两个子接口

1）List(链表|线性表)—可存放重复的元素，元素存取是无序的。

2）Set（集） --不可以存放重复元素，元素的存取是无序的。

如图示

2.2 Collection接口共有的方法

代码案例：

2.2.1 增加

import java.util.ArrayList;
import java.util.Collection;
public class AddDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建对象
        Collection list = new ArrayList();
//添加元素      
        list.add("计算机网络");                  
        list.add("现代系统技术");
        list.add("JSP技术开发详解");
        list.add("Java编程思想");
//输出
        System.out.println(list);               
        Collection list2 = new ArrayList(); 
        list2.add("Java入门到精通");
//将list的所有添加到list2
        list2.addAll(list);           
        list2.add("Java与模式");
//输出
        System.out.println(list2);          
    }
}
输出结果：
[计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想]
[Java入门到精通, 计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想, Java与模式]

2.2.2 删除

import java.util.ArrayList;
import java.util.Collection;
public class AddDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建对象
        Collection list = new ArrayList();
//添加元素     
        list.add("计算机网络");                  
        list.add("现代系统技术");
        list.add("JSP技术开发详解");
        list.add("Java编程思想");
 //输出
        System.out.println(list);              
        Collection list2 = new ArrayList(); 
        list2.add("Java入门到精通");
//将list的所有添加到list2
        list2.addAll(list);           
        list2.add("Java与模式");
//输出
        System.out.println(list2);
//删除list2中的元素         
        boolean remove = list2.remove("计算机网络");             
        System.out.println("是否已经删除《计算机网络》：" + remove);
        System.out.println(list2);
//删除list2中list集合
        remove = list2.removeAll(list);                 
        System.out.println("是否已经删除list集合中的东西：" + remove);
        System.out.println(list2);
    }
}
效果：
[计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想]
[Java入门到精通, 计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想, Java与模式]
是否已经删除《计算机网络》：true
[Java入门到精通, 现代系统技术, JSP技术开发详解, Java编程思想, Java与模式]
是否已经删除list集合中的东西：true
[Java入门到精通, Java与模式]

2.2.3 修改

import java.util.ArrayList;
import java.util.Collection;
public class AddDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建对象
        Collection list = new ArrayList();
//添加元素     
        list.add("计算机网络");                  
        list.add("现代系统技术");
        list.add("JSP技术开发详解");
        list.add("Java编程思想");
//输出
        System.out.println("集合中的内容" + list);
//清空了              
        list.clear();                                
        System.out.println("集合中的内容" + list);
    }
}
效果：
集合中的内容[计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想]
集合中的内容[]

2.2.4 判断

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建对象
        Collection list = new ArrayList();      
        Collection list2 = new ArrayList();
//添加元素
        list.add("计算机网络");                  
        list.add("现代系统技术");
        list.add("JSP技术开发详解");
        list.add("Java编程思想");
//输出
        System.out.println("集合中的内容" + list);               
        boolean empty = list.isEmpty();
//判断
        System.out.println("集合list是空的吗：" + empty);                   
        System.out.println("集合list2是空的吗：" + list2.isEmpty());
        boolean containers  = list.contains("Java编程思想");
//判断
        System.out.println("集合list中有Java编程思想吗：" + containers);
//为list2添加元素     
        list2.add("Java编程300例");                                        
        boolean containersAll = list.containsAll(list2);
//判断
        System.out.println("集合list中包含所有集合list2的元素吗？" + containersAll);   
    }
}
效果：
集合中的内容[计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想]
集合list是空的吗：false
集合list2是空的吗：true
集合list中有Java编程思想吗：true
集合list中包含所有集合list2的元素吗？false

2.2.5 获取

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建对象
        Collection list = new ArrayList(); 
//添加元素    
        list.add("计算机网络");                 
        list.add("现代系统技术");
        list.add("JSP技术开发详解");
        list.add("Java编程思想");
//输出
        System.out.println("集合中的内容" + list);               
        int size = list.size(); 
//获取长度                               
        System.out.println("集合list中的元素有" + size + "个");
    }
}
效果：
集合中的内容[计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想]
集合list中的元素有4个

练习：集合中添加自定义元素

1）

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo2 {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person p1 = new Person("张三",18);
        Person p2 = new Person("李四",20);
        Person p3 = new Person("五五",25);
//创建集合
        Collection coll = new ArrayList();
//添加元素                  
        coll.add(p1);                                        
        coll.add(p2);
        coll.add(p3);
        boolean isEmpty = coll.isEmpty();
//判断集合是否为空
        System.out.println("容器coll里有元素吗：" + isEmpty);  
        int size = coll.size();
//查看集合元素数
        System.out.println("容器里有多少个元素：" + size);    
        boolean containers = coll.contains(p1);
//判断某元素是否存在
        System.out.println("容器里有P1吗：" + containers);   
        boolean isDelete = coll.remove(p1);
//判断某元素是否已删除
        System.out.println("删除p1成功吗：" + isDelete);    
        System.out.println(coll);
//清空容器里的元素
          coll.clear();                                       
          System.out.println("容器里还有多个元素：" + coll.size());
    }
}
//集合的元素
class Person{                                       
    private String name;
    private int 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;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }
}
效果：
容器coll里有元素吗：false
容器里有多少个元素：3
容器里有P1吗：true
删除p1成功吗：true
[Person [age=20, name=李四], Person [age=25, name=五五]]
容器里还有多个元素：0

2）

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo3 {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Collection coll = new ArrayList();
        coll.add(new Book("java编程思想",100));
        coll.add(new Book("JSP开发技术",69));
        System.out.println(coll);
    }
}
class Book{
    private String name;
    private double price;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }  
    public Book() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Book(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }
    @Override
    public String toString() {
        return "Book [name=" + name + ", price=" + price + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        long temp;
        temp = Double.doubleToLongBits(price);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (Double.doubleToLongBits(price) != Double
                .doubleToLongBits(other.price))
            return false;
        return true;
    }
}
效果：
[Book [name=java编程思想, price=100.0], Book [name=JSP开发技术, price=69.0]]

2.3 List

2.3.1 List特有方法

2.3.2 代码实例

增加

import java.util.ArrayList;
import java.util.List;
public class ListAdd {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 //新建集合
        List list = new ArrayList();              
        List list2 = new ArrayList();
//向集合1添加元素
        list.add("计算机网络");                    
        list.add("Java编程思想");
        list.add("JSP开发技术详解");
        list.add("Java与模式");
//输出
        System.out.println("集合里的元素：" + list);
//在集合1指定位置添加元素
        list.add(0,"Java从入门到精通");          
        System.out.println("集合里的元素：" + list);
//往集合2添加元素
        list2.add("HTML技术详解");                  
        list2.add("JavaScript开发");
//把集合1插到集合2指定位置
        boolean addAll = list2.addAll(1,list);     
        System.out.println("添加集合list成功：" + addAll);
 //输出
        System.out.println(list2);                    
    }
}
效果：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
集合里的元素：[Java从入门到精通, 计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
添加集合list成功：true
[HTML技术详解, Java从入门到精通, 计算机网络, Java编程思想, JSP开发技术详解, Java与模式, JavaScript开发]

删除

import java.util.ArrayList;
import java.util.List;
public class ListDelete {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建集合
        List list = new ArrayList();
//向集合1添加元素               
        list.add("计算机网络");                    
        list.add("Java编程思想");
        list.add("JSP开发技术详解");
        list.add("Java与模式");
//输出
        System.out.println("集合里的元素：" + list);
//删除下标为1的元素
        Object o = list.remove(1);
//返回删除的元素                
        System.out.println(o);
//输出                   
        System.out.println("集合里的元素：" + list);
    }
}
效果：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
Java编程思想
集合里的元素：[计算机网络, JSP开发技术详解, Java与模式]

修改

import java.util.ArrayList;
import java.util.List;
public class ListUpdate {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建集合
        List list = new ArrayList();
//向集合1添加元素                
        list.add("计算机网络");                    
        list.add("Java编程思想");
        list.add("JSP开发技术详解");
        list.add("Java与模式");
//输出
        System.out.println("集合里的元素：" + list);
//返回被替代的元素
        Object o = list.set(2, "Java项目开发");
//打印被替代的元素      
        System.out.println(o);
//输出                   
        System.out.println("集合中的元素：" + list);
    }
}
效果：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
JSP开发技术详解
集合中的元素：[计算机网络, Java编程思想, Java项目开发, Java与模式]

查找

import java.util.ArrayList;
import java.util.List;
public class ListSearch {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建集合
        List list = new ArrayList();
//向集合1添加元素               
        list.add("计算机网络");                    
        list.add("Java编程思想");
        list.add("JSP开发技术详解");
        list.add("Java与模式");
//输出
        System.out.println("集合里的元素有：" + list);
        Object o = list.get(list.size() -1);
        System.out.println("查找的元素是：" + o);
        System.out.println("集合里的元素有：" + list);
        int lastIndex = list.lastIndexOf("Java与模式");
        System.out.println("java与模式的下标为：" + lastIndex);
        int index = list.indexOf("Java从入门到精通");
        if(index != -1){
            System.out.println("Java从入门到精通的下标是：" + index);
        }else{
            System.out.println("集合中没有Java从入门到精通这本书");
        }
    }
}
效果：
集合里的元素有：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
查找的元素是：Java与模式
集合里的元素有：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
java与模式的下标为：3
集合中没有Java从入门到精通这本书

求子集合

import java.util.ArrayList;
import java.util.List;
public class ListSub {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建集合
        List list = new ArrayList();
//向集合1添加元素              
        list.add("计算机网络");                    
        list.add("Java编程思想");
        list.add("JSP开发技术详解");
        list.add("Java与模式");
//输出
        System.out.println("集合里的元素有：" + list);
        int formIndex = 1 ;
//不包括下标为3的元素
        int toIndex = 3;
//返回子集合                             
        List subList = list.subList(formIndex,toIndex);
        System.out.println("集合list下标从" + formIndex + "到" + toIndex + "的子集合是：" + subList);
    }
}
效果：
集合里的元素有：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
集合list下标从1到3的子集合是：[Java编程思想, JSP开发技术详解]

2.4 ArrayList

2.4.1 实现原理

数组实现，查找快，增删慢

ArrayList是数组实现的，在增和删时会涉及到数组扩容，以及拷贝元素，所以会比较慢，但是数组可以直接按索引查找，所以查找时较快。

练习：去除ArrayList集合中重复的元素

import java.util.ArrayList;
public class ArrayListDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建集合
        ArrayList arr = new ArrayList();
//往集合arr中添加元素       
        arr.add(new Person("小明",20));       
        arr.add(new Person("小东",40));
        arr.add(new Person("小方",10));
        arr.add(new Person("小圆",30));
        arr.add(new Person("小明",20));
//输出集合的元素
        System.out.println("集合arr中的元素有：" + arr);
//新建集合 
        ArrayList list = new ArrayList();           
        for(int i = 0 ; i < arr.size(); i ++){
            Object o = arr.get(i);
            Person p = (Person)o;
//若重复则不添加
            if(!(list.contains(p))){                    
                list.add(p);
            }
        }
        System.out.println("集合list中的元素：" + list);
    }
}
//集合对象
class Person{                     
    private String name;
    private int 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;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }
}
效果：
集合arr中的元素有：[Person [age=20, name=小明], Person [age=40, name=小东], Person [age=10, name=小方], Person [age=30, name=小圆], Person [age=20, name=小明]]
集合list中的元素：[Person [age=20, name=小明], Person [age=40, name=小东], Person [age=10, name=小方], Person [age=30, name=小圆]]

注：在实际开发中ArrayList是使用频率最高的一种集合

2.5 LinkedList

因为LinkedList的底层是链表实现的，增加时只要让前一个元素记住自己即可，删除时让前一个元素记住后一个，但查询时需要一个一个遍历，所以效率低。

2.5.1 LiskedList特有方法

2.5.2 ArrayList和LinkedList的存储查找的优缺点

1）ArrayList是采用动态数组来存储元素的，它允许直接用下标来直接查找对应的元素，但是，插入元素涉及数据元素移动及内存的操作。总结：查找速度快，插入操作慢。

2）LinkedList是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度快。

2.6 Vector

2.6.1 Enumeration接口

实现 Enumeration 接口的对象，它生成一系列元素，一次生成一个。连续调用 nextElement 方法将返回一系列的连续元素。

主要方法

代码实现

import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Vector v = new Vector();
        v.addElement("Java入门与精通");
        v.addElement("Java编程思想");
        v.addElement("Java与模式");
        System.out.println("集合v中的元素有：" + v);
        System.out.println("集合v下标为2的元素是：" + v.elementAt(2));
        Enumeration e = v.elements();
        while(e.hasMoreElements()){
            System.out.println(e.nextElement());
        }
    }
}
效果：
集合v中的元素有：[Java入门与精通, Java编程思想, Java与模式]
集合v下标为2的元素是：Java与模式
Java入门与精通
Java编程思想
Java与模式

2.7 迭代器

为了方便处理集合中的元素，Java中出现了一个对象，该对象提供了一些方法专门处理集合中的元素---就是迭代器。

Collection接口中定义了获取集合类的迭代器方法（iterator()），所有Collection体系集合都可以获取自身的迭代器。

2.8 Iterable

Collection的父接口，实现了Iteratable的类就可迭代的，并且支持增强for循环。该接口只有一个方法即获取迭代器的方法Iterator()可以获取每个容器自身的迭代器Iterator。(Collection)集合容器都需要获取迭代器（Iterator）.

Collection接口都继承了Iterable，所以Collection体系都具备获取自身迭代器的方法。

该接口仅有一个方法，用于返回集合迭代对象。

2.8.1 Iterator

Iterator iterator()返回集合的迭代器对象。

Iterator接口定义的方法

迭代遍历

代码实例

1）while循环

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class WhileDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//新建集合
        ArrayList list = new ArrayList();
//向集合1添加元素                  
        list.add("计算机网络");                    
        list.add("Java编程思想");
        list.add("JSP开发技术详解");
        list.add("Java与模式");
//输出
        System.out.println("集合里的元素：" + list);
//新建迭代器
        Iterator it = list.iterator();
//判断集合是否有元素   
        while(it.hasNext()){
//输出集合中的元素             
            System.out.println(it.next()); 
        }
    }
}
输出:
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
计算机网络
Java编程思想
JSP开发技术详解
Java与模式

2）for循环

import java.util.ArrayList;
import java.util.Iterator;
public class ForDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub 
//新建集合
        ArrayList list = new ArrayList();
//向集合1添加元素                  
        list.add("计算机网络");                    
        list.add("Java编程思想");
        list.add("JSP开发技术详解");
        list.add("Java与模式");
//输出
        System.out.println("集合里的元素：" + list);
 //实在说我没有看明白这个循环
        for(Iterator it = list.iterator();it.hasNext();){ 
            System.out.println(it.next());
        }
    }
}
输出：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
计算机网络
Java编程思想
JSP开发技术详解
Java与模式

3）使用迭代器清空集合

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class RemoveDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Collection list = new ArrayList();
//向集合1添加元素
        list.add("计算机网络");                    
        list.add("Java编程思想");
        list.add("JSP开发技术详解");
        list.add("Java与模式");
//输出
        System.out.println("集合里的元素：" + list);
        Iterator it = list.iterator();
        while(it.hasNext()){
            it.next();
            it.remove();
        }
        System.out.println("集合里的元素：" + list);//输出
    }
}
输出：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
集合里的元素：[]
注：
1）如果迭代器的指针已经指向了集合的末尾，那么再调用next()会返回NoSuchElementException异常；
2）如果调用remove之前没有调用next()是不合法的，会抛出IllegalStateException异常
3）对集合进行迭代过程中，不允许出现迭代器以外的对元素的操作，因为这样会产生安全隐患，java会抛出异常并发修改异常（ConcurrentModificationException），普通迭代器只支持在迭代过程中删除动作。

2.8.2 List特有的迭代器ListIterator

ListIterator接口的方法

ListIterator在它的父类的基础上增加了（add(obj)）和修改（set(obj)）的操作。

List在迭代时，可以进行此两项操作。

倒序遍历

import java.util.ArrayList;
import java.util.ListIterator;
public class PreviousDemo {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList list = new ArrayList();
		list.add("计算机网络");                     //向集合1添加元素
		list.add("Java编程思想");
		list.add("JSP开发技术详解");
		list.add("Java与模式");
		System.out.println("集合里的元素：" + list);//输出
		ListIterator lil = list.listIterator();                      //使用ListIterator使用迭代对象
		while(lil.hasNext()){                                 //用next的方法输出元素
			System.out.println(lil.next());
		}
		System.out.println("*************************************");
		while(lil.hasPrevious()){                                 //用previous的方法输出元素
			System.out.println(lil.previous());
		}
	}
}
输出：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
计算机网络
Java编程思想
JSP开发技术详解
Java与模式
*************************************
Java与模式
JSP开发技术详解
Java编程思想
计算机网络

Set方法

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

import java.util.ArrayList;
import java.util.ListIterator;
public class SetDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList list = new ArrayList();
//向集合1添加元素
        list.add("计算机网络");                    
        list.add("Java编程思想");
        list.add("JSP开发技术详解");
        list.add("Java与模式");
//输出
        System.out.println("集合里的元素：" + list);
//使用ListIterator使用迭代对象
        ListIterator lil = list.listIterator();                      
            System.out.println(lil.next());
//将上一个next()输出的元素替换掉
            lil.set("如何快速学Java");
//输出                           
        System.out.println("集合里的元素：" + list);
    }
}
输出：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
计算机网络
集合里的元素：[如何快速学Java, Java编程思想, JSP开发技术详解, Java与模式]

Add方法

将指定元素插入列表，该元素直接插入到next()返回的元素的后面。

import java.util.ArrayList;
import java.util.ListIterator;
public class AddDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList list = new ArrayList();
//向集合1添加元素
        list.add("计算机网络");                    
        list.add("Java编程思想");
        list.add("JSP开发技术详解");
        list.add("Java与模式");
//输出
        System.out.println("集合里的元素：" + list);
//使用ListIterator使用迭代对象
        ListIterator lil = list.listIterator();                     
            System.out.println(lil.next());
//在计算机网络后插入了元素
            lil.add("21天学通C语言");
//输出                       
            System.out.println("集合里的元素：" + list);
    }
}
输出：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
计算机网络
集合里的元素：[计算机网络, 21天学通C语言, Java编程思想, JSP开发技术详解, Java与模式]

----------- android培训、java培训、java学习型技术博客期待与您交流！ ------------