java 8 语法_Java8 Stream语法

前言：

讲Stream之前，先来用个小需求带入本文。毕竟代码看的最清楚。

正文：

项目某个页面有个需求，将关键词和集合比对，判断是否存在关键词，这种需求想必是再普通不过，最简单的就是循环迭代了。

上来就干，普通for循环，判断：

for (int i = 0; i < airPortModels1.size(); i++) {

if (airPortModels1.get(i).getAirport().contains(searchWord)) {

searchList.add(airPortModels1.get(i).getAirport());

searchAirPort.add(airPortModels1.get(i));

}

}```

要么就用增强型for循环

for (SkiModel skiModel : airPortModels1) {

if (skiModel.getPark().equals(searchWord)) {

searchList.add(skiModel.getPark());

searchAirPort.add(skiModel);

}

}```

都是遍历每个元素，进行比对，而集合内所有元素都是存储于内存中，如果集合比较大，则比较耗费内存，那么可以使用Stream

利用Stream：

airPortModels1

.stream()

.filter(skiModel -> skiModel.getPark().equals(searchWord))

.forEach(skiModel -> {

searchList.add(skiModel.getPark());

searchAirPort.add(skiModel);

});```

- #####Stream，源码分析：

A sequence of elements supporting sequential and parallel aggregate operations

一个集合流，支持顺序和并行聚合操作```

Stream理解起来就是高级的迭代器，普通迭代器就是遍历元素，然后逐一进行某个操作；而Stream可以根据一些特定条件，对元素进行操作，例如过滤Value小于5的元素，获取首字母为大写的元素，都可以交给Stream来进行。

还是以例子来说明：( 后面都会通过这个例子来讲解)

List list = Arrays.asList(2, 3, 4, 55, -1, 0, null);

list.stream().filter(integer -> integer > 0).count();///过滤出所有大于0的元素，最后得到个数。```

Stream在这里主要做了两件事情。

第一、把所有元素获取到

第二、把大于0的元素过滤出来。

**我们最后调用count()就是获取结果，相当于获取新的List的size。只是相当于，仅仅为了利于我们理解方便，实际上，Stream并没有new一个新List。我们要做的事情就是，获取到Stream，告诉Stream我们要做什么，然后问Stream要结果。**

来分析Stream的语法：

将 list.stream().filter(integer -> integer > 0).count()分为三部分，

**list.stream()** ---------先创建Stream

**filter(integer -> integer > 0)** --------------转换Stream，将创建的Stream进行转换，返回新的Stream，可以进行多次转换

**count()**---------处理Stream，将转换后的Stream进行汇聚，得到想要的结果

**而且最后.count()也是必不可少的，如果不向Stream索取结果，没有需求，它什么都不会干的，就像项目经理向你提需求一样**

所以讲解Stream也分为这三个步骤：

##### 1.创建Stream：

###### 1.1通过Collection的stream()方法，Collection对象转换成Stream，也就是例子中的方法

list.stream();

default Stream stream() {

return StreamSupport.stream(spliterator(), false);

}```

1.2 通过Stream的静态方法创建：

1.2.1 Stream的of方法，共有两个方法，一个接受变长参数，一个固定参数

public static Stream of(T t) {

return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);

}

@SafeVarargs

@SuppressWarnings("varargs") // Creating a stream from an array is safe

public static Stream of(T... values) {

return Arrays.stream(values);

}```

例如：

Stream list= Stream.of(0,-3,9,20,2); //固定长度

Stream list1= Stream.of("fdsfdas","sdfadd"); //变长参数```

1.2.2 Stream的generator方法 可以生成一个无限长度的Stream，但是 Android N之后才可以使用Generate方法

public static Stream generate(Supplier s) {

Objects.requireNonNull(s);

return StreamSupport.stream(

new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);

}```

例如:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { //Android N之后才可以使用Generate方法

Stream.generate(new Supplier() {

@Override

public Integer get() {

return (int) Math.random().forEach(System.out::print); //随机生成无限长度的Stream

}

});

}```

或者 lambda表达式

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

Stream.generate(() -> (int) Math.random()).forEach(System.out::print); //随机生成无限长度的Stream

}```

如果想要限制Stream的长度，可以使用limit()，后面会讲到

Stream.generate(new Supplier() {

@Override

public Integer get() {

return (int) Math.random();

}

}).limit(10).forEach(System.out::print);//生成长度为10的Stream，并打印```

1.2.3 创建一个规律数据的Stream

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

Stream.iterate(1, new UnaryOperator() {

@Override

public Integer apply(Integer integer) {

return integer+1; //打印1到10的数列

}

}).limit(10).forEach(System.out::print);

}```

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {//打印11个hello字符串

Stream.iterate("hello",UnaryOperator.identity()).limit(11).forEach(System.out::print);

}```

2.转换Stream：(为了更清晰理解每个方法的含义，每个方法都附带一个例子)

1.filter 过滤操作

对Stream中元素使用给定的条件进行过滤，生成只包含符合条件的元素的Stream；

List list = Arrays.asList(2, 3, 4, 55, -1, 0, null);

list.stream().filter(integer -> integer>0).count();//过滤掉不大于0的元素```

**2.map** 转换操作

Arrays.asList("a","b","c","d")

.stream()

.map(s->s+"a,")

.forEach(System.out::print);

//打印出：aa,ba,ca,da,```

map具体有三个方法：mapToInt，mapToLong和mapToDouble。见名知意，例如mapToInt就是把原始Stream转换成一个新的Stream，这个新生成的Stream中的元素都是int类型

例如:

List list = Arrays.asList(2, 3, 4, 55, -1, 0, 12);

list.stream().mapToDouble(new ToDoubleFunction() {

@Override

public double applyAsDouble(Integer value) {

return value.doubleValue(); //返回所有元素都为Double类型的Stream

}

});```

**3.flatMap** 将高纬度变为低纬度

private static void flatMapStream() {

String [] s1 = {"a1","a2","a3"};

String [] s2 = {"b1","b2","b3"};

String [] s3 = {"c1","c2","c3"};

Arrays.asList(s1,s2,s3)

.stream()

.flatMap(str -> Stream.of(str))

.map(s -> s+"/")

.forEach(System.out::print); //打印出a1/a2/a3/b1/b2/b3/c1/c2/c3

}```

和map类似，也有flatMapToInt、flatMapToLong 、flatMapToDouble三个方法，不同的是flatmap中每个元素转换后得到的是Stream对象，会把子Stream中的元素压缩到父集合中；

例如：

List list = Arrays.asList(2, 3, 4, 55, -1, 0, null);

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

list.stream().flatMapToInt(new Function() {

@Override

public IntStream apply(Integer integer) {

return IntStream.of(integer);

}

});

}```

**4.distinct** 去重

对Stream中的元素进行去重操作，生成的Stream中没有重复的元素；

例如：

List list = Arrays.asList(2, 3, 4, 55, -1, 0, null);

long count = list.stream().distinct().count();```

5.sorted 排序

对Stream中元素进行排序，得到排序之后的Stream,有空参和有参两种方法

//空参

List list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);

List list1 = list.stream().sorted().collect(Collectors.toList());//排序得到新的集合```

//有参

List list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);

list.stream().sorted(new Comparator() {

@Override

public int compare(Integer o1, Integer o2) {

return Integer.compare(o1.intValue(), o2.intValue());

}

}).forEach(System.out::print); //按元素大小排序```

使用sorted()这个方法，要求Stream中的数据必须实现了Comparable接口

6.limit Stream进行截断操作

List list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);

list.stream().limit(3).forEach(System.out::print);//截取前三个元素```

**7.skip** 跳过 跳过Stream前的n个元素，(*如果原Stream中包含的元素个数小于N，那么返回空Stream*)

List list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);

list.stream().skip(2).forEach(System.out::print); //跳过前两个元素，将剩余元素打印出来

List list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);

list.stream().skip(10).forEach(System.out::print); //元素个数小于跳过的个数，返回空Stream

**8.peek** 生成一个包含原Stream的所有元素的新Stream,同时会提供一个消费函数(Consumer实例)，新Stream每个元素被消费的时候都会执行给定的消费函数；

Stream stream = list.stream().peek(new Consumer() {

@Override

public void accept(Integer integer) {

}

});//生成新的Stream,并提供Cunsumer实例```

9.contact 合并操作，将两个Stream合并为一个，且仅仅可以合并两个Stream，

List list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);

List list1 = Arrays.asList("a", "b","c","d");

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

Stream.concat(list.stream(), list1.stream())

.skip(10).forEach(System.out::print); //打印出23455-101abc

}```

##### 3.处理Stream

遍历forEach

聚合reduce

Optional类型

收集collect

**3.1 遍历**

forEach

forEachOrdered 两个方法

**3.2.聚合** 可以实现从一组数据中生成一个数据(共有三种形式)

```T reduce(T identity, BinaryOperator accumulator);

Optional reduce(BinaryOperator accumulator);

U reduce(U identity,BiFunction accumulator,BinaryOperator combiner);```

List list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);

list.stream().skip(4).reduce(1, new BinaryOperator() {

@Override

public Integer apply(Integer integer, Integer integer2) {

return integer + integer2; //1和前四个元素的和

}

});```

3.3 Optional

Optional是一种容器，可以存储一些值和null。利用这个类，可以进行null的判断，能够有效的避免NullPointerException

get()`,可以拿到Optional中的值，没有值则抛出空指针异常

isPresent(),有非空的值，返回true，否则返回false

ifPresent(),public void ifPresent(Consumer super T> consumer)这个方法中需要一个Consumer接口。如果有非空的值，就执行指定的Consumer的方法来处理这个非空的值；如果为空，则啥都不做

3.4 收集Stream

可将转换后的Stream转为集合

List list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);

if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {

List list1 = list.stream().skip(5).collect(Collectors.toList());

}```

#### 最后，可以组合使用试试

List list = Arrays.asList(2, 3, 4, 55, -1, 0, 1);

Stream list1 = Stream

.of(Arrays.asList("2", "a", "a", "mm", "mm", "sde", "andoid")) //创建Stream

.skip(1) //跳过第一个元素

.distinct()//去重

.filter(strings -> strings.size() >= 1)//过滤元素小于1的元素

.map(strings -> strings + "hello") //每个元素加上“hello”字符串

.sorted((o1, o2) -> Integer.compare(o1.length(), o2.length())); //按字符串长度排序

Stream.concat(list1, list.stream()) //合并两个Stream

.limit(8) //取前八个元素

.forEach(System.out::print);``` //处理Stream，打印每个元素