六大集合List、Set、Map、Queue、Deque、Stack的遍历方式总结

60 阅读 0 评论 40 点赞

我是靠谱客的博主矮小康乃馨，最近开发中收集的这篇文章主要介绍六大集合List、Set、Map、Queue、Deque、Stack的遍历方式总结，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1、List集合

List集合是我们最基础的一种集合，常用的实现类有ArrayList，内部使用数组作为存储结构，因此和数组十分类似，他是一种有序列表，索引也和数组一样，都是从下标0开始。所以我们在遍历List时，有这2种方法：

① 使用for循环，配合get(index)方法遍历。(不推荐)例：

public class Main{
public static void main(String[] args){
List<String> list = Arrays.as("A","B","C","D","E");
for(int i = 0; i < list.size(); i++){
System.out.println(list.get(i));
}
}
}

② 使用迭代器Itearator访问List。（推荐）例：

public class Main {
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C", "D","E");
for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
System.out.println(it.next());
}
}
}

③ 使用for each遍历List，其本质也是使用了迭代器，原理和②相同，但是代码更简单。（推荐）例：

public class Main {
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C", "D","E");
for (String s : list) {
System.out.println(s);
}
}
}

2.Set集合

Set集合用于存储不重复的元素集合，常用的实现类是HashSet，该集合的特点是无序且唯一，内部使用HashMap作为存储结构，因此没有下标值，所以无法使用for循环遍历，对Set集合，我们一般使用for each或者迭代器（Iteartor）来遍历。

① 使用for each遍历。例：

public class Main {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("C");
set.add("D");
for (String s : set) {
System.out.println(s);
}
}
}

② 使用迭代器Iterator遍历。例：

public class Main {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("C");
set.add("D");
Iterator it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}

这两种遍历方式本质都一样，但是第一种写法更简洁。

3.Map集合

Map是一个接口，最常用的实现类有HashMap，他的内部是这种键值（key-value）映射表的数据结构，能够高效的通过key去查找value，对于Map来说，要遍历key可以使用for each循环来遍历Map实例的KeySet()方法返回的Set集合，他是包含不重复的key集合。

① 遍历Map的key值

public class Main {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("张三", 1);
map.put("李四", 2);
map.put("王五", 3);
for (String key : map.keySet()) {
Integer value = map.get(key);
System.out.println(key + " = " + value);
}
}
}

② 同时遍历key和value同样可以使用for each循环遍历Map对象的entrySet()集合，它里面包含了每一个key-value映射。

public class Main {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("张三", 1);
map.put("李四", 2);
map.put("王五", 3);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + " = " + value);
}
}
}

Map遍历出来的顺序不一定是put()时放入的顺序！

4.Queue队列

Queue队列是一种经常使用的集合，他是线性结构，遵循先进先出（FIFO：First In First Out）的原则。

① 采用for each遍历队列。例：

public static void main(String[] args) {
Queue<String> queue = new LinkedList<String>();
queue.offer("A");
queue.offer("B");
queue.offer("C");
queue.offer("D");
for (String s : queue) {
System.out.println(s);
}
}

② 采用迭代器（Iterator）遍历队列

public static void main(String[] args) {
Queue<String> queue = new LinkedList<String>();
queue.offer("A");
queue.offer("B");
queue.offer("C");
queue.offer("D");
String item = null;
while((item = queue.poll()) != null) {
System.out.println(item);
}
}

5、Deque双端队列

Deque双端队列的特点是两头都进，两头都出。元素可以添加到队尾，也可以添加到队首。这的一般不使用for each遍历，因为使用for each会默认从头遍历，而失去了双端队列的特性了

public static void main(String[] args) {
Deque<String> deque = new LinkedList<String>();
//入队
deque.offerFirst("A");
deque.offerFirst("E");
deque.offerLast("D");
deque.offerFirst("C");
deque.offerLast("B");
System.out.println(deque);
//遍历（从队尾开始）
String item = null;
while((item = deque.pollLast()) != null) {
System.out.println(item);
}
}

6、Stack栈

栈是一种后进先出（LIFO）的数据结构。这个与队列Queue的先进先出（FIFO）截然不同。Stack有以下几个使用场景：JVM方法栈、使用Stack完成进制转换和计算中缀表达式等。我们常常可以用他直接做字符串反转。例：

public static void main(String[] args) {
Stack<String> stack = new Stack<String>();
//入栈
stack.push("A");
stack.push("B");
stack.push("C");
stack.push("D");
stack.push("E");
//遍历出栈
while(!stack.isEmpty()) {
System.out.println(stack.pop());
}
//
for (String string : stack) {
//
System.out.println(string);
//
}
}

总结：只要是继承了Collection<E>接口，都可以用for each循环来遍历，但是for each循环的本质还是迭代器Iteartor()的使用，所以，遍历集合，使用迭代器Iteartor()往往是最高效的遍历方式！