java入篇（35）Stream流

一、Stream流

1.1 Stream流概念

用来操作容器中（集合，数组中）元素的流。

1.2 创建Stream流

• 需要一个数据源(集合，数组)来获取流:
• 获取流有三种方法:
• 集合中的Stream方法
• Arrays中的Stream方法
• Stream中的of方法
• 获取一个无限流，

 //创建数据源:
        List<String> list = Arrays.asList("张", "大", "仙");
        //创建Stream流:
        //方式一 集合中的Stream方法
        Stream<String> stream = list.stream();
        //方式二 Arrays中的Stream方法
        Stream<String> stream1 = Arrays.stream(new String[]{"张", "大", "仙"});
        //方式三 Stream中的of方法
        Stream<String> stream2 = Stream.of("张", "大", "仙");

二、操作Stream流

2.1过滤与截断

• Stream filter(Predicate<? super T> predicate)
  返回由与此给定谓词匹配的此流的元素组成的流。

public class Text {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("张", "大", "仙");
        Stream<String> stream = list.stream();
        Stream<String> stream3 = stream.filter((str) -> {
            if (str.equals("张"))
                return true;
            else
                return false;
        });
        stream3.forEach(System.out::println);
    }
}
结果:
张

• Stream distinct()
  返回由该流的不同元素（根据 Object.equals(Object) ）组成的流。
  自定义的类需要重写equals()与hashCode()方法；

public class Text {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("张", "大", "仙","张","^(*￣(oo)￣)^","头");
        Stream<String> stream = list.stream();
        stream.distinct().forEach(System.out::println);
    }
}

结果:
张
大
仙
^(*￣(oo)￣)^
头

• Stream limit(long maxSize)
  返回由此流的元素组成的流，截短长度不能超过 maxSize 。

public class Text {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("张", "大", "仙", "张", "大", "^(*￣(oo)￣)^");
        Stream<String> stream = list.stream();
        stream.limit(3).forEach(System.out::println);
    }
}

• Stream skip(long n)
  跳过前n个元素

public class Text {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("张", "大", "仙", "张", "大", "^(*￣(oo)￣)^");
        Stream<String> stream = list.stream();
        stream.skip(3).forEach(System.out::println);
    }
}

结果:
张
大
^(*￣(oo)￣)^

• void forEach(Consumer<? super T> action)
  类似于遍历元素的功能
• Stream map(Function<? super T,? extends R> mapper)
  对流中原有元素进行操作，将操作后得到的新的元素替换流中原来元素；

public class Text {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("张", "大", "仙","张","^(*￣(oo)￣)^","头");
        Stream<String> stream = list.stream();
        stream.map((str)->str.concat("嘤嘤嘤")).forEach(System.out::println);
    }
}

结果：
张嘤嘤嘤
大嘤嘤嘤
仙嘤嘤嘤
张嘤嘤嘤
^(*￣(oo)￣)^嘤嘤嘤
头嘤嘤嘤

• Stream flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
  对流中原有元素进行操作，将得到的每个新的元素以流的形式返回，最终得到一条流；

public class Text {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("张", "大", "仙","张","^(*￣(oo)￣)^","头");
        Stream<String> stream = list.stream();
        stream.flatMap(new Function<String, Stream<?>>() {
            @Override
            public Stream<?> apply(String s) {
                Stream<String> stream1 = Arrays.asList(s, "猪", "牛", "羊").stream();
                return stream1;
            }
        }).forEach(System.out::print);
    }
}
结果:
张猪牛羊大猪牛羊仙猪牛羊张猪牛羊^(*￣(oo)￣)^猪牛羊头猪牛羊

2.2 排序

• Stream sorted()
  返回由此流的元素组成的流，根据自然顺序排序。

public class Text {
    public static void main(String[] args) {
       Arrays.asList("go","asd","sds","xcv").stream().sorted().forEach(System.out::println);
    }
}

结果:
asd
go
sds
xcv

• Stream sorted(Comparator<? super T> comparator)
  返回由该流的元素组成的流，根据提供的 Comparator进行排序。

public class Text {
    public static void main(String[] args) {
        Stream<Integer> stream = Arrays.asList(1,3,7,4).stream();
        stream.sorted((o1, o2)->o1-o2).forEach(System.out::println);
    }
}

结果:
1
3
4
7

2.3 查找与匹配

• allMatch(Predicate p)
  检查是否匹配所有元素 比如判断 所有员工的年龄都是17岁 如果有一个不是, 就返回false
• anyMatch(Predicate p)
  检查是否至少匹配一个元素 比如判断是否有姓王的员工, 如果至少有一个就返回true
• noneMatch(Predicate p)
  检查是否没有匹配所有元素 比如判断所有员工的工资都是否都是高于3000 如果有一个人低于3000 就返回false
• findFirst()
  返回第一个元素 比如获取工资最高的人 或者 获取工资最高的值是
• findAny()
  返回当前流中的任意元素 比如随便获取一个姓王的员工
• count()
  返回流中元素总数
• max(Comparator c)
  返回流中最大值 比如:获取最大年龄值
• min(Comparator c)
  返回流中最小值 比如:获取最小年龄的值
• forEach(Consumer c)
  内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代

2.4 规约

• reduce(T iden, BinaryOperator b)
  参1 是起始值, 参2 二元运算 可以将流中元素反复结合起来，得到一个值。返回 T 比如:求集合中元素的累加总和

public class Text {
    public static void main(String[] args) {
        Stream<Integer> stream = Arrays.asList(1,3,7,4).stream();
        System.out.println(stream.reduce(3, (x1, x2) -> x1 + x2));
    }
}
结果:
18

注意：是起始值和流中的所有元素做运算。

• reduce(BinaryOperator b)
  这个方法没有起始值 可以将流中元素反复结合起来，得到一个值。返回 Optional

public class Text {
    public static void main(String[] args) {
        Stream<Integer> stream = Arrays.asList(1,3,7,4).stream();
        System.out.println(stream.reduce((x1, x2) -> x1 + x2));
    }
}

结果:
Optional[15]

2.5 收集

• <R,A> R collect(Collector<? super T,A,R> collector)
  使用 Collector对此流的元素执行 mutable reduction Collector 。

public class Text {
    public static void main(String[] args) {
        Stream<Student> stream = Arrays.asList(new Student("猪猪侠", "19"),
                new Student("水桥舞", "10"),
                new Student("慢羊羊", "28")).stream();
        Stream<String> stream1 = stream.map((student) -> student.name);
        Set<String> collect = stream1.collect(Collectors.toSet());
        System.out.println(collect);
    }
}
结果:
[猪猪侠, 水桥舞, 慢羊羊]

• R collect(Supplier supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)
  对此流的元素执行 mutable reduction操作。

三、终止Stream流

Java–Stream流详解

四、实例操作

4.1 Integer list转字符串

//ArrayList<Integer> o1
 String collect = o1.stream().map(s->s+"").collect(Collectors.joining(""));

4.2 int数组转Integer list

List<Integer> collect = Arrays.stream(arr).boxed().collect(Collectors.toList());

4.3 list数组转int

int[] integers = collect.stream().mapToInt(Integer::valueOf).toArray();