为什么高级for循环不能遍历Map集合？

因为高级for循环用在集合中，其原理是集合必须实现了Iterator接口，才可以循环，Map集合没有实现Iterator接口，是通过set集合中Iterator接口迭代的，因此，高级for循环不可以直接迭代map集合。

你是说的增强for是吗? 那是可以的呀.
只是类似的要转换一下而已.  


package com.itheima.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

//关于Map类型集合的遍历，keySet()与entrySet()方法：
//增强For循环
public class MapTest {

        public static void main(String[] args) {
                // 创建一个HashMap对象,并加入了一些键值对。
                Map<String, String> maps = new HashMap<String, String>();
                maps.put("111", "java111");
                maps.put("222", "java222");
                maps.put("333", "java333");
                maps.put("444", "java444");
                maps.put("555", "java555");
               
//                 传统的遍历map集合的方法1; keySet()
                traditionalMethod1(maps);
//                 传统的遍历map集合的方法2; entrySet()
                traditionalMethod2(maps);
//                 使用增强For循环来遍历map集合方法1; keySet()
                strongForMethod1(maps);
//                 使用增强For循环来遍历map集合方法2; entrySet()
                strongForMethod2(maps);
        }

        private static void strongForMethod2(Map<String, String> maps) {
                Set<Entry<String, String>> set = maps.entrySet();
                for (Entry<String, String> entry : set) {
                        String key = entry.getKey();
                        String value = entry.getValue();
                        System.out.println(key + " : " + value);
                }
        }

        private static void strongForMethod1(Map<String, String> maps) {
                Set<String> set = maps.keySet();
                for (String s : set) {
                        String key = s;
                        String value = maps.get(s);
                        System.out.println(key + " : " + value);
                }
        }

        // 使用entrySet()方法，获取maps集合中的每一个键值对，
        private static void traditionalMethod2(Map<String, String> maps) {
                Set<Map.Entry<String, String>> sets = maps.entrySet();
                // 取得迭代器遍历出对应的值。
                Iterator<Entry<String, String>> it = sets.iterator();
                while (it.hasNext()) {
                        Map.Entry<String, String> entry = (Entry<String, String>) it.next();
                        String key = entry.getKey();
                        String value = entry.getValue();
                        System.out.println(key + " : " + value);
                }
        }

        // 使用keySet()方法，获取maps集合中的所有键，遍历键取得所对应的值。
        private static void traditionalMethod1(Map<String, String> maps) {
                Set<String> sets = maps.keySet();
                // 取得迭代器遍历出对应的值。
                Iterator<String> it = sets.iterator();
                while (it.hasNext()) {
                        String key = it.next();
                        String value = maps.get(key);
                        System.out.println(key + " : " + value);
                }
        }
}


云青年分之一

其实增强for循环低层也是通过Iterator进行迭代的，所以凡是能用迭代器迭代的都能用增强for循环，另外Map集合的迭代是通过转成Set集合在利用Set集合的iterator()实现的。
Map集合转成Set集合有两种方法：1、通过entrySet(),获取每一个键组成的Set集合，一个Entry里面有键和键对应的值。2、通过KeySet();获取每一个键组成的Set集合。

加油楼主

import java.util.*;

import org.junit.Test;

public class Demo05 {
        // 增强型for循环
        /**
         * 增强型for循环 只适用于数组，或实现了Iterable 接口的集合类
         */
        public static void main(String[] args) {
                // 数组
                int arr[] = { 1, 2, 3, 6, 8, 6, 9 };
                for (int n : arr) {
                        System.out.println(n);
                }
        }

        @Test
        public void test1() {
                // junit数组
                int arr[] = { 1, 2, 3, 6, 8, 6, 9 };
                for (int n : arr) {
                        System.out.println(n);
                }
        }

        @Test
        public void test2() {
                // 集合
                ArrayList<Integer> list = new ArrayList<Integer>();
                list.add(1);
                list.add(12);
                list.add(13);
                list.add(14);
                list.add(18);
                for (Object ob : list) {
                        System.out.println(ob);
                }
        }

        /***************************************************************************
         * 哈希表
         **************************************************************************/
        @Test
        public void test3() {
                // 哈希表
                Map<String, String> map = new LinkedHashMap<String, String>();
                map.put("1", "aaa");
                map.put("2", "bbbb");
                map.put("3", "cccc");
                map.put("4", "ddd");
                map.put("5", "www");
                // 传统方式一：
                Set<String> set = map.keySet();
                Iterator<String> it = set.iterator();
                while (it.hasNext()) {
                        String key = it.next();
                        String value = map.get(key);
                        System.out.println(key + "=" + value);
                }
        }

        @Test
        public void test4() {
                // 哈希表
                Map<String, String> map = new LinkedHashMap<String, String>();
                map.put("1", "aaa");
                map.put("2", "bbbb");
                map.put("3", "cccc");
                map.put("4", "ddd");
                map.put("5", "www");
                // 传统方式2：
                Set set = map.entrySet();
                Iterator it = set.iterator();
                while (it.hasNext()) {
                        Map.Entry entry = (Map.Entry) it.next();
                        String key = (String) entry.getKey();
                        String value = (String) entry.getValue();
                        System.out.println(key + "=" + value);
                }
        }

        @Test
        public void test5() {
                // 哈希表
                Map<String, String> map = new LinkedHashMap<String, String>();
                map.put("1", "aaa");
                map.put("2", "bbbb");
                map.put("3", "cccc");
                map.put("4", "ddd");
                map.put("5", "www");
                // 增强型for去 1：
                for (Object obj : map.keySet()) {
                        String key = (String) obj;
                        String value = map.get(key);
                        System.out.println(key + "=" + value);
                }
        }

        @Test
        public void test6() {
                // 哈希表
                Map<String, String> map = new LinkedHashMap<String, String>();
                map.put("1", "aaa");
                map.put("2", "bbbb");
                map.put("3", "cccc");

                // 增强型for去 2：
                for (Object obj : map.entrySet()) {
                        Map.Entry entry = (Map.Entry) obj;
                        String key = (String) entry.getKey();
                        String value = (String) entry.getValue();
                        System.out.println(key + "=" + value);
                }
        }

        @Test
        public void test7() {
                /**
                 * 增强for循环 只适合取 数据 修改 数组或集合的数据 最好用传统方式
                 */
                int arr[] = { 1, 2, 3, 6, 8, 6, 9 };
                for (int i : arr) {
                        //i = 2;
                        System.out.println(i);
                }
        }
}