list set map queue deque stack 的遍历总结

一.list的遍历

①普通for循环：（效率低）

Arraylist底层采用object类型数组elementData存储，可以实现按数组索引遍历元素

List<Integer> list =new ArrayList<Integer>(Arrays.asList(121,231,34,11,555));
for(int i=0;i<list.size();i++) {
   System.out.println(list.get(i));
			
 }

//结果：

121
231
34
11
555

 LinkedList底层采用双向链表存储，基于此存储特点，如果采用普通for循环遍历，效率低。对于频繁的遍历操作，建议使用Arraylist；对于频繁的插入删除操作，建议使用 LinkedList

List<String> list=new LinkedList<String>(Arrays.asList("a","c","b","e","f"));
	for(int i=0;i<list.size();i++) {
		System.out.println(list.get(i));
		
	}

//结果：

a
c
b
e
f

②增强for循环（for each）：效率高，底层采用Iterator迭代器实现

List<Integer> list =new ArrayList<Integer>(Arrays.asList(121,231,34,11,555));
for(Integer it:list) {
    System.out.println(it);	
	}

//结果：

121
231
34
11
555

③ Iterator迭代器遍历 （推荐）

List<Integer> list =new ArrayList<Integer>(Arrays.asList(121,231,34,11,555));
Iterator<Integer> iterator = list.iterator();
	while(iterator.hasNext()){
		System.out.println(iterator.next());
		
	}

//结果：

121
231
34
11
555

二.set的遍历

set接口的存储特点：无序、不重复（唯一）

hashset底层采用：(hashmap )   数组+链表+红黑树   存储

linkedHashSet在hashset结构基础上维护了一个链表，保存了前一个和后一个数据  (linkedHashMap)

treeset采用treeMap存储

set接口没有get()方法，不能通过索引获取元素(不能使用普通for循环遍历)

①增强for循环（for each）

Set<String> set=new HashSet<String>(Arrays.asList("我","爱","JAVA"));
		for(String s:set) {
			System.out.println(s);
			
		}

//结果：

JAVA
我
爱

②Iterator迭代器遍历

Set<String> set=new HashSet<String>(Arrays.asList("我","爱","JAVA"));
Iterator<String> iterator = set.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
			
		}
		

//结果：

JAVA
我
爱

三.map的遍历

map的底层存储结构：

        以hashmap为例，采用 数组+链表+红黑树存储；

        key : 无序不重复，采用set集合存储（keySet()）

        value : 有序可重复，采用collection集合存储（values()）

        key-value:无序不重复,封装为entry对象,采用set集合存储（entrySet()）

①  增强for循环（for each）

  方式1：

 Map<String, Integer> map=new HashMap<String, Integer>();
	   map.put("张明", 1001);
	   map.put("王凯", 1002);
	   map.put("孙莉", 1003);
	   map.put("许丽", 1004);
	   map.put("郭鹏", 1005);
	   Set<String> keySet = map.keySet();
	   for(String key:keySet) {
		 Integer value = map.get(key);//通过key获取对应的value值
		 System.out.println("key:"+key+"--->value:"+value);
		   
	   }

//结果：

key:郭鹏--->value:1005
key:许丽--->value:1004
key:张明--->value:1001
key:王凯--->value:1002
key:孙莉--->value:1003

 方式二：

Set<Entry<String, Integer>> entrySet = map.entrySet();//获取存储entry对象的set集合
	   for(Entry<String, Integer> entry: entrySet) {
		   String key = entry.getKey();//通过entry对象调用getKey()方法获取key属性
		   Integer value = entry.getValue();//通过entry对象调用getValue()方法获取value属性
		   System.out.println("key:"+key+"--->value:"+value);
	   }

//结果：


key:郭鹏--->value:1005
key:许丽--->value:1004
key:张明--->value:1001
key:王凯--->value:1002
key:孙莉--->value:1003

 ②Iterator迭代器遍历

   方式1：

       Set<String> keySet = map.keySet();
	   Iterator<String> iterator = keySet.iterator();
	   while(iterator.hasNext()) {
		   String key = iterator.next();
		   Integer value = map.get(key);
		   System.out.println("key:"+key+"--->value:"+value);
		 		   
	   }

  方式2：

       Set<Entry<String,Integer>> entrySet = map.entrySet();
	   Iterator<Entry<String, Integer>> iterator = entrySet.iterator();
	   while(iterator.hasNext()) {
		   Entry<String, Integer> entry = iterator.next();
		   String key = entry.getKey();
		   Integer value = entry.getValue();
		   System.out.println("key:"+key+"--->value:"+value);
	   }

//结果：


key:郭鹏--->value:1005
key:许丽--->value:1004
key:张明--->value:1001
key:王凯--->value:1002
key:孙莉--->value:1003

四.queue队列的遍历：只能从队首取出元素实现遍历

   ① 普通for循环  vs  while循环

       //for循环遍历
        Queue<String> queue=new LinkedList<String>();
		queue.offer("a");
		queue.offer("b");
		queue.offer("c");

		String  str="null";
		for(;(str=queue.poll())!=null;) {
			System.out.println(str);
		}
		

//结果：

a
b
c

        Queue<String> queue=new LinkedList<String>();
		queue.offer("a");
		queue.offer("b");
		queue.offer("c");

       String  str="null";
       while((str=queue.poll())!=null) {
			System.out.println(str);
		}

//结果：

a
b
c

②增强for循环（for each）    从队首遍历数据，不取出

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

//结果：

a
b
c

五.deque的遍历 ：双端队列可以实现从队首和队尾取出元素实现遍历

① 普通for循环  vs  while循环

   以while循环为例：

        Deque<String> deque=new LinkedList<String>();
		deque.offerFirst("a");
		deque.addLast("b");
		deque.offerLast("e");
		//从队首遍历
		while(!deque.isEmpty()) {
			System.out.println(deque.pollFirst());
		}

//结果：

a
b
e

	//从队尾遍历
		String str=null;
		while((str=deque.pollLast())!=null) {
			System.out.println(str);
		}

//结果：

e
b
a

②增强for循环（for each）    从队首遍历数据，不取出

	for(String s:deque) {
			System.out.println(s);
			
		}

//结果：

a
b
e

六.stack的遍历

① 普通for循环  vs  while循环

   以while循环为例：

        Stack<String> stack=new Stack<String>();
		stack.push("w");
		stack.push("y");
		stack.push("z");
		while(!stack.isEmpty()) {
			System.out.println(stack.pop());
			
		}

//结果：

z
y
w

②增强for循环（for each）    从栈首遍历数据，不取出

for(String s:stack) {
     System.out.println(s);			
		}

//结果：

w
y
z

注意：peek()方法可以获取栈顶元素但不出栈，此方法不能用在栈的遍历上，而且当栈为空时获取栈顶元素会报异常   java.util.EmptyStackException

	Stack<String> stack=new Stack<String>();
		stack.push("w");
		stack.push("y");
		stack.push("z");
		while(!stack.isEmpty()) {
			System.out.println(stack.pop());
			
		}
       //错误写法：
        String str=null;
		while((str=stack.peek())!=null) {
			System.out.println(str);
		}
    
//异常！
Exception in thread "main" java.util.EmptyStackException