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

一时失言乱红尘 2022-02-25 07:10 256阅读 0赞

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

2018年10月16日 09:40:18 [神鹰梦泽][Link 1] 阅读数：715

下面是一段代码来解释这个事情，看似有点长，但是前面很多是铺垫，很简单就可以理解，示例来源于《疯狂java讲义》，后面的输出表示得也很清楚

package test;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    
    public class Collection {
    	@SuppressWarnings("unlikely-arg-type")
    	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);
    		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);
    		
    		list.add("jack");//add只表示加入一个字符串
    		list.add("howk");
    		//在java集合中，使用专门的迭代器进行遍历
    		Iterator<String>it=list.iterator();
    		System.out.println("添加了jack和howk后，现在list的元素包含：");
    //		以前老套的迭代器做法
    //		while(it.hasNext()) {
    //			System.out.print(it.next()+" ");
    //		}
    		System.out.println("非常高逼格的使用迭代器Lambda表达式遍历");
    		it.forEachRemaining(String->System.out.print(String+" "));
    		System.out.println();
    		
    		System.out.println("第二次高逼格，显然已经输不出来了");
    		it.forEachRemaining(String->System.out.print(String+" "));
    
    		System.out.println();
    		System.out.println("我foreach的迭代元素为");
    		//对于list中的每一个String，我都要输出,帅！
    		
    		list.forEach(String->System.out.print(String+" "));//Lambda表达式
    		System.out.println();
    //		forEach和forEachRemaining区别不大，可以换着用，但是这个第二次能输出来
    		System.out.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的字符串型元素
    		list.removeIf(ele->((String)ele).length()>2);
    
    		System.out.println("用removeIf取出长度大于2的字符串后list为"+list);
    	}
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64

输出为

巅峰时期的list[1, make, 2]
    失去了第一个数的list[make, 2]
    set包含了[make]
    list是否包含set   true
    removeAll(set)之后的list[2]
    addAll(set)之后的list[2, make]
    添加了jack和howk后，现在list的元素包含：
    非常高逼格的使用迭代器Lambda表达式遍历
    2 make jack howk 
    第二次高逼格，显然已经输不出来了
    
    我foreach的迭代元素为
    2 make jack howk 
    我Foreach还可以来第二次
    2 make jack howk 
    2的长度是1
    make的长度是4
    jack的长度是4
    取出长度大于2的字符串后list为[2]

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20

1.  可以看到，foreach与forEachRemaining是可以依托于迭代器通过Lamdba遍历的，其中forEachRemaining只能用一次
2.  it.forEachRemaining(String->System.out.print(String+" "));表示用迭代器遍历list中的String元素，适合用于容器的遍历
3.  add与addAll,remove与removeAll有类似的区别，add后面接具体的字符串，addAll后面接list,set等
4.  System.out.println("list是否包含set "+list.containsAll(set));判断容器间是否互相包含用contains
5.  list.removeIf(ele->((String)ele).length()>2);这是另一种Lamdba表达式，ele表示元素，效果是去掉list中所有长度大于2的元素

[Link 1]: https://me.csdn.net/qq_37465638