StreamAPI的说明

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API。

Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

为什么要用StreamAPI

实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要java层面去处理。

Stream到底是是什么

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，Stream讲的是计算！”



注意：

Stream 自己不会存储元素。

Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream操作的三个步骤

1- 创建 Stream

一个数据源（如：集合、数组），获取一个流

2- 中间操作

一个中间操作链，对数据源的数据进行处理

3- 终止操作(终端操作)

一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

如图所示：

创建Stream

有三种方式：

1、通过集合(Java8中的Collection接口被扩展没提供了两个获取流的方法 Stream() parallelStream())

2、通过数组(Java8 中的 Arrays 的静态方法 stream() 可以获取数组流 static Stream stream(T[] array): 返回一个流)

3、通过Stream的of()方法(可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数 public static Stream of(T... values) : 返回一个流)

首先有个Person类

  1. package com.xnn.lambda;
  2. /**
  3.  * 类(接口)描述:
  4.  * @author xnn
  5.  * 2018年10月21日下午3:05:37
  6.  */
  7. public class Person {
  8. private String name;
  9. private int age;
  10. private double salary;
  11. private Status status;
  12. /**
  13.  * @return the name
  14.  */
  15. public String getName() {
  16. 	return name;
  17. }
  18. /**
  19.  * @param name the name to set
  20.  */
  21. public void setName(String name) {
  22. 	this.name = name;
  23. }
  24. /**
  25.  * @return the age
  26.  */
  27. public int getAge() {
  28. 	return age;
  29. }
  30. /**
  31.  * @param age the age to set
  32.  */
  33. public void setAge(int age) {
  34. 	this.age = age;
  35. }
  36. /**
  37.  * @return the salary
  38.  */
  39. public double getSalary() {
  40. 	return salary;
  41. }
  43. public void setSalary(double salary) {
  44. 	this.salary = salary;
  45. }
  47. /**
  48.  * @param name
  49.  * @param age
  50.  * @param salary
  51.  * @param status
  52.  */
  53. public Person(String name, int age, double salary, Status status) {
  54. 	super();
  55. 	this.name = name;
  56. 	this.age = age;
  57. 	this.salary = salary;
  58. 	this.status = status;
  59. }
  60. public Person() {
  61. 	super();
  62. }
  63. /**
  64.  * @return the status
  65.  */
  66. public Status getStatus() {
  67. 	return status;
  68. }
  69. /**
  70.  * @param status the status to set
  71.  */
  72. public void setStatus(Status status) {
  73. 	this.status = status;
  74. }
  76. /**
  77.  * @param name
  78.  * @param age
  79.  * @param salary
  80.  */
  81. public Person(String name, int age, double salary) {
  82. 	super();
  83. 	this.name = name;
  84. 	this.age = age;
  85. 	this.salary = salary;
  86. }
  87. /* (non-Javadoc)
  88.  * @see java.lang.Object#hashCode()
  89.  */
  90. @Override
  91. public int hashCode() {
  92. 	final int prime = 31;
  93. 	int result = 1;
  94. 	result = prime * result + age;
  95. 	result = prime * result + ((name == null) ? 0 : name.hashCode());
  96. 	long temp;
  97. 	temp = Double.doubleToLongBits(salary);
  98. 	result = prime * result + (int) (temp ^ (temp >>> 32));
  99. 	result = prime * result + ((status == null) ? 0 : status.hashCode());
  100. 	return result;
  101. }
  102. /* (non-Javadoc)
  103.  * @see java.lang.Object#equals(java.lang.Object)
  104.  */
  105. @Override
  106. public boolean equals(Object obj) {
  107. 	if (this == obj)
  108. 		return true;
  109. 	if (obj == null)
  110. 		return false;
  111. 	if (getClass() != obj.getClass())
  112. 		return false;
  113. 	Person other = (Person) obj;
  114. 	if (age != other.age)
  115. 		return false;
  116. 	if (name == null) {
  117. 		if (other.name != null)
  118. 			return false;
  119. 	} else if (!name.equals(other.name))
  120. 		return false;
  121. 	if (Double.doubleToLongBits(salary) != Double
  122. 			.doubleToLongBits(other.salary))
  123. 		return false;
  124. 	if (status != other.status)
  125. 		return false;
  126. 	return true;
  127. }
  129. /* (non-Javadoc)
  130.  * @see java.lang.Object#toString()
  131.  */
  132. @Override
  133. public String toString() {
  134. 	return "Person [name=" + name + ", age=" + age + ", salary=" + salary
  135. 			+ ", status=" + status + "]";
  136. }
  138. public enum Status {
  139. 	FREE,
  140. 	BUSY,
  141. 	VACATION;
  142. }
  143. }

  2. package com.xnn.stream;
  4. import java.util.Arrays;
  5. import java.util.List;
  6. import java.util.Optional;
  7. import java.util.stream.Stream;
  9. import org.junit.Test;
  11. import com.xnn.lambda.Person;
  13. /**
  14.  * 类(接口)描述:Stream 操作的三个步骤
  15.  * 1.创建流
  16.  * 2.做一些中间操作
  17.  * 3.做终止操作
  18.  * @author xnn
  19.  * 2018年10月22日下午2:56:26
  20.  */
  21. public class TestStreamAPI {
  22. //获取流的第一种方式   （Java8中的Collection接口被扩展没提供了两个获取流的方法 Stream()  parallelStream()）
  23. 	List<Person> person = Arrays.asList(
  24. 			new Person("李四", 59, 6666.66),
  25. 			new Person( "张三", 18, 9999.99),
  26. 			new Person( "王五", 28, 3333.33),
  27. 			new Person( "赵六", 8, 7777.77),
  28. 			new Person( "田七", 38, 5555.55)
  29. 	);
  30. 	@Test
  31. 	public void test1() {
  32. 		//获取一个顺序流
  33. 		Stream<Person> stream = person.stream();
  34. 		System.out.println(stream);
  36. 		//获取一个并行流
  37. 		Stream<Person> parallelStream = person.parallelStream();
  38. 		System.out.println(parallelStream);
  40. 		//获取流的第二种方式 ——由数组创建流
  41. 		Integer arr[] = new Integer[] {1,4,5,6,78,7};
  42. 		Stream<Integer> stream2 = Arrays.stream(arr);
  43. 		Optional<Integer> first = stream2.findFirst();
  44. 		System.out.println(first);
  45. 		//获取流的第三种方式——可以使用静态方法 Stream.of(),即用值创建流
  46. 		Stream<String> stream3 = Stream.of("y7yiu");
  47. 	}
  48. 	@Test
  49. 	public void test2() {
  50. 		//创建无限流
  51. 				//迭代的方式创建无限流
  52. 				Stream.iterate(0,(x)->x+2).limit(10)
  53. 				.forEach(System.out::println);;
  54. 				//生成的方式产生无限流
  55. 				Stream.generate(()->Math.random()).limit(3).forEach(System.out::println);;
  56. 	}
  57. }

运行结果：

  1. java.util.stream.ReferencePipeline$Head@5ef04b5
  2. java.util.stream.ReferencePipeline$Head@5f4da5c3
  3. Optional[1]
  4. 0
  5. 2
  6. 4
  7. 6
  8. 8
  9. 10
  10. 12
  11. 14
  12. 16
  13. 18
  14. 0.20849306218015928
  15. 0.526378190370348
  16. 0.6520277965773994

Stream的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

中间操作——筛选与切片



代码示例

  1.  *
  2.  */
  3. package com.xnn.stream;
  5. import java.net.StandardSocketOptions;
  6. import java.util.ArrayList;
  7. import java.util.Arrays;
  8. import java.util.Collections;
  9. import java.util.HashSet;
  10. import java.util.List;
  11. import java.util.Map;
  12. import java.util.Map.Entry;
  13. import java.util.Optional;
  14. import java.util.Set;
  15. import java.util.function.Function;
  16. import java.util.function.Predicate;
  17. import java.util.stream.Collector;
  18. import java.util.stream.Collectors;
  19. import java.util.stream.Stream;
  21. import org.junit.Test;
  23. import com.xnn.lambda.Person;
  24. import com.xnn.lambda.Person.Status;
  26. /**
  27.  * 类(接口)描述://中间操作
  28.  *
  29.  * @author xnn 2018年10月22日下午3:27:12
  30.  */
  31. public class TestStreamAPI2 {
  33. 	List<Person> person = Arrays.asList(
  34. 			new Person("李四", 59, 6666.66, Status.FREE),
  35. 			new Person("张三", 18, 9999.99, Status.FREE),
  36. 			new Person("王五", 28, 3333.33, Status.BUSY),
  37. 			new Person("赵六", 8, 7777.77, Status.VACATION),
  38. 			new Person("田七", 38, 5555.55, Status.BUSY),
  39. 			new Person("田七", 38, 5555.55, Status.VACATION),
  40. 			new Person("田七", 38, 5555.55, Status.VACATION)
  42. 	);
  43. 	/*
  44. 	 * 筛选与切片 filter——接收 Lambda ， 从流中排除某些元素。 limit——截断流，使其元素不超过给定数量。
  45. 	 * skip(n) ——跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。
  46. 	 * 与 limit(n) 互补
  47. 	 * distinct——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
  48. 	 */
  49. 	@Test
  50. 	public void test1() {
  51. 		// 先获取流
  52. 		Stream<Person> stream = person.stream();
  54. 		// 筛选 Stream<T> filter(Predicate<? super T> predicate);
  55. 		// Predicate接口的test方法 传递进去一个T 返回一个Boolean
  56. 		// filter——接收 Lambda ， 从流中排除某些元素
  57. 		// 这个forEach被称为是内部迭代
  58. 		stream.filter((u) -> {
  59. 			System.out.println("中间操作");
  60. 			//筛选出年龄大于20 的人员
  61. 			return u.getAge() > 20;
  62. 		}).forEach(System.out::println);
  63. 		System.out.println("==============================");
  64. 		/**
  65. 		 * 下面这一部分由于没有终止操作，所以"中间操作"这四个字并没有打印出来，只有当做终止操作时，所有的中间操作会一次性的全部执行，称为“惰性求值”
  66. 		 */
  67. 		Stream<Person> stream4 = person.stream();
  68. 		stream4.filter((u) -> {
  69. 			System.out.println("中间操作");
  70. 			return u.getAge() > 20;
  71. 		});
  72. 		System.out.println("==============================");
  74. 		// 必须再创建一个新流 目测是新功能的时候，不能用上面的流，否则会报流已经打开或关闭的错误
  75. 		Stream<Person> stream1 = person.stream();
  77. 		// limit——截断流，使其元素不超过给定数量
  78. 		//筛选出年龄大于20岁的人元信息后，只取前两个值
  79. 		stream1.filter((u) -> u.getAge() > 20).limit(2)
  80. 				.forEach(System.out::println);
  81. 		System.out.println("==============================");
  83. 		// skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
  84. 		Stream<Person> stream2 = person.stream();
  85. 		//筛选出年龄大于20岁的人元信息后，跳过第一个人，取后面的值
  86. 		stream2.filter((u) -> u.getAge() > 20).skip(1)
  87. 				.forEach(System.out::println);
  89. 		System.out.println("==============================");
  91. 		// distinct——筛选，通过流所生成元素的 hashCode() 和 equals()这样去除重复元素(意即需要重写实体类的hashcode 和equals方法)
  92. 		Stream<Person> stream3 = person.stream();
  94. 		stream3.filter((u) -> u.getAge() > 20).distinct()
  95. 				.forEach(System.out::println);
  96. 	}
  97. }

运行结果：

中间操作——映射



代码示例

  1. package com.xnn.stream;
  3. import java.net.StandardSocketOptions;
  4. import java.util.ArrayList;
  5. import java.util.Arrays;
  6. import java.util.Collections;
  7. import java.util.HashSet;
  8. import java.util.List;
  9. import java.util.Map;
  10. import java.util.Map.Entry;
  11. import java.util.Optional;
  12. import java.util.Set;
  13. import java.util.function.Function;
  14. import java.util.function.Predicate;
  15. import java.util.stream.Collector;
  16. import java.util.stream.Collectors;
  17. import java.util.stream.Stream;
  19. import org.junit.Test;
  21. import com.xnn.lambda.Person;
  22. import com.xnn.lambda.Person.Status;
  24. /**
  25.  * 类(接口)描述://中间操作
  26.  *
  27.  * @author xnn 2018年10月22日下午3:27:12
  28.  */
  29. public class TestStreamAPI2 {
  31. 	List<Person> person = Arrays.asList(
  32. 			new Person("李四", 59, 6666.66, Status.FREE),
  33. 			new Person("张三", 18, 9999.99, Status.FREE),
  34. 			new Person("王五", 28, 3333.33, Status.BUSY),
  35. 			new Person("赵六", 8, 7777.77, Status.VACATION),
  36. 			new Person("田七", 38, 5555.55, Status.BUSY),
  37. 			new Person("田七", 38, 5555.55, Status.VACATION),
  38. 			new Person("田七", 38, 5555.55, Status.VACATION)
  40. 	);
  41. /**
  42. 	 * 映射： 1、map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
  43. 	 * 2、mapToDouble(ToDoubleFunction f)) 接收一个函数作为参数，该函数会被应用到每个素上，产生一个新的
  44. 	 * DoubleStream 3、mapToInt(ToIntFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的
  45. 	 * IntStream。 4、mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的
  46. 	 * LongStream 5、flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
  47. 	 *
  48. 	 * @author:xnn 2018年10月22日下午3:55:54
  49. 	 */
  50. 	@Test
  51. 	public void test2() {
  52. 		Stream<Person> stream = person.stream();
  53. 		// 1、map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
  54. 		// 把姓名的集合取出来
  55. 		// stream.map((x)->x.getName()).forEach(System.out::println);
  56. 		//方法引用的方式写的
  57. 		stream.map(Person::getName).forEach(System.out::println);
  58. 		System.out.println("================");
  60. 		// 2、mapToDouble(ToDoubleFunction f)) 接收一个函数作为参数，该函数会被应用到每个素上，产生一个DoubleStream
  61. 		Stream<Person> stream1 = person.stream();
  62. 		// stream1.mapToDouble((x)->x.getSalary())
  63. 		// .forEach(System.out::println);
  64. 		// 另一种写法 即:接受了Person类的getSalary()方法为参数，把薪资全都取出胡来了
  65. 		stream1.mapToDouble(Person::getSalary).forEach(System.out::println);
  66. 		System.out.println("================");
  68. 		// 3、mapToInt(ToIntFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
  69. 		Stream<Person> stream2 = person.stream();
  70. 		stream2.mapToInt(Person::getAge).forEach(System.out::println);
  71. 		System.out.println("================");
  73. 		Stream<String> stream3 = Stream.of("aaa", "bbb", "ccc", "ddd");
  74. 		Stream<Stream<Character>> map =
  75. 	    /*TestStreamAPI2::filterCharacter就代表把每一个字符串（"aaa","bbb"...）都进行filterCharacter()处理，
  76. 		这时候每个字母，都变成了一个流，而map()方法返回的也是一个流，所以返回值就成了Stream<Stream<Character>>*/
  77. 		 stream3.map(TestStreamAPI2::filterCharacter);
  79. 		 //用map的话还得多重遍历(sm 代表一个Stream<Character>，所以再对sm进行了遍历)
  80. 		 map.forEach((sm)->sm.forEach(System.out::println));
  81.                 System.out.println("++++++++++++++++++++++++++");
  83.         // flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，
  84.         //然后把所有流连接成一个流（是个关键）
  85. 		Stream<String> stream4 = Stream.of("aaa", "bbb", "ccc", "ddd");
  86. 		Stream<Character> flatMap = stream4
  87. 				.flatMap(TestStreamAPI2::filterCharacter);
  88. 		flatMap.forEach(System.out::println);
  89. 		System.out.println("==============");
  91. 		/**
  92. 		 * map 和flatmap类似于list集合的add()方法和addAll()方法
  93. 		 */
  94. 		List<Object> list =new ArrayList<>();
  95. 		List<Object> list2 =new ArrayList<>();
  96. 		list.add("aaa");
  97. 		list.add("bbb");
  98. 		list2.add("1");
  99. 		//add是把集合加进去了
  100. 		list2.add(list);
  101. 		System.out.println(list2);
  103. 		System.out.println("+++++++++++++++++++++++++");
  104. 		List<Object> list3 =new ArrayList<>();
  105. 		List<Object> list4 =new ArrayList<>();
  106. 		list3.add("aaa");
  107. 		list3.add("bbb");
  108. 		list4.add("1");
  109. 		//addAll是把集合中的每一个元素加进去了
  110. 		list4.addAll(list3);
  111. 		System.out.println(list4);
  113. 	}
  115. 	// 把字符串转化为字符数组流
  116. 	public static Stream<Character> filterCharacter(String str) {
  117. 		List<Character> list = new ArrayList<>();
  118. 		for (Character character : str.toCharArray()) {
  119. 			list.add(character);
  120. 		}
  121. 		return list.stream();
  122. 	}
  123. }

运行结果

  1. 李四
  2. 张三
  3. 王五
  4. 赵六
  5. 田七
  6. 田七
  7. 田七
  8. ================
  9. 6666.66
  10. 9999.99
  11. 3333.33
  12. 7777.77
  13. 5555.55
  14. 5555.55
  15. 5555.55
  16. ================
  17. 59
  18. 18
  19. 28
  20. 8
  21. 38
  22. 38
  23. 38
  24. ================
  25. a
  26. a
  27. a
  28. b
  29. b
  30. b
  31. c
  32. c
  33. c
  34. d
  35. d
  36. d
  37. ++++++++++++++++++++++++++
  38. a
  39. a
  40. a
  41. b
  42. b
  43. b
  44. c
  45. c
  46. c
  47. d
  48. d
  49. d
  50. ==============
  51. 用add的结果：[1, [aaa, bbb]]
  52. +++++++++++++++++++++++++
  53. 用addAll的结果：[1, aaa, bbb]

中间操作——排序



代码示例

  1. package com.xnn.stream;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.HashSet;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Optional;
  9. import java.util.stream.Collectors;
  10. import java.util.stream.Stream;
  12. import org.junit.Test;
  14. import com.xnn.lambda.Person;
  15. import com.xnn.lambda.Person.Status;
  17. /**
  18.  * 类(接口)描述://中间操作
  19.  *
  20.  * @author xnn 2018年10月22日下午3:27:12
  21.  */
  22. public class TestStreamAPI2 {
  24. 	List<Person> person = Arrays.asList(
  25. 			new Person("李四", 59, 6666.66, Status.FREE),
  26. 			new Person("张三", 18, 9999.99, Status.FREE),
  27. 			new Person("王五", 28, 3333.33, Status.BUSY),
  28. 			new Person("赵六", 8, 7777.77, Status.VACATION),
  29. 			new Person("田七", 38, 5555.55, Status.BUSY),
  30. 			new Person("田七", 38, 5555.55, Status.VACATION),
  31. 			new Person("田七", 38, 5555.55, Status.VACATION)
  33. 	);
  34. /**
  35. 	 * sorted() 产生一个新流，其中按自然顺序 sorted(Comparator comp) 产生一个新流，其中按比较器顺序
  36. 	 */
  37. 	@Test
  38. 	public void test3() {
  39. 		// sorted() 产生一个新流，其中按自然顺序
  40. 		List<String> list = Arrays.asList("aa", "bb", "cc", "dd", "ee");
  41. 		Stream<String> stream = list.stream();
  42. 		stream.sorted().forEach(System.out::println);
  43. 		System.out.println("-------------------------");
  45. 		// sorted(Comparator comp) 产生一个新流，其中按比较器顺序
  46. 		person.stream().sorted((e1, e2) -> {
  47. 			/**
  48. 			 * 年龄相同按姓名排序，否则按年龄排序
  49. 			 */
  50. 			if (e1.getAge() == e2.getAge()) {
  51. 				return e1.getName().compareTo(e2.getName());
  52. 			} else {
  53. 				return Integer.compare(e1.getAge(), e2.getAge());
  54. 			}
  55. 		}).forEach(System.out::println);;
  56. 	}
  57. }

运行结果

  1. aa
  2. bb
  3. cc
  4. dd
  5. ee
  6. -------------------------
  7. Person [name=赵六, age=8, salary=7777.77, status=VACATION]
  8. Person [name=张三, age=18, salary=9999.99, status=FREE]
  9. Person [name=王五, age=28, salary=3333.33, status=BUSY]
  10. Person [name=田七, age=38, salary=5555.55, status=BUSY]
  11. Person [name=田七, age=38, salary=5555.55, status=VACATION]
  12. Person [name=田七, age=38, salary=5555.55, status=VACATION]
  13. Person [name=李四, age=59, salary=6666.66, status=FREE]

Stream 的终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

流进行了终止操作后，不能再次使用。

终止操作——匹配与查找



代码示例

  1. package com.xnn.stream;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.HashSet;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Optional;
  9. import java.util.stream.Collectors;
  10. import java.util.stream.Stream;
  12. import org.junit.Test;
  14. import com.xnn.lambda.Person;
  15. import com.xnn.lambda.Person.Status;
  17. /**
  18.  * 类(接口)描述://中间操作
  19.  *
  20.  * @author xnn 2018年10月22日下午3:27:12
  21.  */
  22. public class TestStreamAPI2 {
  24. 	List<Person> person = Arrays.asList(
  25. 			new Person("李四", 59, 6666.66, Status.FREE),
  26. 			new Person("张三", 18, 9999.99, Status.FREE),
  27. 			new Person("王五", 28, 3333.33, Status.BUSY),
  28. 			new Person("赵六", 8, 7777.77, Status.VACATION),
  29. 			new Person("田七", 38, 5555.55, Status.BUSY),
  30. 			new Person("田七", 38, 5555.55, Status.VACATION),
  31. 			new Person("田七", 38, 5555.55, Status.VACATION)
  33. 	);
  34. /**
  35. 	 * stream的终止操作(查找与匹配)
  36. 	 * 1、allMatch(Predicate p) 检查是否匹配所有元素
  37. 	 * 2、anyMatch(Predicate p) 检查是否至少匹配一个元素
  38. 	 * 3、noneMatch(Predicate p)检查是否没有匹配所有元素
  39. 	 * 4、findFirst() 返回第一个元素
  40. 	 * 5、findAny() 返回当前流中的任意元素
  41. 	 * @author:xnn 2018年10月23日下午2:48:07
  42. 	 */
  43. 	@Test
  44. 	public void test4() {
  45. 		// allMatch(Predicate p) 检查是否匹配所有元素，即所有元素的status是BUSY才返回true
  46. 		boolean b = person.stream()
  47. 				.allMatch((e) -> e.getStatus().equals(Status.BUSY));
  48. 		System.out.println(b);
  49. 		System.out.println("===================");
  51. 		// anyMatch(Predicate p) 检查是否至少匹配一个元素，只要有一个元素的status是BUSY就返回true
  52. 		boolean c = person.stream()
  53. 				.anyMatch((w) -> w.getStatus().equals(Status.BUSY));
  54. 		System.out.println(c);
  55. 		System.out.println("===================");
  57. 		// noneMatch(Predicate p) 检查是否没有匹配所有元素，即 所有的元素的status都不是BUSY才返回true
  58. 		boolean d = person.stream()
  59. 				.noneMatch((q) -> q.getStatus().equals(Status.BUSY));
  60. 		System.out.println(d);
  61. 		System.out.println("===================");
  63. 		// findFirst() 返回第一个元素，返回符合条件的第一个元素
  64. 		Optional<Person> findFirst = person.stream().sorted(
  65. 				(e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
  66. 				.findFirst();
  67. 		System.out.println(findFirst.get());
  68. 		System.out.println("========================");
  70. 		// findAny() 返回当前流中的任意元素()
  71. 		Optional<Person> any = person.parallelStream()
  72. 				.filter((e) -> e.getStatus().equals(Status.BUSY)).findAny();
  73. 		System.out.println(any);
  74. 	}
  75. }

运行结果

  1. false
  2. ===================
  3. true
  4. ===================
  5. false
  6. ===================
  7. Person [name=王五, age=28, salary=3333.33, status=BUSY]
  8. ========================
  9. Optional[Person [name=田七, age=38, salary=5555.55, status=BUSY]]

终止操作——匹配与查找二



代码示例：


  2. package com.xnn.stream;
  4. import java.util.ArrayList;
  5. import java.util.Arrays;
  6. import java.util.HashSet;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Optional;
  10. import java.util.stream.Collectors;
  11. import java.util.stream.Stream;
  13. import org.junit.Test;
  15. import com.xnn.lambda.Person;
  16. import com.xnn.lambda.Person.Status;
  18. /**
  19.  * 类(接口)描述://中间操作
  20.  *
  21.  * @author xnn 2018年10月22日下午3:27:12
  22.  */
  23. public class TestStreamAPI2 {
  25. 	List<Person> person = Arrays.asList(
  26. 			new Person("李四", 59, 6666.66, Status.FREE),
  27. 			new Person("张三", 18, 9999.99, Status.FREE),
  28. 			new Person("王五", 28, 3333.33, Status.BUSY),
  29. 			new Person("赵六", 8, 7777.77, Status.VACATION),
  30. 			new Person("田七", 38, 5555.55, Status.BUSY),
  31. 			new Person("田七", 38, 5555.55, Status.VACATION),
  32. 			new Person("田七", 38, 5555.55, Status.VACATION)
  34. 	);
  35. /**
  36. 	 * 1、count() 返回流中元素总数
  37. 	 * 2、max(Comparator c) 返回流中最大值
  38. 	 * 3、min(Comparator c)返回流中最小值
  39. 	 * 4、forEach(Consumer c) 内部迭代(使用 Collection接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做
  40. 	 */
  41. 	@Test
  42. 	public void test5() {
  43. 		// count() 返回流中元素总数
  44. 		long count = person.stream().count();
  45. 		System.out.println(count);
  46. 		System.out.println("=======华丽的分割线========");
  48. 		// max(Comparator c) 返回流中最大值
  49. 		Optional<Person> max = person.stream().max(
  50. 				(e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
  51. 		System.out.println("最高工资员工为" + max);
  52. 		System.out.println("=======华丽的分割线========");
  54. 		// min(Comparator c) 返回流中最小值
  55. 		Optional<Person> min = person.stream().min(
  56. 				(e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
  57. 		System.out.println("最低工资员工为" + min);
  58. 	}
  59. }

运行结果

  1. 7
  2. =======华丽的分割线========
  3. 最高工资员工为Optional[Person [name=张三, age=18, salary=9999.99, status=FREE]]
  4. =======华丽的分割线========
  5. 最低工资员工为Optional[Person [name=王五, age=28, salary=3333.33, status=BUSY]]

终止操作——归约



map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名。

代码示例：


  2. package com.xnn.stream;
  4. import java.util.ArrayList;
  5. import java.util.Arrays;
  6. import java.util.HashSet;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Optional;
  10. import java.util.stream.Collectors;
  11. import java.util.stream.Stream;
  13. import org.junit.Test;
  15. import com.xnn.lambda.Person;
  16. import com.xnn.lambda.Person.Status;
  18. /**
  19.  * 类(接口)描述://中间操作
  20.  *
  21.  * @author xnn 2018年10月22日下午3:27:12
  22.  */
  23. public class TestStreamAPI2 {
  25. 	List<Person> person = Arrays.asList(
  26. 			new Person("李四", 59, 6666.66, Status.FREE),
  27. 			new Person("张三", 18, 9999.99, Status.FREE),
  28. 			new Person("王五", 28, 3333.33, Status.BUSY),
  29. 			new Person("赵六", 8, 7777.77, Status.VACATION),
  30. 			new Person("田七", 38, 5555.55, Status.BUSY),
  31. 			new Person("田七", 38, 5555.55, Status.VACATION),
  32. 			new Person("田七", 38, 5555.55, Status.VACATION)
  34. 	);
  35. /**
  36. 	 * 归约
  37. 	 * 1、reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值，返回 T
  38. 	 * 2、reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
  39. 	 */
  40. 	@Test
  41. 	public void test6() {
  42. 		// reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值，返回 T
  43. 		List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  44. 		/**
  45. 		 * 先把0作为了x，y是流中的第一个元素 相加得1，然后1作为x，流中的第二个元素作为y，就这样，依次加下去。
  46. 		 */
  47. 		Integer reduce = list.stream().reduce(0, (x, y) -> x + y);
  48. 		System.out.println(reduce);
  49. 		System.out.println("=======华丽的分割线========");
  51. 		// reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
  52. 		/**
  53. 		 * 可以看出两个reduce方法返回的并不一样，因为第一个reduce方法有初始值，最后所得的值肯定不会为空，而第二种情况则有可能会为空，所以返回值为跑optional
  54. 		 */
  55. 		Optional<Double> reduce2 = person.stream().map(Person::getSalary)
  56. 				.reduce(Double::sum);
  57. 		System.out.println(reduce2);
  58. 		System.out.println("=======华丽的分割线========");
  60. 	}
  61. }

运行结果：

  1. 55
  2. =======华丽的分割线========
  3. Optional[44444.40000000001]
  4. =======华丽的分割线========

终止操作——收集



Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。

另外， Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：





代码示例

  1. package com.xnn.stream;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.HashSet;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Optional;
  9. import java.util.stream.Collectors;
  10. import java.util.stream.Stream;
  12. import org.junit.Test;
  14. import com.xnn.lambda.Person;
  15. import com.xnn.lambda.Person.Status;
  17. /**
  18.  * 类(接口)描述://中间操作
  19.  *
  20.  * @author xnn 2018年10月22日下午3:27:12
  21.  */
  22. public class TestStreamAPI2 {
  24. 	List<Person> person = Arrays.asList(
  25. 			new Person("李四", 59, 6666.66, Status.FREE),
  26. 			new Person("张三", 18, 9999.99, Status.FREE),
  27. 			new Person("王五", 28, 3333.33, Status.BUSY),
  28. 			new Person("赵六", 8, 7777.77, Status.VACATION),
  29. 			new Person("田七", 38, 5555.55, Status.BUSY),
  30. 			new Person("田七", 38, 5555.55, Status.VACATION),
  31. 			new Person("田七", 38, 5555.55, Status.VACATION)
  33. 	);
  34. /**
  35. 	 * 收集： collect(Collector c) 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
  36. 	 */
  37. 	@Test
  38. 	public void test7() {
  39. 		//把人员的名字放到一个list中去
  40. 		List<String> collect = person.stream().map(Person::getName)
  41. 				.collect(Collectors.toList());
  42. 		System.out.println(collect);
  43.           System.out.println("=======华丽的分割线=======");
  45.           //把人员的名字放到一个hashset中去(会自动去重)
  46. 		HashSet<String> collect2 = person.stream().map(Person::getName)
  47. 				.collect(Collectors.toCollection(HashSet::new));
  48. 		System.out.println(collect2);
  49.         System.out.println("=======华丽的分割线=======");
  51. 		//计数
  52. 		Long long1 = person.stream().collect(Collectors.counting());
  53. 		System.out.println(long1);
  54.         System.out.println("=======华丽的分割线=======");
  56. 		// 按状态分组
  57. 		Map<Status, List<Person>> collect3 = person.stream()
  58. 				.collect(Collectors.groupingBy((e) -> e.getStatus()));
  59. 		System.out.println(collect3);
  60.         System.out.println("=======华丽的分割线=======");
  62. 		// 多重分组(先按状态分组，再按薪资是否大于5000分组)
  63. 		Map<Status, Map<Boolean, List<Person>>> collect4 = person.stream()
  64. 				.collect(Collectors.groupingBy((e) -> e.getStatus(),
  65. 						Collectors.groupingBy((e) -> e.getSalary() > 5000)));
  66. 		System.out.println(collect4);
  67.         System.out.println("=======华丽的分割线=======");
  69.         //取所有人员薪资的平均值
  70. 		Double double1 = person.stream()
  71. 				.collect(Collectors.averagingDouble((e) -> e.getSalary()));
  72. 		System.out.println("所有人员薪资的平均值:"+double1);
  73.         System.out.println("=======华丽的分割线=======");
  75.         //把所有人的姓名拼接成一个字符串
  76. 		String collect5 = person.stream().map(Person::getName)
  77. 				.collect(Collectors.joining());
  78. 		System.out.println(collect5);
  79.         System.out.println("=======华丽的分割线=======");
  81.         //找出所有人中薪资最少的一个员工的信息。
  82. 		Optional<Person> optional = person.stream().collect(Collectors.minBy(
  83. 				(e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
  84. 		System.out.println(optional);
  85.         System.out.println("=======华丽的分割线=======");
  87. 	}
  88. }

运行结果

  1. [李四, 张三, 王五, 赵六, 田七, 田七, 田七]
  2. =======华丽的分割线=======
  3. [李四, 张三, 王五, 赵六, 田七]
  4. =======华丽的分割线=======
  5. 7
  6. =======华丽的分割线=======
  7. {BUSY=[Person [name=王五, age=28, salary=3333.33, status=BUSY], Person [name=田七, age=38, salary=5555.55, status=BUSY]], FREE=[Person [name=李四, age=59, salary=6666.66, status=FREE], Person [name=张三, age=18, salary=9999.99, status=FREE]], VACATION=[Person [name=赵六, age=8, salary=7777.77, status=VACATION], Person [name=田七, age=38, salary=5555.55, status=VACATION], Person [name=田七, age=38, salary=5555.55, status=VACATION]]}
  8. =======华丽的分割线=======
  9. {BUSY={false=[Person [name=王五, age=28, salary=3333.33, status=BUSY]], true=[Person [name=田七, age=38, salary=5555.55, status=BUSY]]}, FREE={true=[Person [name=李四, age=59, salary=6666.66, status=FREE], Person [name=张三, age=18, salary=9999.99, status=FREE]]}, VACATION={true=[Person [name=赵六, age=8, salary=7777.77, status=VACATION], Person [name=田七, age=38, salary=5555.55, status=VACATION], Person [name=田七, age=38, salary=5555.55, status=VACATION]]}}
  10. =======华丽的分割线=======
  11. 所有人员薪资的平均值:6349.2
  12. =======华丽的分割线=======
  13. 李四张三王五赵六田七田七田七
  14. =======华丽的分割线=======
  15. Optional[Person [name=王五, age=28, salary=3333.33, status=BUSY]]
  16. =======华丽的分割线=======

Java8新特性——StreamAPI 的使用的更多相关文章

  1. Java8新特性——StreamAPI(二)

    1. 收集器简介 收集器用来将经过筛选.映射的流进行最后的整理,可以使得最后的结果以不同的形式展现. collect方法即为收集器,它接收Collector接口的实现作为具体收集器的收集方法. Col ...

  2. Java8新特性——StreamAPI(一)

    1. 流的基本概念 1.1 什么是流? 流是Java8引入的全新概念,它用来处理集合中的数据,暂且可以把它理解为一种高级集合. 众所周知,集合操作非常麻烦,若要对集合进行筛选.投影,需要写大量的代码, ...

  3. java8 新特性学习笔记

    Java8新特性 学习笔记 1主要内容 Lambda 表达式 函数式接口 方法引用与构造器引用 Stream API 接口中的默认方法与静态方法 新时间日期 API 其他新特性 2 简洁 速度更快 修 ...

  4. 【Java基础】Java8 新特性

    Java8 新特性 Lambda 表达式 Lambda 是一个匿名函数,我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码像数据一样进行传递).使用它可以写出更简洁.更灵活的代码. L ...

  5. java8新特性全面解析

    在Java Code Geeks上有大量的关于Java 8 的教程了,像玩转Java 8--lambda与并发,Java 8 Date Time API 教程: LocalDateTime和在Java ...

  6. Java8新特性

    Java8新特性 Java8主要的新特性涵盖:函数式接口.Lambda 表达式.集合的流式操作.注解的更新.安全性的增强.IO\NIO 的改进.完善的全球化功能等. 1.函数式接口 Java 8 引入 ...

  7. Java系列 - 用Java8新特性进行Java开发太爽了

    本人博客文章网址:https://www.peretang.com/using-java8s-new-features-to-coding-is-awesome/ 前言 从开始写博客到现在已经过去3个 ...

  8. Java8 新特性之Stream----java.util.stream

    这个包主要提供元素的streams函数操作,比如对collections的map,reduce. 例如: int sum = widgets.stream() .filter(b -> b.ge ...

  9. 这可能是史上最好的 Java8 新特性 Stream 流教程

    本文翻译自 https://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/ 作者: @Winterbe 欢迎关注个人微信公众 ...

随机推荐

  1. springboot热启动中那些不为人知的东东

    在springboot热启动中,大家都知道在pom文件中配置devtools,但是当这个服务特别大,或者引入的包特别多的时候,重启一下就特别慢,如果开发的PC的内存和cpu如果不给里的h话,系统就卡主 ...

  2. Spring5源码解析2-register方法注册配置类

    接上回已经讲完了this()方法,现在来看register(annotatedClasses);方法. // new AnnotationConfigApplicationContext(AppCon ...

  3. PDF目录编辑器使用介绍

    PDF目录编辑器使用介绍 魏刘宏 2019.06.28 PDF 是一个比较优秀的文档格式,能够保证在任何终端显示的样式是一样的.但同时也带来了一个问题,就是编辑不方便,其实这也是这个格式特意为之的,无 ...

  4. 刷抖音太累，教你用Python把高颜值的小姐姐都爬下来慢慢看

    前言 文的文字及图片来源于网络,仅供学习.交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理. 作者: 星安果.AirPython 目 标 场 景 相信大家平时刷抖音短视频 ...

  5. 【OOM】解决思路

    一.什么是OOM? OOM就是outOfMemory,内存溢出!可能是每一个java人员都能遇到的问题!原因是堆中有太多的存活对象(GC-ROOT可达),占满了堆空间. 二.怎么解决? 1.拿到内存溢 ...

  6. crm-2

    1.分页 web必备的功能 1)批量制造测试数据 定义一个空列表用于存储 orm对象 ,models.表名(字段=...)创建orm对象append到列表 ,使用bulk_create(对象列表)一次 ...

  7. SQL Server中的LEFT、RIGHT函数

    SQL Server中的LEFT.RIGHT函数. LEFT:返回字符串中从左边开始指定个数字符. LEFT(character_expression,integer_expression); RIG ...

  8. 《0day安全软件漏洞分析技术》学习笔记

    最近因为工作需要在看0day的软件漏洞分析,发现这本<0day安全软件漏洞分析技术(第2版)>真是本好书,唯一缺点就是书上的环境是Windows XP 32Bit的,基于现状难以进行实践, ...

  9. GBT22239-2008-等保1.0三级要求

    第三级基本要求 7.1 技术要求 7.1.1 物理安全 7.1.1.1 物理位置的选择(G3) 本项要求包括: a)   机房和办公场地应选择在具有防震.防风和防雨等能力的建筑内: b)   机房场地 ...

  10. Day_04 面向对象

    概述 对于面向对象编程的支持,Go语言设计得非常简洁而优雅.因为,Go语言并没有沿袭传统 面向对象编程中的诸多概念,比如继承(不支持继承,尽管匿名字段的内存布局和行为类似继承,但它并不是继承). 虚函 ...