前言：综合了一下常用Stream流与Optional操作，底部有本人常用的Stream流判空写法，用以记录和复习

Stream流：

获取流

1. list获取：

List<String> list= new ArrayList();
Stream<String> stream=list.stream();

2. set

Set<String> set=new HashSet<>()
Stream<String> stream=set.stream();

3. vector

  Vector<String> vector = new Vector<>();
  Stream<String> stream = vector.stream();

2. Map获取

需要分key、value或entry等情况

   Map<String, String> map = new HashMap<>();
    //key
   Stream<String> keyStream = map.keySet().steam();
   //value
   Stream<String> valueStream = map.values().stream();
   //entry
   Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();

3. 数组获取

数组不能添加默认方法,Stream中提供静态方法of

    String[] array = {"张三","李四","王五","赵六" };
    Stream<String> stream = Stream.of(array);
     
    //或使用Arrays的静态方法
    Arrays.stream(array)
	}

流方法分类：

1. 延迟方法

支持链式调用,

返回值类型仍然是 Stream 接口自身类型的方法

2. 终结方法

不支持类似 StringBuilder 那样的链式调用,

返回值类型不再是 Stream 接口自身类型的方法

终结方法包括 count 和 forEach 方法

1. forEach（终结方法）

list.stream.foreach(h->{System.out.println(s)});

2. count：计数(终结方法)

返回值为long

list.stream().count();

3.filter ：过滤

将一个流转换成另一个子集流

//删选stream中名字首字为方的
list.stream().filter(user->{user.startWith("方")});

4.limit:截取

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作

list.stream().limit(3);

5.skip:跳过

流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流

list.stream.skip(2);

6.map：映射

可转换不同流类型(可自动装箱)

Stream<String> original = Stream.of("1", "2", "3");
Stream<Integer> result = original.map(s->Integer.parseInt(s));

7.concat:组合

将两个流合并为一个流

注：此为静态方法，与java.lang.String中的concat有区别

Stream.concat(streamA, streamB);

8.distinct:去重

distinct不光通过值，还比较地址进行去重

list.stream().distinct();

9.faltMap 扁平化流

CSDN大佬解释通俗易懂：

Java8 FlatMap的使用_杨幂等的博客-CSDN博客_jdk8 flatmap

//（map）流中有流，需要两次遍历
Stream<Stream<Character>> streamStream = list.stream().map(StreamDemo::fromStringToStream);
        streamStream.forEach(s -> {
            s.forEach(System.out::println);
        });
//（flatMap）流里还有流，使用flatMap可以直接把里面的流打开，一次遍历就可以了
 Stream<Character> characterStream = list.stream().flatMap(StreamDemo::fromStringToStream);
        characterStream.forEach(System.out::println);

10. sort 排序

默认为自然排序 ：

list.stream.sorted()

定制排序

需要传入Comparator接口（如果流中的是引用类型，只能用定制排序）

integerList.stream().sorted((e1,e2) -> e2-e1).forEach(System.out::println);

11.match 检测匹配（终结方法）

返回为Boolean值

//1.allMatch 全部匹配--判断列表中是否全大于5
list.stream().allMatch(i -> i > 5)

//2.anyMatch 至少匹配 --判断列表值是否至少有一个大于5
list.stream().anyMatch(i -> i > 5)

//3.noneMatch 没有匹配 --判断列表值是否全部不大于5
list.stream().noneMatch(i -> i > 5)

12.查找

findFirst 查找第一个元素，返回Optional

findAny 查找任意元素 返回Optional

list.stream.findFirst();
list.stream.findAny();

max 查找最大最小值(终结方法) 返回Optional

  //  查找最大的数
list.stream().max((e1, e2) -> e1 - e2);

13. reduce 缩减(终结方法)

实现 求和，求积，求最大值

//求和
list.stream().reduce((x, y) -> x + y)
list.stream().reduce(0,Integer::sum)

//求积
list.stream().reduce((x,y)->x*y)

//求最大值
list.stream().reduce((x, y) -> x > y ? x : y)
list.stream().reduce(1, Integer::max)

14.collect 收集(终结方法)

流转换

//toList 返回偶数集合
list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList()

//toSet返回Set集合
list.stream().collect(Collectors.toSet())

//toMap返回Map ---user中有name,age
List<User> userList= new ArrayList<User>();
list.stream().collection(Collectiors.toMap(User::getName,user->user)

15 迭代 Stream.iterate

使用Stream.iterate创建流，即无限流

//生成一个0-4的自增数，并打印输出
Stream.iterate(0, n -> n + 1)
              .limit(5)
              .forEach(x -> System.out.println(x));

使用流注意点：

程序猿大佬链接：java成神之——Stream和Optional

1. 如果一个流没有调用终端方法，那么流的其他操作都不会执行。

2. 流用来操作文件的时候才需要手动关闭，单独使用Stream不需要关闭

try (Stream<String> lines = Files.lines(Paths.get("C:\Users\stream.txt")).onClose(() -> System.out.println("流自动关闭"))) {
    lines.forEach(System.out::println);
}

3. 平行流：.parallelStream()

list.parallelStream().forEach(System.out::println);

注：如果对元素的顺序不要求的时候可以使用平行流，开启多核心多线程加速处理速度，使用平行流会显著降低性能

4. 流本身是不能重用的，但是可以使用iterator来实现重用

5. 分组计数：

Stream
.of("a", "b", "a", "c")
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
.entrySet()
.forEach(System.out::println);

a=2
b=1
c=1

Optional操作

CSDN大佬博客：

JDK1.8新特性值Optional_木叶之荣的博客-CSDN博客_jdk1.8 optional

通常用以解决空指针异常：

常用方式：

方式一

 Optional.ofNullable(list).ifPresent(list -> {
            list .stream().forEach(System.out::println;
        });

方式二

 Optional.ofNullable(userList).orElseGet(() -> {
                    return new ArrayList<>();
                })
                .stream()
                .filter(a -> a != null)
                .forEach(System.out::println);
        }

原文地址：http://www.cnblogs.com/ProsperousEnding/p/16828627.html