4.30Java Iterator迭代器遍历容器元素(List/Set/Map)

迭代器的作用

迭代器遍历List

迭代器中遍历List

可以使用for循环进行遍历

• 先获得一个迭代器对象---在for里面

• 获得以后直接通过hashNext方法实现遍历

iterator遍历元素的方法

首先来看看iterator的源码：

public interface Iterator<E> {
    //定义了一个hashNext的布尔量
    boolean hashNext;
    
    //定义一个next属性
    next;
    
    //定义一个remove方法
    default void remove(){
        throw new UnsupportedOperationException("remove");
    }
}

• 通过hashNext属性可以判断有没有下一个元素

hashNext和Next组合起来使用，形成判断的闭环

List继承了Collection类，该类也实现了Iterator接口。

iterator方法帮助我们获得一个迭代器对象

Iterator帮助我们定义了迭代器里面应该有的方法

iterator遍历List：

package collection.iterator;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
/**
 * 测试迭代器遍历List、Set、Map
 * @author Lucifer
 */
public class TestIterator {
​
    /*实现遍历List的方法---先定义方法内容*/
    public static void testIteratorList(){
​
        //方法名遵从驼峰规则
        /*要遍历List就要先有List*/
        List<String> list = new ArrayList<>();
        /*
        1.ArrayList是一个类，继承了AbstractList类
        2.AbstractList类继承了AbstractCollection
        3.AbstractList类同是实现了List接口
         */
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
​
        /*创建迭代器变量---循环获得对象(所以for的第一步是创建对象，循环进行判断(判断是否有下一个元素---利用iterator里面自带的属性)*/
        for (Iterator<String> iter = list.iterator(); list.iterator().hasNext();){
            //调用hashNext方法不能用iter而是用list.iterator方法
            /*用iter.next返回当前对象通过又让游标往下移动一格*/
            String temp = iter.next(); //把当前内容返回然后回到头进行判断看有没有下一个元素
            System.out.println(temp);
        }
    }
}

实现：

package collection.iterator;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
/**
 * 测试迭代器遍历List、Set、Map
 * @author Lucifer
 */
public class TestIterator {
​
    /*实现遍历List的方法---先定义方法内容*/
    public static void testIteratorList(){
​
        //方法名遵从驼峰规则
        /*要遍历List就要先有List*/
        List<String> list = new ArrayList<>();
        /*
        1.ArrayList是一个类，继承了AbstractList类
        2.AbstractList类继承了AbstractCollection
        3.AbstractList类同是实现了List接口
         */
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
​
        /*创建迭代器变量---循环获得对象(所以for的第一步是创建对象，循环进行判断(判断是否有下一个元素---利用iterator里面自带的属性)*/
        for (Iterator<String> iter = list.iterator(); list.iterator().hasNext();){
            //调用hashNext方法不能用iter而是用list.iterator方法
            /*用iter.next返回当前对象通过又让游标往下移动一格*/
            String temp = iter.next(); //把当前内容返回然后回到头进行判断看有没有下一个元素
            System.out.println(temp);
        }
    }
}

迭代器中遍历Set

实现：

package collection.iterator;
​
import java.util.*;
​
/**
 * 测试迭代器iterator遍历Set
 * @author Lucifer
 */
public class TestIteratorSet {
​
    /*实现遍历Set的方法---先定义方法内容*/
    public static void testIteratorSet(){
​
        //方法名遵从驼峰规则
        /*要遍历Set就要先有Set*/
        Set<String> set = new HashSet<>();
        /*
        1.ArrayList是一个类，继承了AbstractList类
        2.AbstractList类继承了AbstractCollection
        3.AbstractList类同是实现了List接口
         */
        set.add("aa");
        set.add("bb");
        set.add("cc");
        set.add("dd");
​
        /*创建迭代器变量---循环获得对象(所以for的第一步是创建对象，循环进行判断(判断是否有下一个元素---利用iterator里面自带的属性)*/
        for (Iterator<String> iter = set.iterator(); set.iterator().hasNext();){
            //调用hashNext方法不能用iter而是用list.iterator方法
            /*用iter.next返回当前对象通过又让游标往下移动一格*/
            String temp = iter.next(); //把当前内容返回然后回到头进行判断看有没有下一个元素
            System.out.println(temp);
        }
    }
}

迭代器中遍历Map

package collection.iterator;
​
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
​
/**
 * 测试迭代器Iterator遍历Map
 * @author Lucifer
 */
public class TestIteratorMap {
​
    /*定义iterator遍历方法*/
    public static void testIteratorMap(){
​
        //这是一个类方法,通过类名.方法名调用
        Map<Integer,String> map = new HashMap<>();
        //往Map里面添加元素
        map.put(100,"aa");
        map.put(200,"bb");
        map.put(300,"cc");
​
        /*遍历Map通过节点遍历*/
        //获得一个Set
        Set<Map.Entry<Integer, String>> ss = map.entrySet(); //返回是一个set集合
        /*
        1.通过map.entrySet获得一个Set集合
        2.Set里面放置的是一个集合(Entry)
        3.在Entry集合里面防止的是泛型<Integer,String>
        <Map.Entry<Integer, String>>这个是一个键值对的泛型
         */
        //在键值对当中进行迭代器迭代
        for (Iterator<Map.Entry<Integer,String>> iter = ss.iterator(); iter.hasNext();){
            //在这个里面继续进行遍历---通过.next方法返回一个Entry
            Map.Entry<Integer,String> temp = iter.next();
            //通过temp.getKey获得键，temp.getValue获得值
            System.out.println(temp.getKey() + "---" + temp.getValue());
        }
    }
​
    /*也可以通过keySet获得键，通过键去遍历容器*/
    public static void  testIteratorMapNo2(){
​
        //这是一个类方法,通过类名.方法名调用
        Map<Integer,String> map = new HashMap<>();
        //往Map里面添加元素
        map.put(100,"aa");
        map.put(200,"bb");
        map.put(300,"cc");
​
        //首先先获得键的集合
        Set<Integer> keySet = map.keySet();
        //利用for循环通过键的值去遍历---键的类型是Integer
        for (Iterator<Integer> iter = keySet.iterator(); iter.hasNext();){
            //获得了键以后取出键
            Integer key = iter.next();
            //通过key获取---用get方法
            System.out.println(key + "---" + map.get(key));
        }
    }
}

测试类：

package collection.iterator;
​
/**
 * 测试TestIterator接口当中的方法
 * @author Lucfier
 */
public class Test {
    public static void main(String[] args) {
​
        /*类名调用方法遍历List*/
        TestIterator.testIteratorList();
​
        /*类名调用方法遍历Set*/
        TestIteratorSet.testIteratorSet();
​
        /*类名调用方法遍历Map*/
        TestIteratorMap.testIteratorMap();
        TestIteratorMap.testIteratorMapNo2();
    }
}

特点：

• Java当中为容器提供了统一的接口iterator它可以遍历List、Map、Set

• 方法类似，都是通过循环捕获对象进行遍历，这里要注意他的for的条件

• 循环初始值为通过iterator方法捕获的返回的链表(List和Set)

• 循环结束条件为iterator接口中的hasNext为null时结束

• Map的话初始值变为iterator方法捕获的key、value值---也可以是key值然后循环

•