• StreamAPI的使用

     

     

    1.    Stream 关注的是对数据的运算，与CPU打交道
        集合关注的是数据存储，与内存打交道

     2.特点

     (1) 自己不会存储元素
     (2) 不会改变源对象。相反，他们会返回一个持有结果的新的Stream
    (3) 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

    3. Stream执行流程 

     (1) Stream实例化
    (2) 一系列的中间操作(过滤、映射...)
     (3) 终止操作

     4. 说明

     (1) 一个中间操作链，对数据源的数据进行处理
     (2) 一旦执行终止操作，就执行中间操作链，共产生结果。之后，不会再被使用

    数据准备 

    Employee类 

    1. public class Employee {
    2.  
    3. 	private int id;
    4. 	private String name;
    5. 	private int age;
    6. 	private double salary;
    7. 	
    8. 	public Employee(int id, String name, int age, double salary) {
    9. 		
    10. 		this.id = id;
    11. 		this.name = name;
    12. 		this.age = age;
    13. 		this.salary = salary;
    14. 	}
    15. 	
    16. 	public Employee() {
    17. 		
    18. 	}
    19.  
    20. 	public int getId() {
    21. 		return id;
    22. 	}
    23.  
    24. 	public void setId(int id) {
    25. 		this.id = id;
    26. 	}
    27.  
    28. 	public String getName() {
    29. 		return name;
    30. 	}
    31.  
    32. 	public void setName(String name) {
    33. 		this.name = name;
    34. 	}
    35.  
    36. 	public int getAge() {
    37. 		return age;
    38. 	}
    39.  
    40. 	public void setAge(int age) {
    41. 		this.age = age;
    42. 	}
    43.  
    44. 	public double getSalary() {
    45. 		return salary;
    46. 	}
    47.  
    48. 	public void setSalary(double salary) {
    49. 		this.salary = salary;
    50. 	}
    51.  
    52. 	@Override
    53. 	public String toString() {
    54. 		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
    55. 	}
    56.  
    57. 	@Override
    58. 	public int hashCode() {
    59. 		final int prime = 31;
    60. 		int result = 1;
    61. 		result = prime * result + age;
    62. 		result = prime * result + id;
    63. 		result = prime * result + ((name == null) ? 0 : name.hashCode());
    64. 		long temp;
    65. 		temp = Double.doubleToLongBits(salary);
    66. 		result = prime * result + (int) (temp ^ (temp >>> 32));
    67. 		return result;
    68. 	}
    69.  
    70. 	@Override
    71. 	public boolean equals(Object obj) {
    72. 		if (this == obj)
    73. 			return true;
    74. 		if (obj == null)
    75. 			return false;
    76. 		if (getClass() != obj.getClass())
    77. 			return false;
    78. 		Employee other = (Employee) obj;
    79. 		if (age != other.age)
    80. 			return false;
    81. 		if (id != other.id)
    82. 			return false;
    83. 		if (name == null) {
    84. 			if (other.name != null)
    85. 				return false;
    86. 		} else if (!name.equals(other.name))
    87. 			return false;
    88. 		if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
    89. 			return false;
    90. 		return true;
    91. 	}
    92. 	
    93. 	
    94. 	
    95. }

     EmployeeData

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4. public class EmployeeData {
    5.  
    6. 	public static List<Employee> getEmployee(){
    7. 		List<Employee> list=new ArrayList<>();
    8. 		
    9. 		list.add(new Employee(1001,"马化腾",34,6000.38));
    10. 		list.add(new Employee(1002,"马云",12,9876.12));
    11. 		list.add(new Employee(1003,"刘强东",34,3000.82));
    12. 		list.add(new Employee(1004,"雷军",26,7657.37));
    13. 		list.add(new Employee(1005,"李彦宏",65,5555.32));
    14. 		list.add(new Employee(1006,"比尔盖茨",42,9500.43));
    15. 		list.add(new Employee(1007,"任正非",26,4333.32));
    16. 		list.add(new Employee(1008,"扎克伯格",35,2500.32));
    17. 		
    18. 		return list;
    19. 	}
    20. }

    Stream的实例化方法

    1. public class StreamAPITest {
    2.  
    3. 	/**
    4. 	 * 测试Stream的实例化
    5. 	 */
    6. 	// 创建Stream 方式一： 通过集合
    7. 	public void test1() {
    8. 		List<Employee> employees= EmployeeData.getEmployee();
    9. 		
    10. 		// default Stream<E> stream() : 返回一个顺序流
    11. 		Stream<Employee> stream = employees.stream();
    12. 		
    13. 		// default Stream<E> parallelStream(): 返回一个并行流
    14. 		Stream<Employee> parallelStream = employees.parallelStream();
    15. 	}
    16. 	
    17. 	//创建 Stream 方式二： 通过数组
    18. 	@Test
    19. 	public void test2() {
    20. 		int [] arr = {1,2,3,4,5,6};
    21. 		//调用Arrays类的static<T> Stream<T> stream (T [] array) :返回一个流
    22. 		IntStream stream = Arrays.stream(arr);
    23. 		
    24. 		Employee e1 = new Employee(100,"Tom", 0, 0);
    25. 		Employee e2 = new Employee(100,"Tom", 0, 0);
    26. 		
    27. 		Employee [] arr2 = {e1,e2};
    28. 		Stream<Employee> stream2= Arrays.stream(arr2);
    29. 	}
    30. 	
    31. 	//创建Stream方式三：通过Stream的of()
    32. 	@Test
    33. 	public void test3() {
    34. 		Stream<Integer> stream=Stream.of(1,2,3,4,5,6);
    35. 	}
    36. 	
    37. 	//创建Stream方式四： 创建无限流
    38. 	@Test
    39. 	public void test4() {
    40. 		//遍历前10个偶数
    41. 		Stream.iterate(0, t->t+2).limit(10).forEach(System.out::println);
    42. 		System.out.println("------------------");
    43. 		
    44. 		//打印10个随机小数
    45. 		Stream.generate(Math::random).limit(10).forEach(i->System.out.println(i));
    46. 	}
    47. }

    Stream的中间操作

    1. import java.util.ArrayList;
    2. import java.util.Arrays;
    3. import java.util.List;
    4. import java.util.stream.Stream;
    5.  
    6. import org.junit.jupiter.api.Test;
    7.  
    8. public class StreamAPITest2 {
    9.  
    10. 	/**
    11. 	 * 测试Stream的中间操作
    12. 	 */
    13. 	// 1. 筛选和切片
    14. 	@Test
    15. 	public void test1() {
    16. 		List<Employee> list=EmployeeData.getEmployee();
    17. 		
    18. 		System.out.println("---------filter------");
    19. 		// filter(Predicate p) ----接收 Lambda，从流中排除某些元素
    20. 		Stream<Employee> stream=list.stream();
    21. 		// 练习：查询员工表中，员工工资大于7000的员工信息
    22. 		stream.filter(e -> e.getSalary()>7000).forEach(i->System.out.println(i));
    23. 		
    24. 		System.out.println("------limit(n)--------");
    25. 		
    26. 		//limit(n) 截断流 ,使其元素不超过给定数量
    27. 		list.stream().limit(3).forEach(System.out::println);
    28. 		
    29. 		System.out.println("----skip(n)------");
    30. 		
    31. 		// skip(n) --跳过元素，返回一个扔掉了前n个元素的流
    32. 		list.stream().skip(3).forEach(i->System.out.println(i));
    33. 		
    34. 		//distinct() --筛选，通过流所生成元素的hasnCode()和equals() 去除重复元素
    35. 		System.out.println("-------------------distinct-------------");
    36. 		list.add(new Employee(1010,"刘强东",40,8000));
    37. 		list.add(new Employee(1010,"刘强东",40,8000));
    38. 		list.add(new Employee(1010,"刘强东",40,8000));
    39. 		list.add(new Employee(1010,"刘强东",40,8000));
    40. 		list.add(new Employee(1010,"刘强东",40,8000));
    41. 		list.add(new Employee(1010,"刘强东",40,8000));
    42. 		
    43. 		list.stream().distinct().forEach(i->System.out.println(i));
    44. 	}
    45. 	
    46. 	//映射
    47. 	@Test
    48. 	public void test2() {
    49. 		//map (function f) --接收一个函数作为参数，将元素转换为其他形式或提取信息
    50. 		List<String> list = Arrays.asList("aa","bb","cc","dd");
    51. 		list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
    52. 		
    53. 		//练习：获取员工姓名长度大于3的员工姓名
    54. 		System.out.println("---------nameStreamFilter----------");
    55. 		List<Employee> employees = EmployeeData.getEmployee();
    56. 		Stream<String> nameStream = employees.stream().map(e -> e.getName());
    57. 		nameStream.filter(name -> name.length()>3).forEach(System.out::println);;
    58. 		
    59. 		System.out.println("------------");
    60. 		//flatMap(Function f) -- 接收一个函数作为参数，将流中的每个值换位另一个流，然后把所有的流连成一个流
    61. 		Stream<Character> charStream = list.stream().flatMap(StreamAPITest2::fromStringToStream);
    62. 		charStream.forEach(System.out::println);
    63. 	}
    64. 	
    65. 	//将字符串中的多个字符串构成的集合转换为对应的Stream实例
    66. 	public static Stream<Character> fromStringToStream(String str){
    67. 		ArrayList<Character> list= new ArrayList<>();
    68. 		for(Character c:str.toCharArray()) {
    69. 			list.add(c);
    70. 		}
    71. 		return list.stream();
    72. 	}
    73. 	
    74. 	//3--排序
    75. 	@Test
    76. 	public void test4() {
    77. 		//sorted--自然排序
    78. 		System.out.println("----sorted--------");
    79. 		List<Integer> list = Arrays.asList(12,43,65,34,87,0,-98,7);
    80. 		list.stream().sorted().forEach(System.out::println);
    81. 		
    82. 		//sorted(Compare com) -- 定制排序
    83. 		System.out.println("------sorted(com)-----");
    84. 		List<Employee> employees = EmployeeData.getEmployee();
    85. 		employees.stream().sorted( (e1,e2)->{
    86. 			return (e1.getAge()-e2.getAge());
    87. 		} ).forEach(System.out::println);
    88. 	}
    89. 	
    90. }

    测试终止植操作

     1. 匹配和查找

    1. import java.util.List;
    2. import java.util.Optional;
    3. import java.util.stream.Stream;
    4.  
    5. import org.junit.jupiter.api.Test;
    6.  
    7. /**
    8.  * 测试终止操作
    9.  * @author CharlieLiang
    10.  *
    11.  */
    12. public class StreamAPITest3 {
    13.  
    14. 	//1-- 匹配与查找
    15. 	@Test
    16. 	public void test1() {
    17. 		List<Employee> employees = EmployeeData.getEmployee();
    18. 		//allMath(Predicate p) -- 检查是否匹配所有元素
    19. 		// 练习：是否所有员工的年龄都大于18
    20. 		System.out.println("-------allMath----------");
    21. 		boolean allMath= employees.stream().allMatch( e -> e.getAge()>10);
    22. 		System.out.println(allMath);
    23. 		
    24. 		System.out.println("--------anyMatch----------");
    25. 		//anyMatch(Predicate p) -- 检查是否至少匹配一个袁术
    26. 		//练习：是否存在员工工资大于10000
    27. 		boolean anyMatch = employees.stream().anyMatch( e -> e.getSalary()>1000);
    28. 		System.out.println(anyMatch);
    29. 		
    30. 		System.out.println("----noneMath-------");
    31. 		//练习： 是否不存在员工姓雷
    32. 		boolean noneMath = employees.stream().noneMatch( e -> e.getName().startsWith("雷"));
    33. 		System.out.println(noneMath);
    34. 		
    35. 		System.out.println("------findFirst------");
    36. 		Optional<Employee> firstEmployee = employees.stream().findFirst();
    37. 		System.out.println(firstEmployee);
    38. 		
    39. 		System.out.println("--------findAny-----------");
    40. 		Optional<Employee> findAny = employees.parallelStream().findAny();
    41. 		System.out.println(findAny);
    42. 	}
    43. 	
    44. 	
    45. 	@Test
    46. 	public void test2() {
    47. 		List<Employee> employees = EmployeeData.getEmployee();
    48. 		// count -- 返回流中元素的总个数
    49. 		System.out.println("---------count-----------");
    50. 		long count = employees.stream().filter( e -> e.getSalary()>5000).count();
    51. 		System.out.println(count);
    52. 		
    53. 		// 练习返回最高工资
    54. 		System.out.println("--------max--------");
    55. 		Stream<Double> salaryStream = employees.stream().map( e -> e.getSalary());
    56. 		Optional<Double> maxSalary = salaryStream.max(
    57. 			(s1,s2) -> {
    58. 				return (int) (s1-s2);
    59. 			}
    60. 		);
    61. 		System.out.println(maxSalary);
    62. 		
    63. 		System.out.println("--------max2------");
    64. 		Stream<Double> salaryStream2 = employees.stream().map( e -> e.getSalary());
    65. 		Optional<Double> maxSalary2 = salaryStream2.max(Double::compare);
    66. 		System.out.println(maxSalary2);
    67. 		
    68. 		// 返回最低工资的员工
    69. 		System.out.println("---min---");
    70. 		Optional<Employee> minSalaryEmployee = 
    71. 				employees.stream().min( (e1,e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
    72. 		System.out.println(minSalaryEmployee);
    73. 		
    74. 		//forEach (Consumer c) --- 内部迭代
    75. 		employees.stream().forEach(i -> System.out.println(i));
    76. 		
    77. 		// 或者
    78. 		// employees.forEach(System.out::println);
    79. 	}
    80. }

    2. 归约测试

    1. import java.util.Arrays;
    2. import java.util.List;
    3. import java.util.Optional;
    4. import java.util.stream.Stream;
    5.  
    6. import org.junit.jupiter.api.Test;
    7. /**
    8.  * 归约测试
    9.  * @author CharlieLiang
    10.  *
    11.  */
    12. public class StreamAPITest4 {
    13.  
    14. 	
    15. 	@Test
    16. 	public void test1() {
    17. 		//reduce (T identity, BinaryOperator) -- 可以将流中的元素反复结合起来，得到一个值。返回T
    18. 		// 练习计算1-10的自然数的和
    19. 		System.out.println("----reduce-----");
    20. 		List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    21. 		// 0: 表示初始值是0
    22. 		Integer sum = list.stream().reduce(0 , Integer::sum);
    23. 		System.out.println(sum);
    24. 		
    25. 		System.out.println("---reduce2----");
    26. 		
    27. 		List<Integer> list2 = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    28. 		// 0: 表示初始值是0
    29. 		Integer sum2 = list2.stream().reduce(0 , (a,b) -> (a+b));
    30. 		System.out.println(sum2);
    31. 		
    32. 		
    33. 		System.out.println("-----reduce(Optional T)---");
    34. 		// reduce(BinaryOperator b)--可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
    35. 		List<Employee> employees = EmployeeData.getEmployee();
    36. 		Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
    37. 		Optional<Double> salarySum = salaryStream.reduce(Double::sum);
    38. 		System.out.println(salarySum);
    39. 		
    40. 		System.out.println("-----reduce(Optional T)2---");
    41. 		Stream<Double> salaryStream2 = employees.stream().map(Employee::getSalary);
    42. 		Optional<Double> salarySum2 = salaryStream2.reduce((a,b) -> (a+b) );
    43. 		System.out.println(salarySum2);
    44. 	}
    45. }

    3. 收集测试

    1. import java.util.List;
    2. import java.util.Set;
    3. import java.util.stream.Collectors;
    4.  
    5. import org.junit.jupiter.api.Test;
    6.  
    7. /**
    8.  * 收集测试
    9.  * @author CharlieLiang
    10.  *
    11.  */
    12. public class StreamAPITest5 {
    13.  
    14. 	@Test
    15. 	public void test1() {
    16. 		// collect(Collector c) -- 将流转化为其他形式。接收一个Collector接口的实现，
    17. 		// 用于给Stream中元素做汇总的方法
    18. 		//练习：查找工资大于6000的员工，结果返回一个List或Set
    19. 		System.out.println("---toList----");
    20. 		List<Employee> employees = EmployeeData.getEmployee();
    21. 		List<Employee> empList = employees.stream().filter( e -> e.getSalary()>6000).collect(Collectors.toList());
    22. 		empList.forEach(System.out::println);
    23. 		
    24. 		System.out.println("---toSet----");
    25. 		Set<Employee> empSet = employees.stream().filter( e -> e.getSalary()>6000).collect(Collectors.toSet());
    26. 		empSet.forEach( i -> System.out.println(i));
    27. 	}
    28. }

    Optional类的使用

    介绍

     Optional类： 为了在程序中避免出现空指针异常而创建的
    常用的方法 :  ofNullable(T t)
                           ofElse(T t) 

    数据准备

    girl类 

    1. public class Girl {
    2.  
    3. 	private String name;
    4.  
    5. 	public Girl(String name) {
    6.  
    7. 		this.name = name;
    8. 	}
    9.  
    10. 	public Girl() {
    11.  
    12. 	}
    13.  
    14. 	public String getName() {
    15. 		return name;
    16. 	}
    17.  
    18. 	public void setName(String name) {
    19. 		this.name = name;
    20. 	}
    21.  
    22. 	@Override
    23. 	public String toString() {
    24. 		return "Girl [name=" + name + "]";
    25. 	}
    26. 	
    27. }

     Boy类

    1. public class Boy {
    2.  
    3. 	private Girl girl;
    4.  
    5. 	public Boy(Girl girl) {
    6. 		this.girl = girl;
    7. 	}
    8.  
    9. 	public Boy() {
    10. 		
    11. 	}
    12.  
    13. 	public Girl getGirl() {
    14. 		return girl;
    15. 	}
    16.  
    17. 	public void setGirl(Girl girl) {
    18. 		this.girl = girl;
    19. 	}
    20.  
    21. 	@Override
    22. 	public String toString() {
    23. 		return "Boy [girl=" + girl + "]";
    24. 	}
    25. 	
    26. }

    测试类 

    1. import java.util.Optional;
    2.  
    3. import org.junit.jupiter.api.Test;
    4.  
    5. /**
    6.  * Optional类： 为了在程序中避免出现空指针异常而创建的
    7.  * 常用的方法 : ofNullable(T t)
    8.  * 			    ofElse(T t)
    9.  * @author CharlieLiang
    10.  *
    11.  */
    12. public class OptionTest {
    13.  
    14. 	/**
    15. 	 * Option.of(T t): 创建一个Optional实例，t必须非空
    16. 	 * Optional.empty(): 创建一个空的Optional实例
    17. 	 * Optional.ofNullable(T t): t可以为null
    18. 	 */
    19. 	
    20. 	@Test
    21. 	public void test1() {
    22. 		Girl girl = new Girl();
    23. 		Optional<Girl> optionalGirl = Optional.of(girl);
    24. 		System.out.println(optionalGirl);
    25. 	}
    26. //	----------------------------
    27. 	@Test
    28. 	public void test2() {
    29. 		Girl girl = new Girl();
    30. 		Optional<Girl> optionalGirl = Optional.ofNullable(girl);
    31. 		System.out.println(optionalGirl);
    32. 		
    33. 		System.out.println("---------");
    34. 		
    35. 		Girl girl2 = null;
    36. 		Optional<Girl> optionalGirl2 = Optional.ofNullable(girl2);
    37. 		System.out.println(optionalGirl2);
    38. 		
    39. 		System.out.println("--------");
    40. 		
    41. 		//orElse(T t1) : 如果当前的Optional内部封装的t是非空的，则返回内部的t
    42. 		// 如果内部的t是空的，则返回orElse() 方法中的参数t1
    43. 		Girl girl3 = optionalGirl2.orElse( new Girl("小梅"));
    44. 		System.out.println(girl3);
    45. 	}
    46. //	-----------------------------------
    47. 	public String getGirlName(Boy boy) {
    48. 		return boy.getGirl().getName();
    49. 	}
    50. 	
    51. 	@Test
    52. 	public void test3() {
    53. 		Boy boy = new Boy();
    54. 		String girlName = getGirlName(boy);
    55. 		System.out.println(girlName);
    56. 	}
    57. //	----------------------------------
    58. 	
    59. 	
    60. 	// 优化以后的版本
    61. 	public String getGirlName2(Boy boy) {
    62. 		if(boy != null ) {
    63. 			Girl girl=boy.getGirl();
    64. 			if(girl != null) return girl.getName();
    65. 		}
    66. 		return null;
    67. 	}
    68. 	
    69. 	@Test
    70. 	public void test4() {
    71. 		Boy boy = new Boy();
    72. 		String girlName = getGirlName2(boy);
    73. 		System.out.println(girlName);
    74. 	}
    75. //	------------------------------------
    76. 	
    77. 	// 使用Optinal类getGirlName():
    78. 	public String getGirlName3(Boy boy) {
    79. 		Optional<Boy> boyOptional = Optional.ofNullable(boy);
    80. 		// 此时boy2一定非空
    81. 		Boy boy2 = boyOptional.orElse(new Boy(new Girl("大梅")));
    82. 		
    83. 		Girl girl=boy2.getGirl();
    84. 		Optional<Girl> girlOptional = Optional.ofNullable(girl);
    85. 		// girl2 一定非空
    86. 		Girl girl2 = girlOptional.orElse(new Girl("小娟"));
    87. 		
    88. 		return girl2.getName();
    89. 	}
    90. 	
    91. 	@Test
    92. 	public void test5() {
    93. 		Boy boy = null;
    94. 		String girlName = getGirlName3(boy);
    95. 		System.out.println(girlName);
    96. 		
    97. 		System.out.println("---------");
    98. 		
    99. 		Boy boy2 = new Boy();
    100. 		String str= getGirlName3(boy2);
    101. 		System.out.println(str);
    102. 		
    103. 		System.out.println("----------");
    104. 		
    105. 		Boy boy3 = new Boy( new Girl("陈老师") );
    106. 		String strChen= getGirlName3(boy3);
    107. 		System.out.println(strChen);
    108. 	}
    109. 	
    110. }

    运行结果：

    test1

     test2

     test3

    NullPointerException

    test4

     test5

     

  • 相关阅读:
    文件操作安全之-文件上传原理篇
    ES 查询时提示：all shards failed [type=search_phase_execution_exception]
    分布式Trace：横跨几十个分布式组件的慢请求要如何排查？
    快速入门Docker
    深度学习 | Transformer 基本原理
    Metabase学习教程：仪表盘-2
    TiDB Lightning 前置检查
    SVG 和 CSS3 实现一个超酷爱心 Like 按钮
    版本控制 | 如何有效管理SVN服务器上的多个储存库
    java并发问题记录
  • 原文地址：https://blog.csdn.net/m0_46306264/article/details/125442560