List、Set、Map、Queue、Deque、Stack遍历方式总结

一、List

List集合继承Collection接口，是一种有序集合，可以通过索引来访问元素，我们在list集合中经常使用ArrayList和LinkedList。

ArrayList底层通过数组实现，随着元素的增加而动态扩容。

ArrayList的特点：

容量不固定，随着容量的增加而动态扩容
有序集合（插入的顺序==输出的顺序）
插入的元素可以为null
增删改查效率更高（相对于LinkedList来说）

LinkedList底层通过链表来实现，随着元素的增加不断向链表的后端增加节点。
LinkedList是一个双向链表，相比于ArrayList来说，LinkedList的随机访问效率更低。

List有三种遍历方式

1.for循环

for(int i = 0; i  < list.size(); i++) {
			System.out.println(list.get(i));
		}

2.for each 循环

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

3.使用迭代器

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

二、Set

Set集合不允许包含相同的元素，如果试图把两个相同的元素加入同一个Set集合中，则添加操作失败，add方法返回false，且新元素不会被加入。

1、foreach遍历

String[] array = { "北京", "深圳", "杭州", "上海", "深圳", "苏州", "北京", "杭州" };
HashSet<String> set = new HashSet<String>();

for(String name : array) {
	System.out.println(name);
		}

2、使用迭代器

String[] array = { "北京", "深圳", "杭州", "上海", "深圳", "苏州", "北京", "杭州" };

//过滤重复值
HashSet<String> set = new HashSet<String>();
		for(String city : array) {
			System.out.println(set.add(city));
			
		}


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

三、Map

Map是一种依照键（key）存储元素的容器，键（key）很像下标，在List中下标是整数。在Map中键（key）可以使任意类型的对象。Map中不能有重复的键（Key），每个键（key）都有一个对应的值（value）。
一个键（key）和它对应的值构成map集合中的一个元素。
Map中的元素是两个对象，一个对象作为键，一个对象作为值。键不可以重复，但是值可以重复。

遍历方式：foreach循环遍历KeySet()、foreach循环遍历entrySet()

1.foreach循环遍历KeySet()

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 123);
        map.put("pear", 456);
        map.put("banana", 789);
        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println(key + " = " + value);
        }
    }
}

2.foreach循环遍历entrySet()

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 123);
        map.put("pear", 456);
        map.put("banana", 789);
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + " = " + value);
        }
    }
}

四、Queue

Queue是一种队列，遵循先进先出的原则（FIFO）,只允许在集合头部进行删除操作，在集合尾部进行插入操作，它的实现类有LinkedList（无界队列）和ArrayBlockingQueue（有界队列）

遍历方式：

package com.yx.demo05;

import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Queue;

public class Test07 {
	public static void main(String[] args) {
		
		Queue<String> queue  = new PriorityQueue<String>();
		queue.offer("G");
		queue.offer("D");
		queue.offer("Y");
		queue.offer("A");
		
		//for each遍历：
		for(String s : queue) {
			System.out.println(s); //ADYG
			
		}
		
		//迭代器遍历
		Iterator<String> it = queue.iterator();
		while(it.hasNext()) {
			String str = it.next();
			System.out.print(str);
		}
		
		//使用isEmpty()
		while(!queue.isEmpty()) {
			System.out.println(queue.poll());
		}
	}
}

五、Deque

Deque是双端队列，允许从两头都进，两头都出。

Queue与Deque的区别：

遍历方式：

package com.yx.demo06;

import java.util.Deque;
import java.util.LinkedList;

public class Test02 {
	public static void main(String[] args) {
		
		Deque<String> deque = new LinkedList<String>();
		deque.offerFirst("A");
		deque.offerLast("K");
		deque.offerLast("P");
		deque.offerFirst("R");
		
		//遍历的同时做出队操作
//		String item = null;
//		while((item = deque.pollLast()) != null) {
//			System.out.println(item);
//		}
		
		
		//遍历（仅从队头开始）
		for(String s :deque) {
			System.out.println(s);
		}
	}
}

 六、栈

栈是一种后进先出（LIFO）的数据结构,只能不断地向栈中压入元素，最后进去的元素最先弹出

遍历方式：

package com.yx.demo06;

import java.util.Stack;

public class Test03 {
	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");
		
		System.out.println(stack);

		//遍历并出栈
		while(!stack.isEmpty()) {
			System.out.println(stack.pop());
		}
		
	
//foreach遍历
		for(String s :stack) {
			System.out.println(s);
		}
	}
}