java集合(1)

集合框架

相关问题

• 集合Collection中存储的如果是自定义类的对象，需要自定义类重写哪个方法？为什么？

• equals()方法

  • contains()

  • remove()

  • retainsAll()

List：equals()方法

Set：（HashSet、LinkedHashSet为例）：equals(),hashCode()

• TreeSet为例：

  • Comparable:compareTo(Object obj)

  • Comparator:compare(Object o1,Object o2)

• ArrayList,LinkedList,Vector三者接口类的相同点和不同点？（面试题）

同：三类都是作为实现类的接口，存储数据的特点相同，都是有序的、可重复的数据

不同：ArrayList：作为List主要的接口实现类，线程不安全的，执行效率高，底层使用Object[]存储 LinkedList：对于频繁的插入，删除操作，使用此类效率比ArrayList效率高，底层使用双向链表存储 对于数据量大的情况，插入，删除数据，对于ArrayList来说需要数据迁移，效率很低， 使用双向链表，作插入，删除操作，只跟前后两个位置有关。 Vector：作为List接口的古老实现类（不怎么用），线程安全的，效率低，底层使用Object[]存储

• List接口的常用方法有那些？

  • add(Object 0bj)

  • remove(Object obj)/remove(int index)

  • set(int index,Object obj)

  • get(int index)

  • add(int index,Object obj)

  • size()

  • 遍历：Iterator;foreach;普通的for

• 如何使用Iterator和增强for循环遍历List？

• Set存储数据的特点是什么？常见的实现类有什么？

  • HashSet:底层对应HashMap

  • LinkHashSet:LinkHashSetMap

  • TreeSet:TreeMap

• 什么是枚举类？枚举类的对象声明的修饰符都有那些？

  • 枚举类：类中的对象的个数是确定得到，有限个。

  • public static final

• 什么是元注解？说说Retention和Target元注解的作用。

  • 元注解：对现有的注解进行解释说明的注解

  • Retention：指明所修饰的注解的生命周期：

    • SOURCE

    • CLASS

    • RUNTINE

  • Target：指定所修饰的Annotation能用于修饰那些程序元素

  • Documented：表示所修饰的注解在被javadoc解析时保留下来

  • Inherited：被它修饰的annotation将具有继承性

• 什么是集合框架？存储数据的特点是什么？

  • collection接口：单列集合，用来存储一个一个的对象

  • List接口：存储有序的、可重复的数据：动态数组

    • ArrayList、LinkedList、Vector

  • Set接口：存储无序的、不可重复的数据

    • HashSet、LinkedHashSet、TreeSet

  • Map接口：双列集合。用来存储一对（key-value）数据

    • HashMap、LinkedHashMap、TreeMap、Hashtable

• 比较throw和throws的异同。

  • throw：抛出一个异常对象，使用在方法内部，手动抛出一个异常对象

  • throws：处理异常的方式，使用在方法声明处的末尾，try-catch-finally

  • 两者像是一种递进的关系

• 对同步代码块中同步监视器和共享数据的理解及各自要求。

  • 同步监视器：俗称锁，

    • 任何一个类的对象都可以充当锁

    • 多个线程共用同一把锁

  • 共享数据：多个线程共同操作的数据

  • 需要使用同步机制将操作共享数据的代码包起来，不能包多了也不能包少了。

集合框架

枚举类

• 说明：

  • 枚举类：类的对象只有有限个确定的

  • 当需要定义一组常量时，强烈建议使用枚举类

  • 如果枚举类中只有一个对象，则可以作为单例模式的实现方式

• 如何自定义枚举类？

• 注解：

  • 框架=注解+ 反射机制 +设计模式

• 通过反射来进行获取调用注解！前提：要求注解的元注解retation中声明的声明周期状态为：RUNTIME

import java.lang.annotation.*;
​
@Inherited
@Retention(RetentionPolicy.RUNTIME)//指明所修饰的注解的生命周期
public @interface MyAnnotation {
    String value() default "hello";
}
​
/*
1.注解声明为：@interface
2.内部定义成员，通常用value表示
3，可以指定成员的默认值，使用default定义
4.如果自定义注解没成员，表面是一个标识作用
5.说明：
如果注解成员，在使用注解时，需要指明成员的值
自定义注解必须配上注解的信息处理流程（使用反射）才有意义
自定义注解通过都会指明两个元注解：Retention，Target
 */

集合

说明

• 集合、数组都是对多个数据进行内存层面存储操作的结构，简称java容器

• 数组在存储多个数据的特点：

  • 初始化后长度确定不能改变

  • 数组定义好，其元素的类型也确定了，只能操作指定类型的数据了，比如：String[] arr; int [] arr; Object arr;

  • 有序、可重复。

  • 数组没有现成的属性或方法可以用，提供的方法有限

• 集合存储的优点：

  • 解决数组存储数据的缺点。

collection接口

• 单例集合框架结构

• collection接口：单列集合，用来存储一个一个的对象

  • List接口：存储有序的、可重复的数据：动态数组

  • 常用的实现类：

  ArrayList、LinkedList、Vector

  • Set接口：存储无序的、不可重复的数据

  • 常用的实现类：

  HashSet、LinkedHashSet、TreeSet

• Map接口：双列集合。用来存储一对（key-value）数据

  • HashMap、LinkedHashMap、TreeMap、Hashtable

Collection中的List接口

• ArrayList类的源码分析

//jdk7:
ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementDate
list.add(123);//elementDate[] = new Integer(123);
...
list.add(11);//如果此次的添加导致底层elementDate数组容量不够，则扩容
//1.默认扩容为原来的1.5倍，同时将原来的数组元素复制到新的数组中。
//2.结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
//jdk8:
ArrayList list = new ArrayList();//底层Object[]数组elementDate初始化为{}，并没有创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementDate中
...
list.add(11);//如果此次的添加导致底层elementDate数组容量不够，则扩容
//1.默认扩容为原来的1.5倍，同时将原来的数组元素复制到新的数组中。
//2.结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

• 结论：jdk7中AarryList的对象的创建上来就造好数组，jdk8中添加数组的时候才造数组，延迟了数组的创建，节省了内存。

• LinkedList的源码分析

//jdk8:双向链表
Node<>存放数据的地方，内部类别人不用，自己用：
    private static class Node<E>{
        item;
        Node<E> next;
        Node<E> prev;
        
        Node(Node<E> prev,E element,Node<E> next){
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
    
LinkedList list = new LinkedList();//内部声明了node类型的first和last属性，默认值为null

• Vector的源码分析

//1.底层都创建了长度为10的数组
//2.扩容长度为原来的2倍

List接口的常用方法

package collection;
​
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
​
/*
常用方法：
增：add(Object obj)
删：remove(int index)  /  remove(Object obj)
改：set(int index ,Object ele)
查：get(int index)
插：add(int index,Object ele)
长度：size()
遍历：1.Iterator迭代器
     2.增强for循环
     3。普通for循环
 */
public class ListTest {
    public void test(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("liuxiang",23));
        list.add(456);
​
        System.out.println(list);
​
        //1.void add(int index,Object ele):在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list);
​
        //2.boolean addAll(int index,Collection eles):从index位置将eles中所有元素添加
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list);
        System.out.println(list.size());//9
​
        //3.Object get(int index):获取指定index位置的元素
        System.out.println(list.get(5));
​
        //4.int indexOf(Object obj):返回obj在集合中首次出现的位置,如果不存在返回-1
        int index = list.indexOf(456);
        System.out.println(index);
​
        //5.int lastIndexOf(Object obj):返回obj在集合中最后一次出现的位置
        int index1 = list.lastIndexOf(456);
        System.out.println(index1);
​
        //6.Object remove(int index):移除指定index位置的元素，并返回此元素，相当于重载方法
        Object obj = list.remove(1);
        System.out.println(obj);//返回删除位置的元素
        System.out.println(list);
​
        //7.Object set(int index,Object ele):设置指定index位置的元素为ele
        list.set(1,"LL");
        System.out.println(list);
​
        //8.List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开子集合
        List sublist = list.subList(1, 4);
        System.out.println(sublist);
    }
​
​
    //测试
    public static void main(String[] args) {
        ListTest listTest = new ListTest();
        listTest.test();
    }
}

• 练习题

package collection;
​
import java.util.ArrayList;
import java.util.List;
​
public class ListExer {
    public void test(){
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.remove(2);//删除的是索引的位置2
        list.remove(new Integer(2));//自己新建了一个对象，删除的是值2
        System.out.println(list);
    }
​
    public static void main(String[] args) {
        ListExer listExer = new ListExer();
        listExer.test();
    }
​
}

​

Set接口的实现类

• HashSet:作为Set接口的主要实现类，线程不安全的，可以存储null值 LinkedHashSet:作为HashSet的子类，遍历其内部数据时可以按照添加的顺序遍历,对于频繁的遍历，效率要高于HashSet TreeSet:底层使用红黑树存储，添加的元素是同一类new的对象，按照属性进行排序

• Set接口中没有额外定义新的方法，使用的都是Collection中声明的方法

• 向Set中添加的数据，其所在类一定要重写hashCode()和equals()方法， 要保持一致性：相等的对象必须要有相等的散列码。

• 一： 以HashSet为例说明： 1.无序性：不等于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加， 而是根据数据的哈希值决定的。

  2.不可重复性：保证添加的元素是按照equals()判断时，不能返回true，即相同元素只能添加一个。

  二：添加元素的过程：以HashSet为例：底层是数组 向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值， 此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即索引位置），判断： 情况一： 数组此位置上是否已经有元素： 如果此位置上没有其他元素，则元素a添加成功 如果此位置上有其他元素b（或者以链表形式存在多个元素），则比较a与b的hash值： 情况二： 如果hash值不相同，a添加成功 如果hash值相同，进而需要调用元素a所在类的equals()方法： 情况三： equals()返回ture，元素a添加失败 equals()返回false，元素a添加成功

  情况二和三：元素a与其他元素以链表的方式存储，（先到先排，后来后排）

package set;
​
​
import collection.User;
​
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
​
/*
Set接口：存储无序的、不可重复的数据
常用的实现类:
HashSet:作为Set接口的主要实现类，线程不安全的，可以存储null值
  LinkedHashSet:作为HashSet的子类，遍历其内部数据时可以按照添加的顺序遍历
TreeSet:底层使用红黑树存储，添加的元素是同一类new的对象，按照属性进行排序
​
1.Set接口中没有额外定义新的方法，使用的都是Collection中声明的方法
2.向Set中添加的数据，其所在类一定要重写hashCode()和equals()方法，
要保持一致性：相等的对象必须要有相等的散列码。
​
 */
public class SetTest {
    /*
   一： 以HashSet为例说明：
    1.无序性：不等于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加，
    而是根据数据的哈希值决定的。
​
    2.不可重复性：保证添加的元素是按照equals()判断时，不能返回true，即相同元素只能添加一个。
​
    二：添加元素的过程：以HashSet为例：底层是数组
    向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
    此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即索引位置），判断：
    情况一：
    数组此位置上是否已经有元素：
    如果此位置上没有其他元素，则元素a添加成功
    如果此位置上有其他元素b（或者以链表形式存在多个元素），则比较a与b的hash值：
   情况二：
    如果hash值不相同，a添加成功
    如果hash值相同，进而需要调用元素a所在类的equals()方法：
   情况三：
    equals()返回ture，元素a添加失败
    equals()返回false，元素a添加成功
​
   情况二和三：元素a与其他元素以链表的方式存储，（先到先排，后来后排）
​
   重写hashCode()方法中，有31==（i<<5）-1来作为系数，优化算法。
     */
    public void test(){
        HashSet set = new HashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("cc");
        set.add(new User("liuxiang",23));
        set.add(new User("liuxiang",23));
        set.add(346);
​
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
​
    }
​
​
    //测试
    public static void main(String[] args) {
        SetTest setTest = new SetTest();
        setTest.test();
    }
}

​

• TreeSet实现类

package collection;
​
public class User implements Comparable{
    private String name;
    private int age;
​
    public User() {
    }
​
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    //重写equals()
    @Override
    public boolean equals(Object o) {
        System.out.println("User equal()...");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
​
        User user = (User) o;
​
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }
​
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
​
    //按照姓名从小到大排，再按价格从小到大排
    @Override
    public int compareTo(Object o) {
        if (o instanceof User){
            User user = (User) o;
            //return this.name.compareTo(user.name);
            //如果两个名字相同，结果输不出，需要重写
            int compare = this.name.compareTo(user.name);
            if (compare != 0){
                return compare;//名字不相等，输出
            }else {
                return Integer.compare(this.age,user.age);
            }
        }else {
            throw new RuntimeException("输入的类型不匹配");
        }
    }
}
​
package collection;
​
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
​
/*
向TreeSet中添加数据，要求相同类的对象
TreeSet:底层使用红黑树（小的在左边，大的在右边）存储，添加的元素是同一类new的对象，按照属性进行排序
自然排序：比较两个对象是否相同的标准为：compareTo()方法，返回0，不再是equals()方法
定制排序：跟(Comparator接口有关):
 */
public class TreeSetTest {
​
    public void test(){
​
        TreeSet set = new TreeSet();
          //举例一
//        set.add(34);
//        set.add(-34);
//        set.add(24);
//        set.add(11);
//        set.add(8);
​
        //举例二:报错：ClassCastException
        //需要进行User implement（继承）Comparable接口重写方法
        set.add(new User("liuxiang",23));
        set.add(new User("duyao",22));
        set.add(new User("jim",26));
        set.add(new User("koko",54));
        set.add(new User("congcong",6));
        set.add(new User("congcong",36));
​
        Iterator iterator = set.iterator();//按从小到大的顺序排列
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
​
    public void test1() {
        Comparator com = new Comparator() {//alt+enter+add method
            //按照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof User && o2 instanceof User) {
                    User u1 = (User) o1;
                    User u2 = (User) o2;
                    return Integer.compare(u1.getAge(), u2.getAge());
                } else {
                    throw new RuntimeException("输入的数据不一致");
                }
            }
        };
        TreeSet set = new TreeSet(com);//按参数里面的方法进行排序
        set.add(new User("liuxiang", 23));
        set.add(new User("duyao", 22));
        set.add(new User("jim", 26));
        set.add(new User("koko", 54));
        set.add(new User("congcong", 54));//被先占了结果中就无了
        set.add(new User("congcong", 36));
​
        Iterator iterator = set.iterator();//按从小到大的顺序排列
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
​
​
​
    //测试
    public static void main(String[] args) {
        TreeSetTest treeSetTest = new TreeSetTest();
        treeSetTest.test1();
    }
}

​

• 对应图示：

collection接口常用方法

package collection;
​
import java.util.Objects;
​
public 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;
    }
    //提供tostring
​
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
//重写方法：alt+insert+equals()and hasCode()
​
    @Override
    public boolean equals(Object o) {
        System.out.println("Person equals().....");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
​
        Person person = (Person) o;
​
        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }
​
   // @Override
   // public int hashCode() {
    //    int result = name != null ? name.hashCode() : 0;
    //    result = 31 * result + age;
     //   return result;
   // }
}
​

package collection;
​
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
​
/*
collection接口声明的方法的测试
​
向Collection接口的实现类的对象中添加obj时，要求obj所在类要重写equals()方法
 */
public class CollectionTest {
​
    public void test(){
        Collection coll = new ArrayList();//接口的具体实现类：有序的，可重复的
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));//string类型
        coll.add(false);//布尔类型
       // Person p = new Person("liuxiang",23);
       // coll.add(p);
        coll.add(new Person("liuxiang",23));//自定义Person类
​
        //1.contains（Object obj）方法：判断当前集合当中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()方法
        boolean contains = coll.contains(123);//结果为true
        System.out.println(contains);
        System.out.println(coll.contains(new String("Tom")));
        //ture,调用的是equals，比的是内容
        //System.out.println(coll.contains(p));//ture
        System.out.println(coll.contains(new Person("liuxiang",23)));
        //false,方法没有重写，调用的Object类，变成true，重写方法:调用equals()方法
​
        //2.containsAll(Collection coll1):判断形参coll1中所有元素是否都存在于当前集合中
        Collection coll1 = Arrays.asList(123,456);
        System.out.println(coll.containsAll(coll1));//判断coll中是否包含coll1中的所有元素
​
    }
​
    public void test1(){
        //3.remove(object obj):从当前集合中移除obj元素
        Collection coll = new ArrayList();//接口的具体实现类
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));//string类型
        coll.add(false);//布尔类型
        coll.add(new Person("liuxiang",23));//自定义Person类
​
        coll.remove(123);//删除数据
        System.out.println(coll);
​
        coll.remove(new Person("liuxiang",23));
        System.out.println(coll);//可以移除，因为重写了equals()方法
​
        //4.removeAll(Collection coll1):移除所有元素
        Collection coll1 = Arrays.asList(123,456);
        coll.removeAll(coll1);
        System.out.println(coll);
    }
​
    public void test2(){
        Collection coll = new ArrayList();//接口的具体实现类
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));//string类型
        coll.add(false);//布尔类型
        coll.add(new Person("liuxiang",23));//自定义Person类
​
        //5.retainAll(Collection coll1):求交集
        Collection coll1 = Arrays.asList(123,456,789);
        coll.retainAll(coll1);
        System.out.println(coll);
    }
​
    public void test3(){
        Collection coll = new ArrayList();//接口的具体实现类
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));//string类型
        coll.add(false);//布尔类型
        coll.add(new Person("liuxiang",23));//自定义Person类
​
        Collection coll1 = new ArrayList();//接口的具体实现类
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));//string类型
        coll.add(false);//布尔类型
        coll.add(new Person("liuxiang",23));//自定义Person类
​
        //6.equals(coll.equals(coll1)):返回boolean值
        System.out.println(coll.equals(coll1));
    }
​
    public void test4(){
        Collection coll = new ArrayList();//接口的具体实现类
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));//string类型
        coll.add(false);//布尔类型
        coll.add(new Person("liuxiang",23));//自定义Person类
​
        //7.hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());
​
        //8.coll.toArray()集合可以转换为数组
        Object[] arr = coll.toArray();
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
​
        //拓展：数组可以转换为集合,返回的是list类型
        List<String> list = Arrays.asList(new String[]{"aa", "bb", "dd"});
        System.out.println(list);
​
        List<int[]> arr1 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr1);//输出[[I@4554617c]，默认一个数组
​
        List<Integer> arr2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr2);//输出[123, 456]，用Integer类型变成两个数组
    }
​
    public void test5(){
        //9.iterator():迭代器，返回Iterator接口的实例，用于遍历集合元素，放在IteratorTest.java中测试
    }
    //测试
    public static void main(String[] args) {
        CollectionTest collectionTest = new CollectionTest();
        collectionTest.test4();
    }
}

​

迭代器iterator

• iterator():迭代器，返回Iterator接口的实例，用于遍历集合元素，放在IteratorTest.java中测试

package collection;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
/*
集合元素的遍历操作，使用迭代器Iterator接口
集合对象每次调用iterator()方法都会得到一个全新的迭代器对象，
默认游标都在第一个元素之前
 */
public class IteratorTest {
​
    public void test(){
        Collection coll = new ArrayList();//接口的具体实现类
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));//string类型
        coll.add(false);//布尔类型
        coll.add(new Person("liuxiang",23));//自定义Person类
​
        Iterator iterator = coll.iterator();//得到迭代器对象
        //方式一(不推荐)
       // for (int i = 0; i < coll.size(); i++) {
        //    System.out.println(iterator.next());
       // }
​
        //方式二(推荐):hasNext方法
        while(iterator.hasNext()){
            //next()指针先下移，再返回集合位置上的元素值
            System.out.println(iterator.next());
        }
    }
​
    //测试
    public static void main(String[] args) {
        IteratorTest iteratorTest = new IteratorTest();
        iteratorTest.test();
    }
}

​

迭代器的执行原理

• 生成迭代器对象时，就有一个空指针iterator.next(),执行hasNext()判断还有没有下一个元素，指针并下移，iterator对象不是容器，就是一个迭代器，容器还是原先的coll

• 集合对象每次调用iterator()方法都会得到一个全新的迭代器对象，默认游标都在第一个元素之前

• 错误写法：

​

    //错误写法
    public void test1(){
        Collection coll = new ArrayList();//接口的具体实现类
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));//string类型
        coll.add(false);//布尔类型
        coll.add(new Person("liuxiang",23));
​
        //方式一:会出现输出元素跳转，第一次下一个指针到123时，判断不是null，输出下一个456
        //到最后还有异常：NoSuchElementException
        Iterator iterator = coll.iterator();
        while(iterator.next() != null){
            System.out.println(iterator.next());
        }
​
        //方式二：会一直循环输出123，死循环
        //当判断新的迭代器hasNext()方法是true，输出迭代器的123，循环重复新的迭代器继续输出123
        while(coll.iterator().hasNext()){
            System.out.println(coll.iterator().next());
        }

• 迭代器中的remove()方法

• 如果还没有调用next()或者在上一次调用next方法后已经调用了remove()方法，
  再调用remove()会报错：IllegalStateException

//迭代器iterator中的remove()方法
    public void test2(){
        Collection coll = new ArrayList();//接口的具体实现类
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));//string类型
        coll.add(false);//布尔类型
        coll.add(new Person("liuxiang",23));
​
        Iterator iterator = coll.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();//接收每一个元素值
            if ("Tom".equals((obj))){
                iterator.remove();
            }
        }
        //此时指针已经到了最后一个元素，需要重新一个迭代器
        //此时输出结果里面已经没有Tom了
        Iterator iterator1 = coll.iterator();//回到起点
        while(iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
    }

增强型for循环遍历

package collection;
​
import java.util.ArrayList;
import java.util.Collection;
​
/*
增强的for循环: 集合/数组对象.for+enter生成
for ( 集合中元素的类型 局部变量：集合对象)
 */
public class ForTest {
​
    public void test(){
        //遍历集合
        Collection coll = new ArrayList();//接口的具体实现类
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));//string类型
        coll.add(false);//布尔类型
        coll.add(new Person("liuxiang",23));//自定义Person类
​
        //for ( 集合中元素的类型 局部变量：集合对象)
        //内部仍然调用了迭代器
        for (Object o : coll) {
            System.out.println(o);
        }
​
        System.out.println("============================");
        //遍历数组
        int[] arr = new int[]{1,2,3,4,6,7};
        for (int i : arr) {
            System.out.println(i);
        }
​
        System.out.println("==============================");
        //练习题
        String[] arr1 = new String[]{"AA","AA","AA"};
​
        //普通for循环
        //for (int i = 0; i < arr1.length; i++) {
        //    arr1[i] = "GG";//输出GG，拿着本身的数组元素做修改
       // }
​
        //增强for循环
        for (String s : arr1) {//将arr1[i]元素取出来赋值给s
            s = "GG";//将s改变，而没有改变arr1[i]
        }
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
​
    }
​
​
    //测试
    public static void main(String[] args) {
        ForTest forTest = new ForTest();
        forTest.test();
    }
}

​