java基础学习_集合类01_对象数组、集合Collection接口、集合List接口_day15总结

=============================================================================
=============================================================================
涉及到的知识点有：
1:对象数组的概述和案例(掌握)
　　(1)对象数组的概述
　　(2)对象数组的案例
2:集合(Collection接口)(掌握)
　　(1)集合的由来？
　　(2)集合和数组的区别？
　　(3)集合的继承体系结构
　　(4)Collection接口的概述
　　(5)Collection接口的成员方法(注意：默认方法前有public abstract修饰)
　　(6)Collection集合的遍历
　　(7)迭代器
　　(8)Collection集合的案例(遍历方式：迭代器方式)(要求：用记事本默写)
　　　　A:存储字符串并遍历
　　　　B:存储自定义对象并遍历
3:集合(List接口)(掌握)
　　(1)List是Collection的子接口
　　(2)List的特有功能(注意：默认方法前有public abstract修饰)
　　(3)List集合的特有遍历功能
　　(4)列表迭代器的特有功能(了解)
　　(5)ConcurrentModificationException 并发修改异常
　　(6)常见的数据结构以及其优缺点
　　(7)List的子类特点(面试题)
　　(8)List集合的案例(遍历方式 迭代器和普通for循环)
=============================================================================
=============================================================================
1:对象数组的概述和案例(掌握)
　　(1)对象数组的概述
　　　　数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
　　(2)对象数组的案例
　　　　我有5个学生，请把这个5个学生的信息存储到数组中，并遍历学生数组，获取得到每一个学生的信息。

　　　　

　　　　示例代码如下：

package cn.itcast_01;

public class Student {
    // 成员变量
    private String name;
    private int age;

    // 构造方法
    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    // 成员方法
    // getXxx()/setXxx()
    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 String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

package cn.itcast_01;

/*
 * 我有5个学生，请把这个5个学生的信息存储到数组中，并遍历学生数组，获取得到每一个学生的信息。
 *         学生类：Student
 *             成员变量：name,age
 *             构造方法：无参,带参
 *             成员方法：getXxx()/setXxx()
 *         存储学生的数组？自己想想应该是什么样子的？
 * 分析：
 *         A:创建学生类。
 *         B:创建学生数组(对象数组)。
 *         C:创建5个学生对象，并赋值。
 *         D:把C步骤的元素，放到学生数组中。
 *         E:遍历学生数组。
 */
public class ObjectArrayDemo {
    public static void main(String[] args) {
        // 创建学生数组(对象数组)。
        Student[] students = new Student[5];
        
        // 遍历新创建的学生数组。
        for (int x = 0; x < students.length; x++) {
            System.out.println(students[x]);
        }
        System.out.println("---------------------");

        // 创建5个学生对象，并赋值。
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("风清扬", 30);
        Student s3 = new Student("刘意", 30);
        Student s4 = new Student("赵雅芝", 60);
        Student s5 = new Student();
        s5.setName("王力宏");
        s5.setAge(27);
        
        // 把C步骤的元素，放到学生数组中。
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;
        students[3] = s4;
        students[4] = s5;

         // 看到很相似，就想用循环改，把C步骤的元素，放到学生数组中。
         // for (int x = 0; x < students.length; x++) {
         //      students[x] = s + "" + (x + 1); // 拼完之后是一个字符串了。
         // }
         // 这个是有问题的。

        // 遍历赋值后的学生数组，用重写的toString()方法
        for (int x = 0; x < students.length; x++) {
            // 重写toString()方法，注意：一个方法写定之后就不要再去改变了。因为改来改去的还不如重新写个方法呢？
            System.out.println(students[x]); 
        }
        System.out.println("---------------------");
        
        // 遍历赋值后的学生数组，用getXxx()方法
        for (int x = 0; x < students.length; x++) {            
            // System.out.println(students[x].getName() + "---" + students[x].getAge()); // 或者等价于下面
            // 因为学生数组的每一个元素都是一个学生。
            Student s = students[x];
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

-----------------------------------------------------------------------------
2:集合(Collection接口)(掌握)
　　(1)集合的由来？
　　　　我们学习的是Java --> 面向对象 --> 操作很多对象 --> 存储 --> 容器(数组和StringBuffer) --> 数组
　　　　而数组的长度是固定的，当添加的元素超过了数组的长度需要对数组重新定义，太麻烦，所以数组不适合做变化的需求，Java内部就给我们提供了集合类供我们使用。
　　　　集合类能存储任意对象，长度是可以改变的，即长度能随着元素的增加而增加，随着元素的减少而减少。
　　(2)集合和数组的区别？
　　　　A:长度区别
　　　　　　数组长度固定，不能自动增长。
　　　　　　集合的长度的是可变的,可以根据元素的增加而增长。
　　　　B:内容区别
　　　　　　数组只能存储同一种类型。
　　　　　　集合可以存储不同类型(其实集合一般存储的也是同一种类型)。
　　　　C:元素的数据类型区别
　　　　　　数组既可以存储基本数据类型，又可以存储引用数据类型；基本数据类型存储的是值，引用数据类型存储的是地址值。
　　　　　　集合只能存储引用数据类型(对象)，其实集合中也可以存储基本数据类型，但是在存储的时候会自动装箱变成对象。
---------------------------------------
　　(3)集合的继承体系结构
　　　　刚说过集合是存储多个元素的，但是呢，存储多个元素我们也是有不同需求的：
　　　　　　比如说，我要这多个元素中不能有相同的元素；
　　　　　　再比如说，我要这多个元素按照某种规则排序一下。
　　　　针对不同的需求，Java就提供了不同的集合类，这样呢，Java就提供了很多个集合类。
　　　　　　这多个集合类的数据结构不同，数据结构不同不重要的，重要的是你要能够存储东西，并且还要能够使用这些东西，比如说存储、获取、判断等。
　　　　　　既然这样，那么，这多个集合类是有共性的内容的，我们把这些集合类的共性内容不断的向上提取，最终就能形成集合的继承体系结构。
　　　　如下图所示：

　　　　
　　Collection(单列集合的根接口)
　　　　|--List(有序:存和取的顺序一致,有索引,可以存储重复元素)
　　　　　　|--ArrayList(数组实现)
　　　　　　|--Vector(数组实现)
　　　　　　|--LinkedList(链表实现)
　　　　|--Set(无序:存和取的顺序不一致,无索引,不可以存储重复元素)
　　　　　　|--HashSet(哈希算法)
　　　　　　|--TreeSet(二叉树算法)
---------------------------------------
　　(4)Collection接口的概述
　　　　Collection接口是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。(后面会慢慢的讲解)
　　　　Collection表示一组对象，这些对象也称为collection的元素。
　　　　JDK不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现。
　　(5)Collection接口的成员方法(注意：默认方法前有public abstract修饰)
　　　　1：添加功能
　　　　　　boolean add(Object obj)　　 添加一个元素
　　　　　　boolean addAll(Collection c)  添加一个集合的元素
　　　　2:删除功能
　　　　　　void clear() 　　　　　　　　　    移除所有元素
　　　　　　boolean remove(Object o) 　　     移除一个元素
　　　　　　boolean removeAll(Collection c)    移除一个集合的元素(只要集合中有一个元素被移除了，就返回true)
　　　　3:判断功能
　　　　　　boolean contains(Object o) 　　    判断集合中是否包含指定的元素
　　　　　　boolean containsAll(Collection c)   判断集合中是否包含指定的集合元素(只有集合包含所有的元素，才返回true，才叫包含)
　　　　　　boolean isEmpty() 　　    　　　　判断集合是否为空
　　　　4:获取功能(重点学)
　　　　　　Iterator<E> iterator() 　返回在此集合的元素上进行迭代的迭代器。是集合专用的遍历方式。
　　　　5:长度功能
　　　　　　int size() 　　                元素的个数（即集合的长度）
　　　　　　面试题：
　　　　　　　　数组有没有length()方法呢？ 答：没有。特别注意：因为数组求长度是：数组名.length，而不是：数组名.length()
　　　　　　　　字符串有没有length()方法呢？ 答：有。
　　　　　　　　集合有没有length()方法呢？ 答：没有，因为集合求长度的方法是size()。
　　　　6:交集功能(了解)
　　　　　　boolean retainAll(Collection c) 　　两个集合都有的元素？思考：元素去哪了？返回的boolean又是什么意思呢？
　　　　　　　　// 假设有两个集合A，B。
　　　　　　　　// A对B做交集，最终的结果保存在集合A中，集合B不变。
　　　　　　　　// 但是返回值表示的是集合A是否发生过改变。
　　　　　　　　// 集合A没有发生改变，返回false，即集合B包含集合A；
　　　　　　　　// 集合A发生改变，返回true。
　　　　7：把集合转成对象数组，可以实现集合的遍历(了解)
　　　　　　Object[] toArray()
---------------------------------------
　　(6)Collection集合的遍历
　　　　A:把集合转成对象数组(了解)
　　　　　　练习：用集合存储5个学生对象，并把学生对象进行遍历(遍历方式：把集合转成对象数组，需要用记事本背着写出来)。
　　　　　　示例代码如下：

package cn.itcast_02;

public class Student {
    // 成员变量
    private String name;
    private int age;

    // 构造方法
    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    // 成员方法
    // getXxx()/setXxx()
    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;
    }
}

package cn.itcast_02;

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

/*
 * 练习：用集合存储5个学生对象，并把学生对象进行遍历(遍历方式：把集合转成对象数组，需要用记事本背着写出来)。
 * 
 * 分析：
 *         A:创建学生类
 *         B:创建集合对象
 *         C:创建学生对象
 *         D:把学生添加到集合
 *         E:把集合转成对象数组
 *         F:遍历对象数组
 */
public class StudentDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();

        // 创建学生对象
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("风清扬", 30);
        Student s3 = new Student("令狐冲", 33);
        Student s4 = new Student("武鑫鑫", 25);
        Student s5 = new Student("刘晓曲", 22);

        // 把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(s5);

        // 把集合转成对象数组，向上转型
        Object[] objs = c.toArray();
        // 遍历对象数组
        for (int x = 0; x < objs.length; x++) {
            // System.out.println(objs[x]); // 没有重写toString()方法

            // 向下转型
            Student s = (Student) objs[x];
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

　　　

　　　　B:迭代器(集合的专用遍历方式)
　　　　　　练习：用集合存储5个学生对象，并把学生对象进行遍历(遍历方式：用迭代器进行遍历)。
　　　　　　示例代码如下：

package cn.itcast_03;

public class Student {
    // 成员变量
    private String name;
    private int age;

    // 构造方法
    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    // 成员方法
    // getXxx()/setXxx()
    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 String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    
}

package cn.itcast_03;

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

/*
 * 练习：用集合存储5个学生对象，并把学生对象进行遍历。用迭代器进行遍历。
 * 
 * 注意：
 *         A:自己的类名不要和我们学习的要使用的API中的类名相同。
 *         B:复制代码的时候，很容易把那个类所在的包也导入过来，容易出现不能理解的问题。
 */
public class IteratorTest {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();

        // 创建学生对象
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("风清扬", 30);
        Student s3 = new Student("令狐冲", 33);
        Student s4 = new Student("武鑫鑫", 25);
        Student s5 = new Student("刘晓曲", 22);

        // 把学生添加到集合中
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(s5);

        // 遍历
        Iterator it = c.iterator();
        while (it.hasNext()) {
            // System.out.println(it.next()); // 重写了toString()方法
            Student s = (Student) it.next();  // 向下转型
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

　　　　　　迭代器使用出现的2个想问题解释：
　　　　　　　　问题1:能用while循环写这个程序，我能不能用for循环呢？
　　　　　　　　　　答：能。用for循环改写，遍历完成后，it这个对象就变成垃圾了，可以被JVM的垃圾回收器进行回收了，效率高，但是结构不是特别明朗。
　　　　　　　　问题2:不要多次使用it.next()方法，因为每次使用都去访问一个对象。
　　　　　　　　　　//System.out.println(((Student) it.next()).getName() + "---" + ((Student) it.next()).getAge());
　　　　　　　　　　//NoSuchElementException 不要多次使用it.next()方法。
---------------------------------------
　　(7)迭代器
　　　　A:迭代器是集合的获取元素的方式。
　　　　B:迭代器是依赖于集合而存在的。
　　　　　　因为迭代器是通过集合调用集合的方法而得到的。即必须先有集合，然后才有迭代器。
　　　　　　Collection接口的成员方法
　　　　　　　　Iterator iterator() 　　迭代器，集合的专用遍历方式。
　　　　　　Iterator接口的成员方法
　　　　　　　　boolean hasNext()    判断如果仍有元素可以迭代，则返回 true。
　　　　　　　　Object next() 　　　 获取元素，并移动到下一个位置。
　　　　　　　　NoSuchElementException 没有这样的元素异常，因为你已经找到最后了。
　　　　C:迭代器的原理图解和源码浅析
　　　　　　a:迭代器为什么定义了一个接口而不是实现类？
　　　　　　　　假如把迭代器定义为一个类，这样我们就可以创建该类的对象，调用该类的方法来实现集合的遍历了。
　　　　　　　　但是，java中提供了很多的集合类，而这些集合类的数据结构是不同，所以它们的存储方法也是不同的，
　　　　　　　　进而它们的遍历方法也是不一样的，最终就没有把迭代器定义为一个类了。
　　　　　　　　　　(因为定义成一个迭代器类就是一个具体的实现了，既然是具体实现那么它们的遍历方式就是一样的了)

　　　　　　　　而无论是那种集合，都应该具备获取元素的功能，并且最好辅助以判断的功能，这样在获取前，先判断，就不容易出错。
　　　　　　　　也就是说，判断和获取功能应该是一个集合遍历所具备的，而每种集合的遍历方式又不太一样，
　　　　　　　　所以把这两个功能给提取出来，并不提供具体的实现，而这种方式叫做接口。

　　　　　　　　那么，真正的具体的实现类在哪里呢？
　　　　　　　　在真正的具体的子类中，是以内部类的方式体现的。
　　　　　　　　　　(因为在子类中要包含两个方法)
　　　　　　　　如下图所示：

　　　　
　　　　　　b:迭代器的内部类实现源码浅析

-----------------------------------------------------------------------------
public interface Inteator {
    public abstract boolean hasNext(); // 注意：默认方法前有public abstract修饰，是接口中方法的默认修饰符
    public abstract Object next();     // 注意：默认方法前有public abstract修饰，是接口中方法的默认修饰符
}

public interface Iterable {
    Iterator iterator(); // 没有具体实现，注意：默认方法前有public abstract修饰，是接口中方法的默认修饰符
}
-----------------------------------------------------------------------------
public interface Collection extends Iterable {
    Iterator iterator(); // 没有具体实现，注意：默认方法前有public abstract修饰，是接口中方法的默认修饰符
}

public interface List extends Collection {
    Iterator iterator(); // 没有具体实现，注意：默认方法前有public abstract修饰，是接口中方法的默认修饰符
}
-----------------------------------------------------------------------------
public class ArrayList implements List {
    public Iterator iterator() { // 具体实现
        return new Itr();
    }
    
    private class Itr implements Iterator { // Itr是Iterator接口的实现类
        public boolean hasNext() {}
        public Object next(){} 
    }
}
-----------------------------------------------------------------------------
Collection c = new ArrayList();
c.add("hello");
c.add("world");
c.add("java");
Iterator it = c.iterator();     // new Itr();
while(it.hasNext()) {
    String s = (String)it.next();
    System.out.println(s);
}
-----------------------------------------------------------------------------

---------------------------------------
　　(8)Collection集合的案例(遍历方式：迭代器方式)(要求：用记事本默写)
　　　　集合的使用步骤：
　　　　　　A:创建集合对象
　　　　　　B:创建元素对象
　　　　　　C:把元素添加到集合
　　　　　　D:遍历集合
　　　　　　　　a:通过集合对象获取迭代器对象
　　　　　　　　b:通过迭代器对象的hasNext()方法判断是否有元素
　　　　　　　　c:通过迭代器对象的next()方法获取元素并移动到下一个位置

　　　　A:存储字符串并遍历

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

            public class CollectionDemo {
                public static void main(String[] args) {
                    // 创建集合对象
                    Collection c = new ArrayList();
                    
                    // 创建元素对象
                    String s = new String("hello");
                    // 把元素添加到结合
                    c.add(s);
                    c.add("world");
                    c.add("java");
                    
                    // 遍历集合
                    // 通过集合对象获取迭代器对象
                    Iterator it = c.iterator();
                    while (it.hasNext()) {
                        String s1 = (String) it.next();
                        System.out.println(s1);
                    }
                }
            }

---------------------------------------
　　　　B:存储自定义对象并遍历

            public class Student {
                private String name;
                private int age;

                public Student() {
                    super();
                }

                public Student(String name, int age) {
                    super();
                    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;
                }

            }

            import java.util.Collection;
            import java.util.ArrayList;
            import java.util.Iterator;
            
            public class StudentDemo {
                public static void main(String[] args) {
                    // 创建集合对象
                    Collection c = new ArrayList();
                    
                    // 创建学生对象
                    Student s1 = new Student("貂蝉", 25); // 含参构造
                    Student s2 = new Student("小乔", 16);
                    Student s3 = new Student("黄月英", 20);
                    Student s4 = new Student(); // 无参构造
                    s4.setName("大乔");
                    s4.setAge(26);

                    // 把学生对象添加到集合对象中
                    c.add(s1);
                    c.add(s2);
                    c.add(s3);
                    c.add(s4);
                    c.add(new Student("孙尚香", 18)); // 匿名对象
                    
                    // 遍历集合
                    Iterator it = c.iterator();
                    while (it.hasNext()) {
                        Student s = (Student) it.next();
                        System.out.println(s.getName() + "---" + s.getAge());
                    }
                }
            }

-----------------------------------------------------------------------------
3:集合(List接口)(掌握)
　　(1)List是Collection的子接口
　　　　特点：有序(存储顺序和取出顺序一致)，有索引，可以存储重复元素。
　　(2)List的特有功能(注意：默认方法前有public abstract修饰)
　　　　A:添加功能
　　　　　　void add(int index, Object element) 　　在指定位置添加元素
　　　　B:删除功能
　　　　　　Object remove(int index) 　　根据索引删除元素，返回被删除的元素
　　　　C:获取功能
　　　　　　Object get(int index) 　　      获取指定位置的元素
　　　　D:列表迭代器功能
　　　　　　ListIterator listIterator() 　　  List集合特有的迭代器
　　　　E:修改功能
　　　　　　Object set(int index, Object element)   根据索引修改元素，返回被修该的元素
---------------------------------------
　　(3)List集合的特有遍历功能
　　　　A:由size()和get()结合。
　　　　B:代码演示

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

        public class ListDemo {
            public static void main(String[] args) {
                // 创建集合对象
                List list = new ArrayList();
                
                // 创建元素对象，并添加
                list.add("hello");
                list.add("wprld");
                list.add("java");
                
                // 通过集合对象获取迭代器对象
                Iterator it = list.iterator();
                // 迭代器遍历集合
                while (it.hasNext()) {
                    String s = (String) it.next();
                    System.out.println(s);
                }
                
                // 普通for循环遍历集合
                for (int x = 0; x < list.size(); x++) {
                    String s = (String) list.get(x);
                    System.out.println(s);
                }
            }
        }

---------------------------------------
　　(4)列表迭代器的特有功能(了解)
　　　　Object previous() 　　　　获取上一个元素
　　　　boolean hasPrevious() 　  判断是否有元素
　　　　注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。
　　(5)ConcurrentModificationException 并发修改异常
　　　　当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
　　　　A:出现的现象
　　　　　　迭代器在遍历集合时，用集合去修改集合元素。
　　　　B:产生的原因
　　　　　　迭代器是依赖于集合而存在的，在判断成功后，集合中新添加了元素，集合发生了改变，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。
　　　　　　其实这个问题描述的是：迭代器在遍历元素的时候，通过集合是不能修改元素的。
　　　　C:解决的方案
　　　　　　a:迭代器迭代元素，用列表迭代器(ListIterator)修改元素
　　　　　　　　元素是跟在刚才迭代的元素后面的。
　　　　　　　　注意：Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator列表迭代器。
　　　　　　b:集合遍历元素，用集合修改元素(普通for循环：size()和get())
　　　　　　　　元素是在最后添加的。(即元素添加在集合的末尾)
---------------------------------------
　　(6)常见的数据结构以及其优缺点
　　　　A:栈 　　　   先进后出
　　　　B:队列 　　   先进先出
　　　　C:数组 　　   查询快，增删慢
　　　　D:链表 　　   查询慢，增删快
　　　　E:树
　　　　F:哈希表
　　　　如下图所示：

　　　　

　　　　
---------------------------------------
　　(7)List的子类特点(面试题)
　　　　ArrayList
　　　　　　底层数据结构是数组，查询快，增删慢。
　　　　　　线程不安全，效率高。
　　　　Vector
　　　　　　底层数据结构是数组，查询快，增删慢。
　　　　　　线程安全，效率低。
　　　　LinkedList
　　　　　　底层数据结构是链表，查询慢，增删快。
　　　　　　线程不安全，效率高。

　　　　List有三个儿子，我们到底使用谁呢?
　　　　　　看需求(看情况)。
　　　　分析：
　　　　　　要安全吗?
　　　　　　　　要：Vector(即使要，也不使用这个，后面有替代的)
　　　　　　　　不要：ArrayList或者LinkedList
　　　　　　查询多：ArrayList
　　　　　　增删多：LinkedList

　　　　什么都不知道，就用ArrayList。
---------------------------------------
　　(8)List集合的案例(遍历方式：迭代器和普通for循环)
　　　　A:存储字符串并遍历

　　　　　　示例代码如下：

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

public class ListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();
        
        // 创建元素对象，并添加
        list.add("hello");
        list.add("wprld");
        list.add("java");
        
        // 通过集合对象获取迭代器对象
        Iterator it = list.iterator();
        // 迭代器遍历集合
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }
        
        // 普通for循环遍历集合
        for (int x = 0; x < list.size(); x++) {
            String s = (String) list.get(x);
            System.out.println(s);
        }
    }
}

　　　　B:存储自定义对象并遍历

　　　　　　示例代码如下：

package cn.itcast_03;

public class Student {
    // 成员变量
    private String name;
    private int age;

    // 构造方法
    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    // 成员方法
    // getXxx()/setXxx()
    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;
    }
}

package cn.itcast_03;

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

/*
 * 存储自定义对象并遍历，遍历方式：迭代器和普通for循环。(size()和get()结合)
 */
public class ListDemo3 {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

        // 创建学生对象
        Student s1 = new Student("林黛玉", 18);
        Student s2 = new Student("刘姥姥", 88);
        Student s3 = new Student("王熙凤", 38);

        // 把学生添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);

        // 遍历
        // 迭代器遍历集合
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }
        System.out.println("-----------");

        // 普通for循环遍历集合
        for (int x = 0; x < list.size(); x++) {
            Student s = (Student) list.get(x);
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

=============================================================================