java8+stream+remove_Java8的Stream用法

Java8 API新增了一个新的抽象流Stream，它可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。Stream就是把集合数据看作流，流在管道中传输，我们可在管道中进行排序聚合等操作。

在平时写代码的过程中，涉及到集合操作时候，Stream API可以极大的提高我们的生产力，让我们写出高效率、干净、简洁的代码。Stream API有很多操作可供使用，这里主要介绍常用的几个方法。

基础Stream API

forEach

forEach是迭代流中的每一个元素。

1

2

3

4

5

6

7

8@Test

public void testForeach() {

Random random = new Random();

List list= new ArrayList<>();

//random.ints(-100,100).limit(10).forEach(System.out::println);

random.ints(-100,100).limit(10).forEach(t->list.add(t));

System.out.println(list);

}

上述是用forEach迭代输出每一个-100至100的随机值，输出10个，还可以迭代进入一个新的List集合。

map

map对流中每个元素进行操作，返回一个新的流

1

2

3

4

5

6

7

8

9

10

11

12@Test

public void testMap(){

// 只是对流操作并不会改变原List中的数据

//Stream fruit=Stream.of("apple","orange","banner","pear");

List fruit = Arrays.asList("apple","orange","banner","pear");

fruit.stream().sorted().map(String::toUpperCase).forEach(System.out::println);

System.out.println(fruit);

// 返回新的流

List newfruit = fruit.stream().map(v->v.toUpperCase()).collect(Collectors.toList());

System.out.println(newfruit);

}

上述是对每个元素进行大写字母化，或输出或返回到新的集合中

filter

filter 方法用于通过设置的条件过滤出元素

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19/**

* Long 数组选取不为Null和大于0的值

* @param t

* @return

*/

public static Long[] removeNullAndZero(Long[] t) {

List list = Arrays.asList(t);

return list.stream().filter(v->v!=null && v>0).toArray(Long[] :: new);

}

/**

* 选取String数组 不为Null的值

* @param t

* @return

*/

public static String[] removeNullAndZero(String[] t) {

List list = Arrays.asList(t);

return list.stream().filter(v->v!=null).toArray(String[] :: new);

}

过滤Null或者大于0的元素

1

2

3

4

5

6@Test

public void testFilter() {

List intList = Arrays.asList(8,2,4,1,8,3,10,6,6,15);

List newIntList=intList.stream().filter(i->i>5).sorted().distinct().collect(Collectors.toList());

System.out.println(newIntList);

}

上述是过滤大于5的值，并且排序，取唯一的数字输出到新的集合。

parallelStream

parallelStream 是流并行处理程序的代替方法，相比较Stream是多管道操作。它就是基于ForkJoinPool执行并发任务的。

特点

使用parallelStream可以简洁高效的写出并发代码。

parallelStream并行执行是无序的。

parallelStream提供了更简单的并发执行的实现，但并不意味着更高的性能，它是使用要根据具体的应用场景。如果cpu资源紧张parallelStream不会带来性能提升；如果存在频繁的线程切换反而会降低性能。

任务之间最好是状态无关的，因为parallelStream默认是非线程安全的，可能带来结果的不确定性。

Github上对Parallel做了增强，有兴趣可以点击访问。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15@Test

public void testParallel() {

Random random = new Random();

List list= new ArrayList<>();

random.ints(-10000,10000).limit(10000).forEach(t->list.add(t));

long start = System.currentTimeMillis();

list.stream().filter(e -> e > 1000 && e< 2000).collect(Collectors.toList());

System.out.println("stream : " + (System.currentTimeMillis() - start) + "ms");

start = System.currentTimeMillis();

list.parallelStream().filter(e -> e > 1000 && e < 2000).collect(Collectors.toList());

System.out.println("parallelStream : " + (System.currentTimeMillis() - start) + "ms");

}

测试并发处理速度，上述代码对此做了测试，测试结果parallelStream速度是稍快一点。

Count

Stream API还提供简单的统计操作。

1

2

3

4

5

6

7

8

9

10

11@Test

public void testCount() {

List numList = Arrays.asList(6, 2, 4, 3, 7, 3, 5, 9);

DoubleSummaryStatistics stats = numList.stream().mapToDouble((x) -> x).summaryStatistics();

System.out.println("总个数 : " + stats.getCount());

System.out.println("列表中最大的数 : " + stats.getMax());

System.out.println("列表中最小的数 : " + stats.getMin());

System.out.println("所有数之和 : " + stats.getSum());

System.out.println("平均数 : " + stats.getAverage());

}

简单的统计的功能。

实际应用

我在实际项目对会有集合进行操作，使用Stream API能够帮我简洁的解决问题。下面是我实际使用场景。

对象类1

2

3

4

5

6

7

8

9

10

11

12

13

14import lombok.AllArgsConstructor;

import lombok.Data;

import lombok.NoArgsConstructor;

@Data

@NoArgsConstructor

@AllArgsConstructor

public class Person {

private String name;

private Integer gender;

private int age;

private double height;

}

使用场景

构造数据1

2

3

4

5

6

7

8

9

10

11

12static List createPeople(){

List people=new ArrayList();

Person person=new Person("张三",0,30,2.8);

people.add(person);

person=new Person("李四",0,32,1.6);

people.add(person);

person=new Person("王五",1,32,2.0);

people.add(person);

person=new Person("王五",1,33,1.6);

people.add(person);

return people;

}

连接某一属性

需要并行显示，用,连接某一属性

1

2

3

4

5

6

7

8@Test

public void CollectionStreamJoin(){

List people=createPeople();

Stream stream=people.stream();

// 取出对象的name值，并用,连接

String names = stream.map(v->v.getName()).collect(Collectors.joining(","));

System.out.println(names);

}

获取某属性唯一值

根据某一个属性值，删选对象。只保留唯一的属性值

1

2

3

4

5

6

7

8

9@Test

public void distinctList() {

List people=createPeople();

List distinctlist = people.stream()

.collect(Collectors.collectingAndThen(

Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))),

ArrayList::new));

System.out.println(distinctlist);

}

多属性排序

需要用多个属性去进行排序

1

2

3

4

5

6@Test

public void sortField() {

List people=createPeople();

people.sort(Comparator.comparing(Person::getAge).reversed().thenComparing(Person::getHeight));

System.out.println(JSON.toJSONString(people));

}

分组后排序

对象列表先按照一个字段分组，并根据另一个字段的大小来排序，取第一个对象

1

2

3

4

5

6

7

8

9

10

11@Test

public void getOnlyOneByField() {

List people=createPeople();

Map map =new HashMap<>();

map = people.parallelStream()

.collect(Collectors.groupingBy(Person::getName,

Collectors.collectingAndThen(

Collectors.reducing((c1, c2) -> c1.getAge()>c2.getAge()?c1:c2),

Optional::get)));

System.out.println(map);

}

总结

使用Stream API可以让集合操作的代码更为简洁，提高生产力。而且本人在写Stream操作的时候，思想就跟写SQL语句类似，包括分组、聚合、过滤等操作，遇到难的可以在思维上借鉴下。