探究map，list，for

从map中取数据的几种不同方式

HashMap<String, String> stringStringHashMap = new HashMap<>();
        stringStringHashMap.put("a","1");
        stringStringHashMap.put("b","2");
        stringStringHashMap.put("c","3");
        stringStringHashMap.put("d","4");

        long l1 = System.currentTimeMillis();
        for (String s:stringStringHashMap.values()){
            System.out.println("这里是： "+ s);
        }
//        Iterator var6 = stringStringHashMap.values().iterator();
//编译后的代码实际上是这样，使用迭代器
//      while(var6.hasNext()) {
    //    String s = (String)var6.next();
    //    System.out.println("这里是： " + s);
//}
        long l2 = System.currentTimeMillis();
        System.out.println(l2-l1);
        System.out.println();

        long l3 = System.currentTimeMillis();
        for (Map.Entry<String,String> entry:stringStringHashMap.entrySet()){
            System.out.println("k: "+entry.getKey()+" v: "+entry.getValue());
        }
        Iterator var10 = stringStringHashMap.entrySet().iterator();

//        while(var10.hasNext()) {
//            Entry<String, String> entry = (Entry)var10.next();
//            System.out.println("k: " + (String)entry.getKey() + " v: " + (String)entry.getValue());
//        }
        long l4 = System.currentTimeMillis();
        System.out.println(l4-l3);
        System.out.println();


        Iterator<Entry<String, String>> iterator = stringStringHashMap.entrySet().iterator();
        while (iterator.hasNext()){
            Entry<String, String> next = iterator.next();
            System.out.println(next.getValue());
        }
//        while(iterator.hasNext()) {
//            Entry<String, String> next = (Entry)iterator.next();
//            System.out.println((String)next.getValue());这里编译是做的类型转换的
//        }
        System.out.println();

        stringStringHashMap.forEach((key,value)->{
            var a=value;
            System.out.println(a);
        });
//        stringStringHashMap.forEach((key, value) -> {
//            System.out.println(value);  没有什么用的var一行可以直接省略
//        });

        // 1.Map entries
        Consumer<Entry<String, String>> action = System.out::println;
        stringStringHashMap.entrySet().forEach(action);
//        PrintStream var10000 = System.out;
//        System.out.getClass();
//        Consumer<Entry<String, String>> action = var10000::println;
//        前三行反而会将那一行拆开
//        stringStringHashMap.entrySet().forEach(action);

        // 2.Map keys
        Consumer<String> actionKeys = System.out::println;
        stringStringHashMap.keySet().forEach(actionKeys);

        // 3. Map values
        Consumer<String> actionValues = System.out::println;
        stringStringHashMap.values().forEach(actionValues);

        System.out.println("----");

map的for循环都是用到了迭代器

遍历数组和集合的区别

String[] array = {"1", "2", "3"};
        for (String i : array) {
            System.out.println(i);
        }
//        for(int var4 = 0; var4 < var3; ++var4) {
//            String i = var2[var4];
//            System.out.println(i);
//        }
        

        ArrayList<String> list = new ArrayList<>();
        list.add("111");
        list.add("222");
        list.add("333");
        for (String i : list) {
            System.out.println(i);
        }
//        Iterator var17 = list.iterator();
//
//        while(var17.hasNext()) {
//            String i = (String)var17.next();
//            System.out.println(i);
//        }

 可见，遍历数组使用的是原始for循环，集合的话使用的是Iterator迭代器。

foreach里面是否可以删除添加list中的元素---》

foreach不可以删除/修改/增加 集合元素，而for可以

ArrayList<String> lista = new ArrayList<>();
        lista.add("111");
        lista.add("222");
        lista.add("333");

//        log.info(list.toString());
        System.out.println(lista.toString());
        System.out.println(lista.getClass());
        for (int i = 0; i < lista.size(); i++) {
            lista.remove("222");
            System.out.println(i);
        }
        System.out.println(lista.toString());
        System.out.println(lista.getClass());
        System.out.println("----");

        ArrayList<String> listb = new ArrayList<>();
        listb.add("111");
        listb.add("222");
        listb.add("333");
        System.out.println(listb.toString());

        for (String i : listb) {
//            listb.remove("222");


//            不要在foreach循环里进行元素的remove/add操作，remove元素请使用Iterator方式。
//
//            Negative example:
//            List<String> originList = new ArrayList<String>();
//            originList.add("22");
//            for (String item : originList) {
//                //warn
//                list.add("bb");
//            }
//
//
//
//            Positive example:
//            Iterator<Integer> it=b.iterator();
//            while(it.hasNext()){
//                Integer temp =  it.next();
//                if (delCondition) {
//                    it.remove();
//                }
//            }
            System.out.println(i);
        }
        System.out.println(listb.toString());
//        java.util.ConcurrentModificationException 报错，

        System.out.println("========");

        ArrayList<String> listc = new ArrayList<>();
        listc.add("111");
        listc.add("222");
        listc.add("333");
        System.out.println(listc);
        Iterator<String> it = listc.iterator();
        while (it.hasNext()) {
            String next = it.next();

//            it.remove();//这里使用的是迭代器里面的remove（）方法，
            if (next.equals("222")) {
                it.remove();//这里使用的是迭代器里面的remove（）方法，
//                // 当然如果使用list的remove方法在此删除质地感元素的话是成功的，比如：list.remove("222")
//            }
            }
            System.out.println(listc);


        }
    }

https://blog.csdn.net/weixin_44056462/article/details/90769772

这里面需要理解一点底层的源码思想

https://blog.csdn.net/qq_40521656/article/details/90749927

ArrayList<String> list = new ArrayList<>();
        list.add("111");
        list.add("222");
        list.add("333");
//        log.info(list.toString());
        System.out.println(list);
        for (String i : list) {
            i="444";
        }
        System.out.println(list);
输出无变换

foreach不能修改集合的元素 

 Student student=new Student(1,"huge");
        Student student1=new Student(1,"xiaoyao");
        List<Student> studentList=new ArrayList<Student>();
        studentList.add(student);
        studentList.add(student1);
        System.out.println(student.getName());
        System.out.println(student1.getName());
        for(Student stu:studentList)
        {
            stu.setName("jingtian");
        }
        System.out.println(student.getName());
        System.out.println(student1.getName());

但是可以修改对象的属性

1、for与foreach都可以遍历数组/集合，不过for则在较复杂的循环中效率更高。
2、foreach不可以删除/修改集合元素，而for可以
3、foreach和for都可以修改duixiang里面的属性
所以相比较下来for循环更为灵活。

从这里我们可以学习迭代器模式https://www.runoob.com/design-pattern/iterator-pattern.html, 这也是好处啊：迭代器模式将存储数据和遍历数据的职责分离

还可以学习到数组虽然可以用foreach，但实际上编译的时候又成了普通的forhttps://www.cnblogs.com/slwenyi/p/6393366.html

观察使用迭代器成功删除集合元素的时候

第一次         第二次

   注意这里，删除元素后，游标减1，lastr直接成-1，期望次数加1  第三次

注意：如果代码中的remove用的不是迭代器的删除功能，会导致一个提前退出的问题，listc.remove("222");，而将原来的集合增加一个元素，在用这个就会报错ConcurrentModificationException，因为---》下图中modCount（记录了对集合修改的次数）的值不等于expectedModCount（通过迭代器对集合修改的次数

https://www.cnblogs.com/YYCat/p/4675084.html

可以看源码

iterator的next和remove，以及check

 @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
 final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);  注意这个实际是数组自己的remove
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

数组的remove方法

public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

可以理解为，这也就体现了迭代器的作用

反正别人这样说https://blog.csdn.net/layman1024/article/details/76103793，，我还没看到真的源码，线程，还没验证过，所以这里也不确定。

回归正题，取map中的值有哪些方式，他们的区别是啥，for和foreach，1.8的呢，能充分利用多核，实现真正的并行，如果数据量不大，只能起到简化代码的作用，而数据量大的时候，其威力就展现了。

for和foreach的效率……：(1)for是使用下标（偏移量）定位的.
(2)foreach应该是使用类似循环子的机构
(3)对随机访问效率高的ArrayList. 使用下标访问效率本身很高.foreach内部的循环子直接封装下标,自己实现的for比foreach更直接，效率稍高些，但差别不会太大,仍然在一个数量级上。 (4)如果使用插入和删除效率高的LinkedList，for基于下标访问会每次从头查询,效率会很低.foreach循环子使用高效的地址运算,效率会高.其差距将很大，完全不在一个数量级别.如果数组很大，差别可能会几百甚至上千倍.

为什么呢，下标定位，for配数组，链表结构foreach配链表，就这样撒。