Stream流的中间方法

一.Stream流的中间方法 

注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据 

二.filter

filter的主要用法是过滤，挑选出满足条件的元素

package com.njau.d10_my_stream;

import java.util.ArrayList;
import java.util.Collections;

public class StreamDemo6 {
    public static void main(String[] args) {
        /*
            filter              过滤
            limit               获取前几个元素
            skip                跳过前几个元素

            注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
            注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
         */
        //filter    过滤      把张开头的留下，其余的过滤不要
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        /*
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                // 返回值为true。则表示当前数据留下
                // 返回值为false。则表示当前数据舍弃不要
                return s.startsWith("张");
            }
        }).forEach(s -> System.out.println(s));
        */

        list.stream().filter(s -> s.startsWith("张"))
            .filter(s -> s.length() == 3)
                .forEach(s -> System.out.println(s));

        // 只能用一次,已经在上面用过了
//        stream1.forEach(s -> System.out.println(s));

        System.out.println(list);
    }
}

三.limit和skip

limit：获取前几个元素

skip：跳过前几个元素

package com.njau.d10_my_stream;

import java.util.ArrayList;
import java.util.Collections;

public class StreamDemo6 {
    public static void main(String[] args) {
        /*
            filter              过滤
            limit               获取前几个元素
            skip                跳过前几个元素

            注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
            注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
         */
        //filter    过滤      把张开头的留下，其余的过滤不要
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        // limit               获取前几个元素
        // skip                跳过前几个元素
        list.stream().limit(3)
                .forEach(s -> System.out.println(s));

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

        list.stream().skip(3)
                .forEach(s -> System.out.println(s));

        System.out.println("=================================================");
        // 课堂练习：
        // 获取："张强,"张三丰","张翠山"
        // 方法1
        list.stream().skip(3)
                .limit(3)
                .forEach(s -> System.out.println(s));
        System.out.println("=================================================");
        // 方法2
        list.stream().
                limit(6).
                skip(3).
                forEach(s -> System.out.println(s));
    }
}

四.distinct

对于集合中的元素进行去重，如果集合使用的是HashSet集合，要进行hashCode和equals方法的重写

package com.njau.d10_my_stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;

public class StreamDemo7 {
    public static void main(String[] args) {
        /*
            distinct    元素去重，依赖（hashCode和equals方法）
            concat      合并a和b两个流为一个流，如果两个流中的数据类型不一致，那么会使用两个数据类型共同的父类数据类型

            注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
            注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
        */
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤","张三丰","张三丰");

        // distinct     元素去重，依赖（hashCode和equals方法）
        list.stream().
                distinct().
                forEach(s -> System.out.println(s));
        System.out.println("==================================");
    }
}

五.concat

将两个流合并成为一个流，如果两个流的数据类型不同，那么就使用这两个流的数据类型的公共父类数据类型

package com.njau.d10_my_stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;

public class StreamDemo7 {
    public static void main(String[] args) {
        /*
            distinct    元素去重，依赖（hashCode和equals方法）
            concat      合并a和b两个流为一个流，如果两个流中的数据类型不一致，那么会使用两个数据类型共同的父类数据类型

            注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
            注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
        */
        // concat      合并a和b两个流为一个流，如果两个流中的数据类型不一致，那么会使用两个数据类型共同的父类数据类型
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"张无忌","周芷若","赵敏","张强","张三丰","张翠山");

        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"张良","王二麻子","谢广坤");

        Stream<String> stream1 = list1.stream();
        Stream<String> stream2 = list2.stream();
        Stream<String> stream3 = Stream.concat(stream1, stream2);
        stream3.forEach(s -> System.out.println(s));
    }
}

六.map

map用于转换流中的数据类型为别的数据类型

package com.njau.d10_my_stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;


/**
 *  map     转换流中的数据类型
 *  注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
 *  注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
 */
public class StreamDemo8 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张翠山-40","张良-35","王二麻子-37","谢广坤-50");

        // Function函数参数1：原来的数据类型  参数2：要转换的数据类型
        list.stream().map(new Function<String, Integer>() {
            // s：原来的数据
            @Override
            public Integer apply(String s) {
                String[] arr = s.split("-");
                String s1 = arr[1];
                int i = Integer.parseInt(s1);
                return i;
            }
        }).forEach(s -> System.out.println(s));

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

        list.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s -> System.out.println(s));
    }
}