【一】List集合
List是一种可变有序列表，它的存储结构采用数组存储。在需要遍历时，和数组一样，我们可以利用for循环根据索引配合get(int)方法遍历
①：
public class Main {
public static void main(String[] args) {
List list = Arrays.asList("杭州", "北京", "上海", "南京");
for (int i=0; i
但是这种方法有一定的缺陷，首先，它的代码复杂，其次因为get(int )方法只有ArrayLIst的实现是高效的，换成LinkedList后，索引越大，访问的速度也就会越慢。最好的方法就是用迭代器来访问List。Iterator本身也是一个对象，但他是由List的实例调用iterator()方法的时候创建的。Iterator对象知道如何遍历一个LIst，并且不同的List类型，返回的Iterator对象实现也是不同的。
②：
public class Main {
public static void main(String[] args) {
List list = Arrays.asList("杭州", "北京", "上海", "南京");
for (Iterator it = list.iterator(); it.hasNext(); ) {
String s = it.next();
System.out.println(s);
}
}
}
Java的for each 循环本事就可以帮我们使用Iterator遍历，上面的代码改写之后
③:
public class Main {
public static void main(String[] args) {
List list = Arrays.asList("杭州", "北京", "上海", "南京");
for (String s : list) {
System.out.println(s);
}
}
}
只要实现了Iterator接口的集合类都可以直接用for each 循环来遍历，Java编译器会自动把for each循环变成Iterator的调用，原因在于Iterator接口定义了一个Iterator Iterator()方法，强迫集合类必须返回一个Iterator实例。
【二】Set集合
Set集合的存储结构是依靠Map集合来定义的，Set集合中只有键，没有值。根据Map的存储结构，也保证了它的键的唯一性，从而使Set集合产生最重要的一个特点，就是它的不重复性。
Set集合也可以使用for循环来遍历，或者使用迭代器来遍历
①：
public class Test {
public static void main(String[] args) {
Set set = new HashSet<>();
set.add("apple");
set.add("banana");
set.add("pear");
set.add("orange");
for (String string : set) {
System.out.println(string);
}
}
}
②迭代器
public class Test {
public static void main(String[] args) {
Set set = new HashSet<>();
set.add("apple");
set.add("banana");
set.add("pear");
set.add("orange");
Iterator it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
【三】Map集合
Map集合是一种是通过键值（key-value）映射表的数据结构来存储数据，作用就是能高效的通过可以来快速查找value（元素）
对于Map集合的遍历，可以使用for each循环遍历Map实例的keySet()方法返回的Set集合，它包含不重复的key的集合。
public class Test {
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("apple", 123);
map.put("pear", 456);
map.put("banana", 789);
map.put("watermelon", 789);
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 Test {
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("apple", 123);
map.put("pear", 456);
map.put("banana", 789);
map.put("watermelon", 789);
for (Map.Entry entry : map.entrySet()) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + " = " + value);
}
}
}
【四】Queue集合
Queue接口继承自Collection，它的常用实现类有(无界队列)LinkedList，(双端队列)PriorityQueue，(有界队列)ArrayBlockingQueue等等。Queue队列遵循先进先出(First in FIrst out)原则。它只允许在集合的前端进行出队操作，在集合的后端进行出队操作。
Queue队列的遍历方式有：
①：for each遍历
public class Demo05 {
public static void main(String[] args) {
//add()和remove()方法在失败的时候会抛出异常(不推荐)
Queue queue = new LinkedList();
//添加元素, offer() 返回的 false。
queue.offer("a");
queue.offer("b");
queue.offer("c");
queue.offer("d");
queue.offer("e");
for (String q : queue) {
System.out.println(q);
}
}
}
②：迭代器方式
public class Demo05 {
public static void main(String[] args) {
//add()和remove()方法在失败的时候会抛出异常(不推荐)
Queue queue = new LinkedList();
//添加元素, offer() 返回的 false。
queue.offer("a");
queue.offer("b");
queue.offer("c");
queue.offer("d");
queue.offer("e");
Iterator it = queue.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
③：根据队列判空循环遍历
public class Demo05 {
public static void main(String[] args) {
//add()和remove()方法在失败的时候会抛出异常(不推荐)
Queue queue = new LinkedList();
//添加元素, offer() 返回的 false。
queue.offer("a");
queue.offer("b");
queue.offer("c");
queue.offer("d");
queue.offer("e");
while(!queue.isEmpty()) {
System.out.println(queue.poll());
}
}
}
Deque接口继承自Queue接口。Deque队列称为双向队列，它既有FIFO的特点，又有LIFO的特点。它既是队列又是栈。它的常用实现类有LInkedList(基于链表实现的链式双向队列),ArrayDeque(基于数组实现的线性双向队列)。
【五】Deque集合
Deque遍历方式有：
①：for each遍历(默认从头开始遍历)
public class Demo05 {
public static void main(String[] args) {
Deque de = new LinkedList();
de.offerFirst("A1");// 添加到头部
de.offerFirst("A2");// 添加到头部
de.offerLast("A3");// 添加到尾部
de.offer("A4");// 默认添加到尾部
for (String string : de) {
System.out.println(string);
}
}
}
②：通过Deque队列的判空方法遍历
public class Demo05 {
public static void main(String[] args) {
Deque de = new LinkedList();
de.offerFirst("A1");// 添加到头部
de.offerFirst("A2");// 添加到头部
de.offerLast("A3");// 添加到尾部
de.offer("A4");// 默认添加到尾部
while(!de.isEmpty()) {
System.out.println(de.poll());// 默认从首部逐个出队遍历
// System.out.println(de.pollLast());// 从尾部逐个出队遍历
// System.out.println(de.pollFirst());// 从首部逐个出队遍历
}
}
}
③：迭代器遍历
public class Demo05 {
public static void main(String[] args) {
Deque de = new LinkedList();
de.offerFirst("A1");// 添加到头部
de.offerFirst("A2");// 添加到头部
de.offerLast("A3");// 添加到尾部
de.offer("A4");// 默认添加到尾部
Iterator it = de.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
【六】Stack集合
Stack集合作为一个类，继承自Vector类，它的特点是后进先出(LIFO)。栈只有入栈操作和出栈操作。
栈的遍历方式有：
①：for each 循环遍历
public class Demo05 {
public static void main(String[] args) {
Stack stack = new Stack();
stack.push("A1");
stack.push("A2");
stack.push("A3");
stack.push("A4");
stack.push("A5");
for (String string : stack) {
System.out.println(string);
}
}
}
②：栈的判空方法遍历
public class Demo05 {
public static void main(String[] args) {
Stack stack = new Stack();
stack.push("A1");
stack.push("A2");
stack.push("A3");
stack.push("A4");
stack.push("A5");
while(!stack.isEmpty()) {
System.out.println(stack.pop());// (先进后出)出栈
}
}
}
③：迭代器遍历
public class Demo05 {
public static void main(String[] args) {
Stack stack = new Stack();
stack.push("A1");
stack.push("A2");
stack.push("A3");
stack.push("A4");
stack.push("A5");
Iterator it = stack.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
