Java中List、Set、Map、Queue和Stack栈集合的遍历

一、List的遍历

        在集合类中，List是最基础的一种集合：它是一种有序列表。List的行为和数组几乎完全相同：List内部按照放入元素的先后顺序存放，每个元素都可以通过索引确定自己的位置，List的索引和数组一样，从0开始 ，特点是有序允许重复。

public class List_bianli {
	public static void main(String[] args) {
		List<String> arrayList = new ArrayList<String>();
		arrayList.add("stu1");
		arrayList.add("stu2");
		arrayList.add("stu3");
		arrayList.add("stu4");
		arrayList.add("stu5");
		// 方法一:for each循环主要用于遍历数组或集合中的元素
		for (String s : arrayList) {
			System.out.println(s);
		}
		System.out.println("-----------");
		//方法二: Iterator主要用于迭代访问(即遍历)Collection中的元素
		Iterator<String> it = arrayList.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		//方法三:List的get(index)方法，返回集合index处的元素
		System.out.println("-----------");
		for (int i = 0; i < arrayList.size(); i++) {
			System.out.println(arrayList.get(i));
		}
}
}

二、Set的遍历

        Set实际上相当于一个只存储key、不存储value的特殊Map。放入Set的元素和Map的key特点类似，不允许重复。常用的Set实现类是HashSet，特点是无序唯一。

public class Set_bianli {
	public static void main(String[] args) {
		Set<String> hashSet = new HashSet<String>();
		hashSet.add("010");
		hashSet.add("025");
		hashSet.add("013");
		hashSet.add("020");
		hashSet.add("029");
		// 方式一:for each循环
		for (String x : hashSet) {
			System.out.println(x);
		}
		System.out.println("-------------");
		// 方式二:迭代器
		Iterator<String> it = hashSet.iterator();
		while(it.hasNext()) {
			String x = it.next();
			System.out.println(x);
		}
	}
}

总结：集合元素的遍历，最好用foreach();

三、Map的遍历

        Map<K, V>是一种键-值映射表，当我们调用put(K key, V value)方法时，就把key和value做了映射并放入Map。当我们调用V get(K key)时，就可以通过key获取到对应的value。如果key不存在，则返回null。和List类似，Map也是一个接口，最常用的实现类是HashMap。

public class Map_bianli {
	public static void main(String[] args) {
		Map<String, Integer> hashMap = new HashMap<String, Integer>();
		hashMap.put("stu1", 85);
		hashMap.put("stu2", 87);
		hashMap.put("stu3", 75);
		hashMap.put("stu4", 99);
		hashMap.put("stu5", 95);

		// 方法一:通过Map的键的迭代遍历Map集合的键
		// 再通过get()方法根据键获取对应的值(效率低)
		Set<String> keySet = hashMap.keySet(); // 先获取hashMap键的集合
		Iterator<String> it = keySet.iterator();
		while (it.hasNext()) {
			Object key = it.next();
			System.out.println(key + " = " + hashMap.get(key));
		}
		System.out.println("-----------");
        //方法二:for each()
        for (String key : hashMap.keySet()) {
             Integer value = hashMap.get(key);
             System.out.println(key + " = " + value);
        }
        //方法三:同时遍历key和value可以使用for each循环遍历Map对象的entrySet()集合，它包含每      
        // 一个key-value映射
        for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
             System.out.println(entry.getKey() + " = " + entry.getValue());
        }
}
}

        总结：方法三是最简洁最通用的遍历方式

四、Queue的遍历

        队列Queue是一种经常使用的集合，线性表结构，遵循先入先出、后入后出的基本原则，一般来说，它只允许在集合的前端进行删除操作，而在集合的后端进行插入操作。

        注：LinkedList既实现了List接口，又实现了Queue接口。所以，在使用的时候，如果我们把它当作List，就定义List的引用；如果我们把它当作Queue。

public class Queue_bianli {
	public static void main(String[] args) {
		Queue<String> queue = new LinkedList<String>();		
		queue.offer("E");
		queue.offer("D");
		queue.offer("C");
		queue.offer("B");
		queue.offer("A");
		System.out.println(queue);		
		//方法一:for each只是遍历没有出队
		for(String s:queue) {
			System.out.println(s);
		}
		System.out.println("-----------");
		//方法二:for循环，遍历的同时进行出队操作
		int size = queue.size();
		for(int i=0;i<size;i++) {
			System.out.println(queue.poll());
		}
		System.out.println("-----------");	
		//方法三:while循环，同时进行出队操作
		String temp;
		while((temp = queue.poll())!=null) {
			System.out.println(temp);
		}		
	}
}

五、Stack的遍历

        栈（Stack）的后进先出（LIFO：Last In First Out），只能不断地往Stack中压入（push）元素，最后进去的必须最早弹出（pop）

        所以，Stack只有入栈和出栈的操作： ○ 把元素压栈：push(E) ○ 把栈顶的元素“弹出”：pop() ○ 取栈顶元素但不弹出：peek()。

public class Stack_bianli {

	public static void main(String[] args) {
		Stack<String> stack = new Stack<String>();
		stack.push("A1");
		stack.push("A2");
		stack.push("A3");
		stack.push("A4");
		stack.push("A5");
		// 方法一:只是遍历
		for (String s : stack) {
			System.out.println(s);
		}
		System.out.println("-------------");

		//方法二:遍历并逐一出栈
		while (!stack.isEmpty()) {
			System.out.println(stack.pop());
		}
	}
}