Day4-java—Stream流化

Stream流化

• 将集合流化
  • xxx.stream() // 创建普通流
  • xxx.parallelStream() // 创建并行流
• 数组类支持
  • Arrays.stream()

Demo01

package course.java8.stream;

import com.google.common.collect.Lists;

import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * jdk1.8之前写法与jdk1.8现在写法 对比
 */
public class Demo1 {

    private static final List<String> STR_LIST = Lists.newArrayList("ab", "xyz", "789", "axy", "azzzzz", "a678", "a1234");

    public static void main(String[] args) {
        // 过滤字符串，找到以a开头的，排序，后生成一个字符串，并用，进行分割
        // abc,axy,azz -> "abc,axy,azz"

        foo1();

        foo2();
    }

    /**
     * 使用jdk1.8之前的原生写法
     */
    public static void foo1() {
        List<String> bufList = Lists.newArrayList();
        for (String s : STR_LIST) {
            if (!s.startsWith("a")) {
                continue;
            }

            bufList.add(s);
        }

        bufList.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(), o2.length());
            }
        });

        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < bufList.size(); i++) {
            if (i == bufList.size() - 1) {
                builder.append(bufList.get(i));
                continue;
            }

            builder.append(bufList.get(i)).append(",");
        }

        String result = builder.toString();

        System.out.println("foo1 result = " + result);
    }

    /**
     * 使用jdk1.8 lambda+stream来处理
     */
    public static void foo2() {
        String result = STR_LIST.stream()
                .filter(str -> str.startsWith("a"))
                .sorted(Comparator.comparingInt(String::length))
                .collect(Collectors.joining(","));

        System.out.println("foo2 result = " + result);
    }
}

Demo02

package course.java8.stream;

import com.google.common.collect.Lists;
import com.google.common.collect.Sets;

import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class Demo2 {

    public static void main(String[] args) {
        testStream();

        testInnerOperation();
    }

    /**
     * 第二步: 中间操作
     */
    private static void testInnerOperation() {
        List<String> strs = Lists.newArrayList("ab", "xyz", "789", "axy", "azzzzz", "a678", "a1234");

        strs.stream() // 流化
                .filter(str -> str.startsWith("a")) // 中间操作
                .filter(str -> str.startsWith("a")) // 中间操作
                .filter(str -> str.startsWith("a")) // 中间操作
                .filter(str -> str.startsWith("a")) // 中间操作
                .filter(str -> str.startsWith("a")) // 中间操作
                .filter(str -> str.startsWith("a")) // 中间操作
                .filter(str -> str.startsWith("a")) // 中间操作
                .filter(str -> str.startsWith("a")) // 中间操作
                .filter(str -> str.startsWith("a")) // 中间操作
                .filter(str -> str.startsWith("a")) // 中间操作
                .filter(str -> str.startsWith("a")) // 中间操作
                .map(str -> str.toUpperCase())      // 中间操作
                .map(str -> str.toUpperCase())      // 中间操作
                .map(str -> str.toUpperCase())      // 中间操作
                .map(str -> str.toUpperCase())      // 中间操作
                .map(str -> str.toUpperCase())      // 中间操作
                .map(str -> str.toUpperCase())      // 中间操作
                .map(str -> str.toUpperCase())      // 中间操作
                .map(str -> str.toUpperCase())      // 中间操作
                .map(str -> str.toUpperCase())      // 中间操作
                .map(str -> str.toUpperCase())      // 中间操作
                .forEach(str -> System.out.println(str));  // 结束操作
    }

    /**
     * 第一步: 流化操作
     */
    private static void testStream() {
        List<String> strs = Lists.newArrayList("ab", "xyz", "789", "axy", "azzzzz", "a678", "a1234");
        Set<String> sets = Sets.newHashSet();

        int[] arr = new int[10];

        // 1.流化操作, 普通流
        strs.stream();
        sets.stream();
        Arrays.stream(arr);

        // 2.并行流
        strs.parallelStream();
        sets.parallelStream();
    }

}

Demo03

import com.google.common.collect.Lists;

import java.util.Comparator;
import java.util.List;

public class Demo3 {

    public static void main(String[] args) {
        List<String> strs = Lists.newArrayList("ab", "xyz", "789", "axy", "azzzzz", "a678", "a1234", "b1236", "x123", "y123", "z678");

        // testFilter(strs);

        // testMap(strs);

        // testSort(strs);

        // testLimitAndSkip(strs);

        testFlatMap();
    }

    private static void testFlatMap() {
        List<List<String>> strsList = Lists.newArrayList();

        List<String> strs1 = Lists.newArrayList("ab", "xyz", "789");
        List<String> strs2 = Lists.newArrayList("xy", "ww", "8990");
        List<String> strs3 = Lists.newArrayList("cd", "sss", "13311");
        List<String> strs4 = Lists.newArrayList("uii", "sdfdsfdf", "678");

        strsList.add(strs1);
        strsList.add(strs2);
        strsList.add(strs3);
        strsList.add(strs4);

        // -------
        // 需求: 将大集合中的所有字符串 全部转成大写
        // 用之前所学的转化操作，就这样搞，但是比较恶心.
        // Stream<List<String>> stream = strsList.stream();
        // stream.forEach(strList -> {
        //     strList.stream().map(String::toUpperCase).forEach(str -> {
        //         System.out.println("str = " + str);
        //     });
        // });

        strsList.stream()
                // flatMap 做了啥
                .flatMap(strList -> strList.stream())
                .map(str->str.toUpperCase())
                .forEach(str -> System.out.println("str=" + str));
    }

    /**
     * 中间操作: skip + limit
     *
     * @param strs
     */
    private static void testLimitAndSkip(List<String> strs) {
        strs.stream()
                .peek(str -> System.out.println("strs === " + str))
                .skip(2)
                .limit(3)
                .forEach(str -> System.out.println("str=" + str));

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

        strs.stream()
                .skip(3)
                .limit(5)
                .forEach(str -> System.out.println("str=" + str));
    }

    /**
     * 中间操作 排序
     *
     * @param strs
     */
    private static void testSort(List<String> strs) {
        // 默认的排序方式
        strs.stream().sorted().forEach(str -> System.out.println("str=" + str));
        System.out.println("-----------");
        strs.stream().sorted(Comparator.comparingInt(String::length)).forEach(str -> System.out.println("str=" + str));
    }

    /**
     * 中间操作 映射操作
     *
     * @param strs
     */
    private static void testMap(List<String> strs) {
        strs.stream()
                .map(String::toUpperCase)
                .map(str -> str + ";")
                .map(str -> str + "+")
                .forEach(str -> System.out.println("str=" + str));
    }

    /**
     * 中间操作 过滤器 filter演示
     *
     * @param strs
     */
    private static void testFilter(List<String> strs) {
        strs.stream()
                .filter(str -> str.length() >= 5)  // 第一个过滤器: 字符串长度大于等于5
                .filter(str -> str.startsWith("b")) // 第二个过滤器: 以字符b开头的
                .forEach(str -> System.out.println("str=" + str));
    }
}

Demo04

Demo05

Demo06