java集合中对contains,foreach,forEachRemaining,lambda表达式的使用

package com.test.controller;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

public class A {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        list.add("1");
        list.add("make");//add是将传入的参数当String看，哪怕传入一个很长的list，也只算一个
        list.add("2");
        System.out.println("巅峰时期的list"+list);
        list.remove(0);//list中，remove后接的是索引
        System.out.println("失去了第一个数的list"+list);


        System.err.println("============分析HashSet与ArrayList表示:ArrayList可以直接装入HashSet元素 和删除元素 互通的============");
        HashSet<String> set=new HashSet<>();
        set.add("make");
        System.out.println("set包含了"+set);
        System.out.println("list是否包含set   "+list.containsAll(set));//list和set是可以相互包含的
        list.removeAll(set);
        System.out.println("removeAll(set)之后的list"+list);
        list.addAll(set);//addAll是将传入的参数当list看，有多少加多少,类似的removeAll,containsAll都如此
        System.out.println("addAll(set)之后的list"+list);


        System.err.println("============分析Iterator与ArrayList============");
        list.add("jack");//add只表示加入一个字符串
        list.add("howk");
        //在java集合中，使用专门的迭代器进行遍历
        Iterator<String> it=list.iterator();
        System.out.println("添加了jack和howk后，现在list的元素包含："+list);
//		以前老套的迭代器做法
        System.err.println();
        System.err.println("============老套的迭代器遍历,表示用了此遍历,就没法使用list.iterator().forEachRemaining来遍历了,只能遍历一次============");
        while(it.hasNext()) {
            System.out.print(it.next()+" ");
        }
        System.err.println();

        System.err.println("============非常高逼格的使用迭代器Lambda表达式遍历:list.iterator().forEachRemaining==========");
        it.forEachRemaining(String->System.out.print(String+" "));
        System.err.println();
        System.err.println("============第二次高逼格，显然已经输不出来了:表示list.iterator().forEachRemaining只能只能用一次==第二次在遍历就遍历不出来数据了,哈哈=====");
        it.forEachRemaining(String->System.out.print(String+" "));

        System.out.println();
        System.err.println("========我foreach的迭代元素为=====");
        //对于list中的每一个String，我都要输出,帅！

        list.forEach(String->System.out.print(String+" "));//Lambda表达式
        System.out.println();
//		forEach和forEachRemaining区别不大，可以换着用，但是这个第二次能输出来
        System.err.println("我Foreach还可以来第二次");
        list.forEach(String->System.out.print(String+" "));//Lambda表达式
        System.out.println();

        System.out.println(list.get(0)+"的长度是"+list.get(0).length());
        System.out.println(list.get(1)+"的长度是"+list.get(1).length());
        System.out.println(list.get(2)+"的长度是"+list.get(2).length());

        //删除list中的所有长度大于2的字符串型元素
        System.err.println("===========这是另一种Lamdba表达式，ele表示元素，效果是去掉list中所有长度大于2的元素========");
        list.removeIf(ele->((String)ele).length()>2);
        System.out.println("用removeIf取出长度大于2的字符串后list为"+list);
        System.err.println();
        System.err.println("总结:foreach与forEachRemaining是可以依托于迭代器通过Lamdba遍历的，其中forEachRemaining只能用一次");
        System.err.println("总结:foreach与forEachRemaining是可以依托于迭代器通过Lamdba遍历的，其中forEachRemaining只能用一次");
    }
}

巅峰时期的list[1, make, 2]
失去了第一个数的list[make, 2]
============分析HashSet与ArrayList表示:ArrayList可以直接装入HashSet元素 和删除元素 互通的============
set包含了[make]
list是否包含set   true
removeAll(set)之后的list[2]
addAll(set)之后的list[2, make]
============分析Iterator与ArrayList============
添加了jack和howk后，现在list的元素包含：[2, make, jack, howk]

============老套的迭代器遍历,表示用了此遍历,就没法使用list.iterator().forEachRemaining来遍历了,只能遍历一次============
2 make jack howk 
============非常高逼格的使用迭代器Lambda表达式遍历:list.iterator().forEachRemaining==========

============第二次高逼格，显然已经输不出来了:表示list.iterator().forEachRemaining只能只能用一次==第二次在遍历就遍历不出来数据了,哈哈=====

========我foreach的迭代元素为=====
2 make jack howk 
我Foreach还可以来第二次
2 make jack howk 
2的长度是1
make的长度是4
jack的长度是4
===========这是另一种Lamdba表达式，ele表示元素，效果是去掉list中所有长度大于2的元素========
用removeIf取出长度大于2的字符串后list为[2]

总结:foreach与forEachRemaining是可以依托于迭代器通过Lamdba遍历的，其中forEachRemaining只能用一次
总结:foreach与forEachRemaining是可以依托于迭代器通过Lamdba遍历的，其中forEachRemaining只能用一次