Java8的lambda表达式学习记录—lambda表达式Stream流学习七—Stream的中间操作 : 筛选或切片、映射、排序

一，筛选或切片

public class StreamUse {
	/*
	Stream的中间操作 : 筛选或切片
	1) filter,接收 Lambda,从流中排除某些元素
	2) limit,截断流,使其元素不超过给定数量.
	3) skip(n),跳过元素,返回一个扔掉了前n个元素的流,若流中的元素不足n个的话,则返回一个空值,与 limit(n) 互补
	4) distinct,筛选,通过流所生成元素的 hashcode() 以及 equals() 去除重复元素
	 */
	String[] strs = new String[]{"aa", "bb", "cc", "dd", "ee", "aa", "bb"};
    Stream s = Arrays.stream(strs);

	@Test
    public void test1(){
        //中间操作不会执行任何操作,直到有终止操作时才会一次性执行全部内容,称为"惰性求值"
        s.filter((e) -> e.equals("dd")).forEach(System.out::println);//dd
        //内部迭代,迭代操作由 Stream API 完成
    }
	
	@Test
    public void test2(){
    	//只要满足了条件之后,后面的过程不会再走,可提交效率,称为"短路"
        s.limit(3).forEach(System.out::println);//aa, bb, cc
    }

    @Test
    public void test3(){
        s.skip(3).forEach(System.out::println);//dd, ee, aa, bb
    }

    @Test
    public void test4(){
    	//通过流所生成元素的 hashcode() 以及 equals() 去除重复元素,如果是自定义的类则需要重写 hashcode 与 equals 方法
        s.distinct().forEach(System.out::println);//aa, bb, cc, dd, ee
    }
}

二，映射

public class StreamUse {
	/*
    Stream的中间操作 : 映射
    map—接收 Lambda,将元素转换为其他形式或提取信息,接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素,
    flatMap—接收一个函数作为参数,将流中的每个值都换成另外一个流,然后把所有流连接成一个流
     */
	List<Employee> list = Arrays.asList(
		new Employee("张三", 18, 9999.99),
	   	new Employee("李四", 20, 7777.77),
	   	new Employee("王五", 36, 5555.55),
	   	new Employee("赵六", 50, 3333.33),
	   	new Employee("田七", 10, 2222.22)
	);
	
	@Test
    public void test5(){
        List<String> slist = Arrays.asList("aa", "bb", "cc", "dd", "ee");
        slist.stream().map((e) -> e.toUpperCase()).forEach(System.out::println);//AA, BB, CC, DD, EE

        list.stream().map((e) -> e.getName()).forEach(System.out::println);//张三, 李四, 王五...
        list.stream().map(Employee::getName).forEach(System.out::println);
    }

	public static Stream<Character> filterCharacter(String str){//将传过来的String转为数组,每个值都存入list,返回一个list流
        List<Character> list = new ArrayList<>();
        for (Character c : str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }

    @Test
    public void test6(){
        List<String> slist = Arrays.asList("aa", "bb", "cc", "dd", "ee");
        Stream<Stream<Character>> stream = slist.stream().map(StreamUse::filterCharacter);//将list转为流,然后通过.map(Function<T, R>)来将每个元素传给filterCharacter方法,每个元素都返回一个list流
        stream.forEach((e) -> e.forEach(System.out::println));
        //第一层Stream.forEach,Stream中每个元素又是一个新的Stream,然后再.forEach这个流输出即可
        System.out.println("-------------------");
        Stream<Character> stream1 = slist.stream().flatMap(StreamUse::filterCharacter);
        stream1.forEach(System.out::println);
        //flatMap—接收一个函数作为参数,将流中的每个值都换成另外一个流,然后把所有流连接成一个流
        /*
        .map,就是将Stream流中每个元素转换为其他形式,将要做的操作应用到每个元素上
        .flatmap,将Stream流中每个值都替换为另外一个流,然后再把所有的流都连接合并为一个流
        区别就在于,.map类似Collections.add(T), .flatmap类似Collections.addAll(Collection)
         */
    }
}

三，排序

public class StreamUse {
    /*
    Stream的中间操作 : 排序
    sorted()-自然排序(Comparable)
    sorted(Comparator com)-定制排序(Comparator)
     */
    @Test
    public void test7(){
        List<String> slist = Arrays.asList("ee", "dd", "cc", "bb", "aa");
        slist.stream().sorted().forEach(System.out::println);//自然排序

        list.stream().sorted((e1, e2) -> {
           if (e1.getAge() != e2.getAge()){
               return Integer.compare(e1.getAge(), e2.getAge());
           }else {
               return e1.getName().compareTo(e2.getName());
           }
        }).forEach(System.out::println);
    }
}