java8 stream基本操作集锦

stream java8

---

//对的
String[] arrl = stack.stream().toArray(String[]::new);
//有问题
arrl = Stream.of(stack).toArray(String[]::new);

String合并、剔除重复、排序

String a = "xyaabbbccccdefww";
String b = "xxxxyyyyabklmopq";

System.out.println(Stream.of(a.concat(b).split(""))
        .sorted()
        .distinct()
        .collect(Collectors.joining())

Stream 装箱流 （Boxed Stream）

将对象流转换为集合：

//It works perfect !!
List<String> strings = Stream.of("how", "to", "do", "in", "java")
                    .collect(Collectors.toList());

然而，上述过程对于基本类型流元素却不生效。

//Compilation Error !!
IntStream.of(1,2,3,4,5)
    .collect(Collectors.toList());

构建流管道

Collection.stream()                                使用一个集合的元素创建一个流。
Stream.of(T...)                                    使用传递给工厂方法的参数创建一个流。
Stream.of(T[])                                    使用一个数组的元素创建一个流。
Stream.empty()                                    创建一个空流。
Stream.iterate(T first, BinaryOperator<T> f)    创建一个包含序列 first, f(first), f(f(first)), ... 的无限流
Stream.iterate(T first, Predicate<T> test, BinaryOperator<T> f)    （仅限 Java 9）类似于 Stream.iterate(T first, BinaryOperator<T> f)，但流在测试预期返回 false 的第一个元素上终止。
Stream.generate(Supplier<T> f)                    使用一个生成器函数创建一个无限流。
IntStream.range(lower, upper)                    创建一个由下限到上限（不含）之间的元素组成的 IntStream。
IntStream.rangeClosed(lower, upper)                创建一个由下限到上限（含）之间的元素组成的 IntStream。
BufferedReader.lines()                            创建一个有来自 BufferedReader 的行组成的流。
BitSet.stream()                                    创建一个由 BitSet 中的设置位的索引组成的 IntStream。
Stream.chars()                                    创建一个与 String 中的字符对应的 IntStream。

中间流操作

filter(Predicate<T>)                与预期匹配的流的元素
map(Function<T, U>)                    将提供的函数应用于流的元素的结果
flatMap(Function<T, Stream<U>>        将提供的流处理函数应用于流元素后获得的流元素
distinct()                            已删除了重复的流元素
sorted()                            按自然顺序排序的流元素
Sorted(Comparator<T>)                按提供的比较符排序的流元素
limit(long)                            截断至所提供长度的流元素
skip(long)                            丢弃了前 N 个元素的流元素
takeWhile(Predicate<T>)                （仅限 Java 9）在第一个提供的预期不是 true 的元素处阶段的流元素
dropWhile(Predicate<T>)                （仅限 Java 9）丢弃了所提供的预期为 true 的初始元素分段的流元素

终止流操作

forEach(Consumer<T> action)            将提供的操作应用于流的每个元素。
toArray()                            使用流的元素创建一个数组。
reduce(...)                            将流的元素聚合为一个汇总值。
collect(...)                        将流的元素聚合到一个汇总结果容器中。
min(Comparator<T>)                    通过比较符返回流的最小元素。
max(Comparator<T>)                    通过比较符返回流的最大元素。
count()                                返回流的大小。
{any,all,none}Match(Predicate<T>)    返回流的任何/所有元素是否与提供的预期相匹配。
findFirst()                            返回流的第一个元素（如果有）。
findAny()                            返回流的任何元素（如果有）。

stream构造

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

class Rock{
    Rock(int i){
        System.out.println(i);
    }
}

public class HelloDate {
    public static void main(String[] args) {
        //stream 操作：构建
        //1. 单独的值
        Stream stream = Stream.of("a","b","c");
        //2. 数组
        String[] strings = new String[]{"a","b","c"};
        stream = Stream.of(strings);
        stream = Arrays.stream(strings);
        //3. collections
        List<String> list = Arrays.asList(strings);
        stream = list.stream();
    }
}

数值流的构造

IntStream.of(new int[]{1,2,3}).forEach(i-> System.out.println(i));
System.out.println(">>next");
IntStream.range(1,3).forEach(i-> System.out.println(i));
System.out.println(">>next");
IntStream.rangeClosed(1,3).forEach(i-> System.out.println(i));

映射

List<Integer> nums = Arrays.asList(1,2,3,4);
List<Integer> squareNums = nums.stream().map(n->n*n).collect(Collectors.toList());
System.out.println(squareNums);

输出为[1, 4, 9, 16]
map 生成的是个 1:1映射，每个输入元素，都按照规则转换成为另外一个元素。还有一些场景，是一对多映射关系的，这时需要 flatMap。

过滤

Integer[] sixNums = {1,2,3,4,5,6};
Integer[] evens = Stream.of(sixNums).filter(n->n%2==0).toArray(Integer[]::new);
System.out.println(Arrays.asList(evens));

输出为[2,4,6]

例子 打印姓名（forEach 和 pre-java8 的对比）

// Java 8
roster.stream().filter(p -> p.getGender() == Person.Sex.MALE).forEach(p -> System.out.println(p.getName()));
// Pre-Java 8
for (Person p : roster) {
 if (p.getGender() == Person.Sex.MALE) {
 System.out.println(p.getName());
 }
}

peek 例子 对每个元素执行操作并返回一个新的 Stream

System.out.println(Stream.of("one","two","three","four","five")
.filter(p->p.length()>3)
.peek(e-> System.out.println("Filtered value "+e))
.map(String::toUpperCase)
.peek(e-> System.out.println("Mapped value "+e))
.collect(Collectors.toList()));

parallelStream

parallelStream其实就是一个并行执行的流.它通过默认的ForkJoinPool,可能提高你的多线程任务的速度.
Stream具有平行处理能力，处理的过程会分而治之，也就是将一个大任务切分成多个小任务，这表示每个任务都是一个操作，因此像以下的程式片段：
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
numbers.parallelStream()
.forEach(out::println);
你得到的展示顺序不一定会是1、2、3、4、5、6、7、8、9，而可能是任意的顺序，就forEach()这个操作來讲，如果平行处理时，希望最后顺序是按照原来Stream的数据顺序，那可以调用forEachOrdered()。例如：
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
numbers.parallelStream()
.forEachOrdered(out::println);
注意:如果forEachOrdered()中间有其他如filter()的中介操作，会试着平行化处理，然后最终forEachOrdered()会以原数据顺序处理，因此，使用forEachOrdered()这类的有序处理,可能会（或完全失去）失去平行化的一些优势，实际上中介操作亦有可能如此，例如sorted()方法。

reduce

这个方法的主要作用是把 Stream 元素组合起来。 它提供一个 起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。 从这个意义上说，字符串拼接、数值的sum、min、max、average 都是特殊的 reduce。例如 Stream 的 sum 就相当于

Integer sum = integers.reduce(0, (a, b) -> a+b);

或

Integer sum = integers.reduce(0, Integer::sum);

最小值、拼接、求和

Integer sum = Stream.of(sixNums).reduce(0,(a,b)->a+b);
String concat = Stream.of("A","B","c","D").reduce("",String::concat);
double minValue = Stream.of(1.0,2.1,-0.3).reduce(Double.MAX_VALUE,Double::min);
concat = Stream.of("A","B","c","D").filter(x->x.toLowerCase().compareTo("c")>0).reduce("",String::concat);

limit/skip

limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素（它是由一个叫 subStream 的方法改名而来）。

部分测试代码

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class HelloDate {

    public static void main(String[] args) {
        //stream 操作：构建
        //1. 单独的值

        Stream<String> stream = Stream.of("a","b", "c");
        //转为数组
        String[] strArray1 = stream.toArray(String[]::new);


        stream = Stream.of("a","b", "c");
        List<String> list1 = stream.collect(Collectors.toList());
        System.out.println(list1);


        List<Integer> nums = Arrays.asList(1,2,3,4);
        List<Integer> squareNums = nums.stream().map(n->n*n).collect(Collectors.toList());
        System.out.println(squareNums);

        Integer[] sixNums = {1,2,3,4,5,6};
        Integer[] evens = Stream.of(sixNums).filter(n->n%2==0).toArray(Integer[]::new);
        System.out.println(Arrays.asList(evens));

        System.out.println(Stream.of("one","two","three","four","five").filter(p->p.length()>3).peek(
                e-> System.out.println("Filtered value "+e)
        ).map(String::toUpperCase).peek(e-> System.out.println("Mapped value "+e)).collect(Collectors.toList()));

        Integer sum = Stream.of(sixNums).reduce(0,(a,b)->a+b);
        System.out.println(sum);

        String concat = Stream.of("A","B","c","D").reduce("",String::concat);
        double minValue = Stream.of(1.0,2.1,-0.3).reduce(Double.MAX_VALUE,Double::min);
        concat = Stream.of("A","B","c","D").filter(x->x.toLowerCase().compareTo("c")>0).reduce("",String::concat);
        System.out.println(concat);
    }
}

如化平方数

import java.util.stream.Collectors;

public class SquareDigit {

    public int squareDigits(int n) {
        return Integer.parseInt(String.valueOf(n)
                                      .chars()
                                      .map(i -> Integer.parseInt(String.valueOf((char) i)))
                                      .map(i -> i * i)
                                      .mapToObj(String::valueOf)
                                      .collect(Collectors.joining("")));
    }

}

部分测试代码

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class HelloDate {
    public static int[] HelloDate(int[] arr) {
        int[] newArr = IntStream.of(arr).map(x->x*2).toArray();
        return newArr;
    }

    public static void main(String[] args) {
        int a = 1246;
        String b = "woc";
        String c = "123";
        System.out.println(String.valueOf(a).chars().map(i->Integer.parseInt(String.valueOf((char)i)))
                            .map(i->i*i)
                            .mapToObj(String::valueOf)
                            .collect(Collectors.joining(""))
        );
        String d = "1";
        System.out.println(Integer.parseInt(String.valueOf(d)));

        System.out.println("直接输出char");
        String.valueOf(a)
                .chars()
                .forEach(i-> System.out.println(i));

        System.out.println("转化为int之后再输出");
        int res = Integer.parseInt(String.valueOf(a)
                .chars()
                .map(i->Integer.parseInt(String.valueOf((char)i)))
                .mapToObj(String::valueOf)
                .collect(Collectors.joining(""))
        );

        char i = '1';
        System.out.println(Integer.parseInt(String.valueOf(i)));

        System.out.println(res);
        int n = 120;
        if(n<0) System.out.println("false");
        int n_sqrt = (int)Math.round(Math.sqrt(n));
        System.out.println(n_sqrt*n_sqrt==n);

        String pin = "a123";
        String pin2 = "a1 23 dfas";
        int[] aaa = new int[]{1,5,2,6,7,3,6};

        //Integer[] aaa2 = IntStream.of(aaa).filter(nn->nn%2!=0).toArray();
        //System.out.println(list);
        System.out.println(IntStream.of(aaa)
                .map(li->li*li)
                .sum()
        );
        System.out.println(new StringBuilder(pin).reverse().toString());
        String[] l = String.valueOf(pin2).split(" ");
        System.out.println();
        String afterJoining = Stream.of(l)
                .map(i2->new StringBuilder(i2).reverse().toString())
                .collect(Collectors.joining(" "))
        ;
        System.out.println(afterJoining);

        String[] afterSplit = String.valueOf("123").split(" ");
        Stream.of(afterSplit)
                .map(iiii->new StringBuilder(iiii).reverse().toString())
                .collect(Collectors.joining(" "));

        String[] L = new String[]{"ABART 20", "CDXEF 50", "BKWRK 25", "BTSQZ 89", "DRTYM 60"};
        String[] M = new String[]{"A", "B", "C", "W"};
        int[] mSum = new int[M.length];
        for(String ii:L){
            StringBuilder stringBuilder = new StringBuilder(ii);
            for (int i)
        }
    }
}