常用的六种集合的遍历方式

  一.List集合的存储特点是元素有序，可重复。遍历List集合有以下几种方式：

1.普通for循环：

		List<String> list = new ArrayList<String>();
		list.add("北京");
		list.add("上海");
		list.add("广州");
		list.add("西安");
		//通过普通for循环，相当于根据数组的小标遍历集合
		for(int i = 0;i<list.size();i++) {
			System.out.print(list.get(i)+" ");
		}

普通for循环遍历list，可以从前往后遍历，也可以从后往前遍历。因为List内部使用数组存储元素，因此可以通过使用下标进行访问。

2.增强for循环:(底层使用迭代器）

		for (String s : list) {
			System.out.print(s+" ");
		}

3.使用迭代器：

		Iterator<String> it = list.iterator();//获取迭代器对象
		while(it.hasNext()) {//判断集合是否有下一个元素，也就是判断有没有到集合尾部
			System.out.print(it.next()+" ");//获取集合中的元素并输出
		}
	    ListIterator<String> it = list.listIterator(list.size()-1);//获取迭代器对象
		while(it.hasPrevious()) {//使用 ListIterator迭代器
		    System.out.println(it.previous());
		}

List集合可以使用两种迭代器，Iterator和ListIterator，前者只能从前往后遍历，而后者可以传入一个索引，相当于可以从指定位置进行迭代，可以从前往后或者从后往前遍历。

  二.Set集合的存储特点是元素无序，且唯一。遍历Set集合有以下几种方法：

1.增强for循环：

	for (String s : set) {
			System.out.print(s+" ");
		}

2.使用迭代器：

		Iterator<String> it = set.iterator();
		while(it.hasNext()) {
			System.out.print(it.next()+" ");
		}

由于Set集合内部使用Map集合存储元素，因此不能通过普通for循环使用下标来获取元素。

   三.Map集合内部使用数组+链表+红黑树来存储元素。其内部存储的是key-value键值对。键唯一。遍历Map有以下几种方法：

1.获取Map的keySet()：通过遍历key，获取对应的value，从而遍历键值对：

		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("令狐冲", 30);
		map.put("东方不败", 28);
		map.put("上官子怡", 21);
		for (String key : map.keySet()) {//遍历Map集合的keySet集合
			Integer value = map.get(key);//获取 value
			System.out.println(key + "--" + value);
		}

2.获取Map集合的Entryset()，遍历Map的Entry集合，直接获取键值对对象

		for(Entry<String, Integer> entry:map.entrySet()) {
			System.out.println(entry);
		}

3.使用迭代器：

	Iterator<Entry<String, Integer>> it = map.entrySet().iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}

  四.Queue，队列的特点是先进先出。且只能从队尾入队，队头出队。遍历Queue的方法有以下几种：

1.通过循环：

		Queue<String> queue = new LinkedList<String>();
		queue.offer("关羽");
		queue.offer("张飞");
		queue.offer("赵云");
		queue.offer("马超");
		queue.offer("黄忠");
		String str;//定义一个字符串的引用，用来获取队列中的元素
		while ((str = queue.poll()) != null) {//获取队列中的元素
			System.out.println(str);
		}

用此方法遍历队列时，用poo()方法会删除队列中的元素。当遍历结束时，队列为空。

2.使用迭代器：

		Iterator<String> it = queue.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}

3.用增强for循环：

		for (String hero : queue) {
			System.out.println(hero);
		}

五.Deque双端队列，双端队列可以从两端入队，从两端出队。其遍历方式有以下几种：

1.使用增强for循环或者迭代器

		for (String hero : deque) {
			System.out.println(hero);
		}
		Iterator<String> it = deque.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}

2.通过while循环从前往后遍历：

		String str;
		while((str = deque.pollFirst())!=null) {//从队头访问双端队列
			System.out.println(str);
		}

3.通过while循环从后往前遍历：

		while((str = deque.pollLast())!=null) {//从队尾访问双端队列
			System.out.println(str);
		}

 六，Stack栈，栈只能从栈顶入栈，从栈顶出栈，因此栈的特点为后进先出。遍历栈的方法有以下几种：

1.使用增强for循环或者迭代器：

		Stack<String> stack = new Stack<String>();
		stack.add("1");
		stack.add("2");
		stack.add("3");
		stack.add("4");
		stack.add("5");
		for(String ss : stack) {
			System.out.println(ss);
		}
		Iterator<String> it1 = stack.iterator();
		while(it1.hasNext()) {//使用Iterator迭代器
			System.out.println(it1.next());
		}
		ListIterator<String> it2 = stack.listIterator(1);//使用ListIterator迭代器
		while(it2.hasNext()) {
			System.out.println(it2.next());
		}

Stack也可以像List那样使用两种迭代器进行遍历。

2.使用while循环和isEmpty()方法配合遍历：

		while(!stack.isEmpty()) {//当栈不为空时
			System.out.println(stack.pop());//从栈中取出元素
		}

此方法遍历结束后，栈中为空。

总结：

     1.上述的六种集合都可以使用增强for循环遍历。而此方法底层使用迭代器进行遍历。故它们也都可以使用迭代器进行遍历。

     2.Deque双端队列可以从两端入队和出队，因此它可以结合自身的方法从前遍历，也可以从后遍历。

     3.List和Stack可以使用两种迭代器进行遍历。分别是Iterator和ListIterator，Iterator只能从前往后遍历。ListIterator允许从指定位置开始，可以从前遍历，也可以从后遍历。

     4.虽然它们都可以使用迭代器进行遍历，但是由于不同的集合内部存储元素的结构不同。因此迭代器的内部实现遍历的逻辑规则也完全不同。