JDK1.8新特性介绍+Lambda+函数接口+方法、构造方法和数组引用及Stream流

最新推荐文章于 2022-12-23 10:01:14 发布
最新推荐文章于 2022-12-23 10:01:14 发布
阅读量511 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言 学习 青少年编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GL280599ZL/article/details/127706585
版权

JDK新特性介绍+Lambda+函数接口+方法、构造方法和数组引用及Stream流

一、JDK新特性介绍

  • 速度更快 - 优化底层源码，比如HashMap、ConcurrentHashMap
  • 代码更少 - 添加新的语法Lambda表达式
  • 强大的Stream API
  • 便于并行
  • 最大化减少空指针异常 - Optional

二、Lambda表达式

1.介绍

Lambda是一个匿名函数(方法)， 允许把函数作为一个方法的参数 。利用Lambda表达式可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。一般都是优化匿名内部类

2.基础语法

1.无参数无返回值的抽象方法
public class Test01 {

	public static void main(String[] args) {
		
//		I1 i1 = new I1(){
//
//			@Override
//			public void method() {
//				System.out.println("传统的方式");
//			}
//		};
//		i1.method();
//	}

//		I1 i1 = ()->{
//		System.out.println("lamdba的方式");	
//		};
//		i1.method();
		
		I1 i1 = ()-> System.out.println("lamdba的方式");
		i1.method();
   }
}

interface I1{
	public void method();
}
2.带参数的抽象方法
public class Test01 {

	public static void main(String[] args) {
		
//		I1 i1 = new I1(){
//
//			@Override
//			public void method(int a, int b) {
//				int result = a+b;
//				System.out.println("传统方式-" + result);
//			}
//		};
//		i1.method(100, 400);
		
//		I1 i1 = (int a,int b)->{
//			int result = a+b;
//			System.out.println("lamdba的方式-" + result );
//		};
//		i1.method(520, 520);
		
		//注意：lamdba中使用到外部类的变量时，该变量会变成常量
		int i =100;
		I1 i1 = (x,y)->{
			int result = x+y;
			System.out.println("lamdba的方式-" + result + "----" + i);
		};
		i1.method(10, 20);
	}
}


interface I1 {
	public void method(int a,int b);
}
3.带返回值的抽象方法
public class Test01 {
 
	public static void main(String[] args) {
//		I1 i1 = new I1(){
//
//			@Override
//			public int method(int a, int b) {
//				int result = a+b;
//				System.out.println("传统的方式");
//				return result;
//			}
//		};
//		int num = i1.method(100, 200);
//		System.out.println(num);
		
		I1 i1 = (int a,int b)->{
			int result = a+b;
			System.out.println("lamdba的方式");
			return result;
		};
		int num = i1.method(100,150);
		System.out.println(num);
	}
}

interface I1{
	public int method (int a,int b);
}
4.注意点
public class Test01 {

	public static void main(String[] args) {
		
		//注意点1：重写方法的形参只有一个时，可以不加小括号
//		I1 i1 = a->System.out.println(a);
//		i1.method(100);
		
		//注意点2：Lambda表达式当中不允许声明一个与局部变量同名的参数或者局部变量
		I1 i1 = (a)->System.out.println(a);
		i1.method(200);
	}
}

interface I1{
	public void method(int a);
}
5.Lamdba的案例
1.调用Collections.sort()方法

调用Collections.sort()方法，通过定制排序比较两个Student对象

(先按年龄比较，年龄相同按照薪资比较），使用Lambda表达式作为参数传递

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test01 {

	public static void main(String[] args) {
		
		List<Student> stuList = Arrays.asList(
				new Student("张飞", 31, 4800,Role.WARRIOR),
				new Student("后裔", 28, 7200,Role.SHOOTER),
				new Student("夏侯惇", 19, 9600,Role.WARRIOR),
				new Student("妲己", 28, 6100,Role.MASTER),
				new Student("孙尚香", 23, 9600,Role.SHOOTER),
				new Student("安吉拉", 28, 3000,Role.MASTER));
		
//		Collections.sort(stuList,new Comparator<Student>() {
//
//			@Override
//			public int compare(Student o1, Student o2) {
//				int age1 = o1.getAge();
//				int age2 = o2.getAge();
//				if(age1 != age2){
//					return Integer.compare(age1, age2);
//				}
//				
//				double blood1 = o1.getBlood();
//				double blood2 = o2.getBlood();
//				if(blood1 != blood2){
//					return Double.compare(blood1, blood2);
//				}
//				return 1;
//			}
//		});
		
		Collections.sort(stuList,(stu1,stu2)->{
			int age1 = stu1.getAge();
			int age2 = stu2.getAge();
			if(age1 != age2){
				return Integer.compare(age1, age2);
			}
			
			double salary1 = stu1.getBlood();
			double salary2 = stu2.getBlood();
			if(salary1 != salary2){
				return Double.compare(salary1, salary2);
			}
			return 1;
		});
		
		
		for (Student stu : stuList) {
			System.out.println(stu);
		}
	}
}

public class Student {

	private String name;
	private int age;
	private double blood;
	private Role role;
	
	public Student() {
	}

	public Student(String name, int age, double blood, Role role) {
		this.name = name;
		this.age = age;
		this.blood = blood;
		this.role = role;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getBlood() {
		return blood;
	}

	public void setBlood(double blood) {
		this.blood = blood;
	}

	public Role getRole() {
		return role;
	}

	public void setRole(Role role) {
		this.role = role;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", blood=" + blood + ", role=" + role + "]";
	}
	
	
}

public enum Role {

	MASTER,SHOOTER,WARRIOR;
}
2.创建抽象方法

创建I1接口，创建抽象方法：public String getValue(String str),

在测试类中编写方法使用接口作为参数，将一个字符串转为大写，并作为方法的返回值

public class Test01 {

	public static void main(String[] args) {
		String strHandler =	strHandeler("abc",(str)->str.toUpperCase());
		System.out.println(strHandler);
	}
	
	public static String strHandeler(String str,I1 i1){
		return i1.getValue(str);
	}
}

interface I1{
	public String getValue(String str);
}
3.创建I1<T,R>接口

创建I1<T,R>接口，泛型T为参数，R为返回值，创建抽象方法：public R add(T t1,T t2),

在测试类中编写方法使用接口作为参数，计算两个long类型的和

public class Test01 {

	public static void main(String[] args) {
		
		long addLong = addLong(10,20,(a,b)->a+b);
		System.out.println(addLong);
	}
	
	public static long addLong(long a,long b,I1<Long,Long> i1){
		return i1.add(a,b);
	}
}

interface I1 <T,R>{
	public R add(T t1,T t2);
}

三、函数式接口

函数式接口是指仅仅只包含一个抽象方法的接口，jdk1.8提供了一个@FunctionalInterface注解来定义函数式接口，如果我们定义的接口不符合函数式的规范便会报错。配合Lambda表达式一起使用

函数式接口参数类型返回类型用途
Consumer 消费型接口Tvoidvoid accept(T t);
Supplier 供给型接口voidTT get();
Function<T, R> 函数型接口TRR apply(T t);
Predicate 断言型接口Tbooleanbooelan test(T t);
BiConsumer<T, U>T,Uvoid对类型为T,U参数应用操作。包含方 法为void accept(T t,U u);
BiFunction<T, U, R>T,UR对类型为T,U参数应用操作，并返回R类型的结果。包含方法为R apply(T t,U u);
UnaryOperator extends Function<T, T>T,TT对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为T apply(T t1，T t2);
BinaryOperator extends BiFunction<T,T,T>T,TT对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为T apply(T t1，T t2);
ToIntFunction ToLongFunction ToDoubleFunctionTint long double分别计算int、long、double值的函数
IntFunction LongFunction DoubleFunctionint long doubleR参数为int、long、double类型的函数
1.创建I1<T,R>接口，泛型T为参数，R为返回值，创建抽象方法：public R add(T t1,T t2), 在测试类中编写方法使用接口作为参数，计算两个long类型的和
  
    方法一、
import java.util.function.BiFunction;

public class Test01 {

	public static void main(String[] args) {
		
		long addLong = addLong(10,20,(a,b)->a+b);
		System.out.println(addLong);
	}
	
	public static long addLong(long a,long b,BiFunction<Long,Long,Long> bf){
		return bf.apply(a,b);
	}
}

方法二、

import java.util.function.BinaryOperator;

public class Test01 {

	public static void main(String[] args) {
		
		long addLong = addLong(10,20,(a,b)->a+b);
		System.out.println(addLong);
	}
	
	public static long addLong(long a,long b,BinaryOperator<Long> bo){
		return bo.apply(a,b);
	}
} 

2.创建I1接口，创建抽象方法：public String getValue(String str),在测试类中编写方法使用接口作为参数，将一个字符串转为大写，并作为方法的返回值
    
    方法一、
   import java.util.function.UnaryOperator;

public class Test01 {

	public static void main(String[] args) {
		String strHandler = strHandler("abc", (str)->str.toUpperCase());
		System.out.println(strHandler);
	}
	
	public static String strHandler(String str,UnaryOperator<String> uo){
		return uo.apply(str);
	}
}   

方法二、
import java.util.function.Function;

public class Test01 {

	public static void main(String[] args) {
		
		String strHandler = strHandler("abc",(str)->str.toUpperCase());
		System.out.println(strHandler);
	}
	
	public static String strHandler(String str,Function<String,String> fun){
		return fun.apply(str);
	}
}

函数式接口的应用场景：

在编写接口时，发现该接口只有一个抽象方法，就可以使用Java给我们提供过的函数式接口，

好处：减少自己创建的接口

四、方法、构造方法和数组引用

方法、构造方法和数组引用就是Lamdba的另一种表现形式

1.方法引用

若Lamdba表达式中的内容由方法已经实现了，可以使用方法引用这个技能

当你需要使用方法引用时，目标引用放在分隔符::前，方法的名称放在后面

1.对象::实例方法

Lambda表达式中调用方法的参数类型和返回值必须和函数式接口中的抽象方法一致

public class Test01 {

	public static void main(String[] args) {
		
//		I1 i1 = (str)->System.out.println(str);
//		i1.method("abc");
		
		I1 i1 = System.out::println;
		i1.method("abc");
	}
}

interface I1{
	public void method(String str);
}
2.类名::静态方法
import java.util.Comparator;
public class Test01 {

	public static void main(String[] args) {
		
//		Comparator<Integer> comparator = (a,b)-> Integer.compare(a,b);
//		System.out.println(comparator.compare(100,200));
		
		Comparator<Integer> comparator = Integer::compare;
		System.out.println(comparator.compare(20, 20));
	}
}
3.类名::实例方法

Lambda表达式参数列表中第一个参数必须是实例方法的调用者

Lambda表达式参数列表中第二个参数必须是实例方法的参数

public class Test01 {

	public static void main(String[] args) {
		
//		I1<String> i1 = (str1,str2)->str1.equals(str2);
//		System.out.println(i1.method("abc1","abc2"));
		
		I1<String> i1 = String::equals;
		System.out.println(i1.method("abc1", "abc1"));
	}
}

interface I1<T>{
	public boolean method(T t1,T t2);
}

2.构造方法的引用

类名::new

需要调用的构造方法的参数列表必须和函数式接口中抽象方法的参数列表一致

public class Test01 {

	public static void main(String[] args) {
		
//		I1 i1 = ()->new Student();
//		Student stu1 = i1.method();

		//调用无参构造创建学生对象
		I1 i1 = Student::new;
		Student stu1 = i1.method();
		System.out.println(stu1);
		
//		I2 i2 = (name,age,salary,course)->new Student(name, age, salary, course);
//		Student stu2 = i2.method("孙策", 25, 15000,Course.JAVA);
//		System.out.println(stu2);
		
		//调用有参构造创建学生对象
		I2 i2 = Student::new;
		Student stu2 = i2.method("孙策", 25, 12000, Course.JAVA);
		System.out.println(stu2);
		
	}
}

interface I1{
	public Student method();
}

interface I2{
	public Student method(String name,int age,double salary,Course course);
}

public class Student {

	private String name;
	private int age;
	private double salary;
	private Course course;
	
	public Student() {
	}

	public Student(String name, int age, double salary, Course course) {
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.course = course;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public Course getCourse() {
		return course;
	}

	public void setCourse(Course course) {
		this.course = course;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", salary=" + salary + ", course=" + course + "]";
	}
}

public enum Course {
	JAVA,HTML,PYTHON;
}

3.数组引用

语法格式：type[]::new

import java.util.Arrays;
public class Test01 {

	public static void main(String[] args) {
		
		I1<String[]> i1 =String[]::new;
		String[] dd = i1.method(30);
		System.out.println(Arrays.toString(dd));
	}
}

interface I1<T>{
	public T method(int length);
}

五、Stream流

1.概念

Stream（流）是数据渠道，用于操作数据源（集合、数组等），生成元素序列。换言之，集合是存储数据的容器，流使用操作这些数据的

Stream可以对集合进行非常复杂的查找、过滤、映射数据等操作，类似于SQL执行数据库查询。Stream提供了一种高效且易于使用的处理数据的方式

注意：

  • Stream不会存储数据
  • Stream不会改变源数据，通过一系列操作数据源会返回一个持有结果的新Stream
  • Stream操作是延迟执行的，意味着流会等到需要结果的时候才执行

2.执行步骤

  1. 创建Stream：通过数据源（集合、数组等）获取一个Stream
  2. 中间操作：中间操作链，对源数据的数据进行处理
  3. 终止操作：执行中间操作，并产生结果

3.创建Stream对象

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.stream.Stream;

import org.junit.Test;

public class Test01 {

	@Test
	public void test01(){
		//方式一：通过集合获取流对象

		ArrayList<String> list = new ArrayList<>();
		Collections.addAll(list, "aaa","bbb","ccc","ddd");
		Stream<String> stream = list.stream();//获取此集合的Stream对象
		stream.forEach(System.out::println);//遍历打印流中的数据
	}
	
	@Test
	public void test02(){
		//方式二：通过数组获取流对象
		String[] ss = {"aaa","bbb","ccc","ddd"};
		Stream<String> stream = Arrays.stream(ss);//获取此数组的Stream对象
		stream.forEach(System.out::println);//遍历打印流中的数据
	}
	
	@Test
	public void test03(){
		//方式三：通过Stream的静态方法of()获取流对象
		Stream<String> stream = Stream.of("ccc","bbb","aaa");//将元素添加到Stream对象中
		stream.forEach(System.out::println);//遍历打印流中的数据
	}
	
	@Test
	public void test04(){
		//方式四：创建无限流
		Stream<Integer> stream = Stream.iterate(1, (x)->x+100);
		stream = stream.limit(5);//获取流中前5条数据
		stream.forEach(System.out::println);//遍历打印流中的数据
	}
	
	@Test
	public void test05(){
		//方式五：创建无限流
		Stream<Double> stream = Stream.generate(()->Math.random());//每次随机出一个数字
		 stream = stream.limit(5);//获取流中前5条数据
		 stream.forEach(System.out::println);//遍历打印流中的数据
	}
}

4.中间操作 - 筛选与切片

方法描述
filter(Predicate p)从流中排除元素
limit(long maxSize)设置限制数据条数
skip(long n)跳过元素，返回跳过n个元素的流，若流中不满足n个元素则返回空流。与limit()互补
distinct()筛选，流通过元素对象的hashCode()和equals()方法去除重复元素

如果没有终止操作，中间操作就不会被调用，终止操作时一次性全部处理，这种称为惰性求值/延迟加载

import java.util.Arrays;
import java.util.List;

import org.junit.Test;

public class Test02 {

	List<Student> stuList = Arrays.asList(
			new Student("张三", 28, 4800,Course.JAVA),
			new Student("李四", 36, 7200,Course.JAVA),
			new Student("王五", 19, 9600,Course.HTML),
			new Student("赵六", 42, 6100,Course.HTML),
			new Student("孙七", 23, 9600,Course.PYTHON),
			new Student("吴八", 31, 3000,Course.PYTHON),
   			new Student("李四", 36, 7200,Course.JAVA));
	
	@Test
	public void test01(){
		//需求1：过滤掉工资小于5000的学生对象
		stuList.stream().filter((stu)->{
			if(stu.getSalary() > 5000){
				return true;
			}
			return false;
		}).forEach(System.out::println);
	}
	
	@Test
	public void test02(){
		//需求2：过滤掉工资小于5000的学生对象，并显示3条
		stuList.stream().filter((stu)->{
			if (stu.getSalary() > 5000) {
				return true;
			}
			return false;
		}).limit(3).forEach(System.out::println);
	}
	
	
	@Test
	public void test03(){
		//需求3：过滤掉小于5000的学生对象，并跳过第1个学生对象
		stuList.stream().filter((stu)->{
			if (stu.getSalary() > 5000) {
				return true;
			}
			return false;
		}).skip(1).forEach(System.out::println);
	}
	
	@Test
	public void test04(){
	  //需求4：过滤掉小于5000的学生对象，并筛选掉重复元素
	//底层是依据hashCode()和equals()来去判断两个对象是否相同
		stuList.stream().filter((stu)->{
			if (stu.getSalary() > 5000) {
				return true;
			}
			return false;
		}).distinct().forEach(System.out::println);
	}
}

public class Student implements Comparable<Student>{

	private String name;
	private int age;
	private double salary;
	private Course course;
	
	public Student() {
	}
	
	public Student(String name, int age, double salary, Course course) {
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.course = course;
	}



	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public Course getCourse() {
		return course;
	}

	public void setCourse(Course course) {
		this.course = course;
	}
	
	

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", salary=" + salary + ", course=" + course + "]";
	}

	@Override
	public int hashCode(){
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((course == null) ? 0 : course.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(salary);
		result = prime * result + (int)(temp ^ (temp >>> 32) );
		return result;
	}
	
	@Override
	public boolean equals(Object obj) {
		if(this == obj)
			return true;
		if(obj == null)
			return false;
		if(getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if(age != other.age)
			return false;
		if(course != other.course)
			return false;
		if (name == null) {
			if (other.name != null) 
				return false;
		} else if(!name.equals(other.name))
			return false;
		if(Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
			return false;
		return true;
	}
	@Override
	public int compareTo(Student o) {
		if(this == o){
			return 0;
		}
		if (this.age != o.age) {
			return Integer.compare(this.age, o.age);
		}
		return 1;
	}

}


public enum Course {

	JAVA,HTML,PYTHON;
}

5.中间操作 - 映射

方法描述
map(Function<?, ? > mapper)将流中所有元素映射成一个新的元素或者提取信息
flatMap(Function<?, ? extends Stream<? >> mapper)将流中的流整合（整合成平面/平铺流）
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

import org.junit.Test;

public class Test03 {
	List<String> nameList = Arrays.asList("张三","李四","王五","赵六","孙七","吴八");	

	List<Student> stuList = Arrays.asList(
			new Student("张三", 28, 4800,Course.JAVA),
			new Student("李四", 36, 7200,Course.JAVA),
			new Student("王五", 19, 9600,Course.HTML),
			new Student("赵六", 42, 6100,Course.HTML),
			new Student("孙七", 23, 9600,Course.PYTHON),
			new Student("吴八", 31, 3000,Course.PYTHON),
			new Student("李四", 36, 7200,Course.JAVA));

	@Test
	public void test01(){
		//map() - 将流中所有元素映射成一个新的元素 或者 提取信息

		//方式1：映射成一个新的元素
		//需求：将流中所有字符串拼接成新的字符串
		nameList.stream().map((str)->str.charAt(0)).forEach(System.out::println);
	}

	@Test       //重要！！！！！！！
	public void test02(){
		//方式2：映射成提取信息
		//需求：把原来流中的学生对象替换成学生姓名
		stuList.stream().map((stu)->stu.getName()).forEach(System.out::println);
	}

	@Test
	public void test03(){
		//带着需求学flatMap()
		//flatMap() - 将流中的流整合（整合成平面/平铺流）
		//需求：将nameList里的字符串转换为字符输出

		//解决方案1：使用map()完成需求，可以看到流里包含另外的流，非常麻烦
//		Stream<Stream<Character>> stream = nameList.stream().map(Test03::getCharacterStream);
//		stream.forEach((sm)->{
//			sm.forEach(System.out::println);
//		});
		
		//解决方案2：使用flatMap()完成需求，将流中的流一并整合
		nameList.stream().flatMap((str)->getCharacterStream(str)).forEach(System.out::println);
		
	}

	public static Stream<Character> getCharacterStream(String str){
		char[] charArray = str.toCharArray();
		ArrayList<Character> list = new ArrayList<>();
		for (char c : charArray) {
			list.add(c);
		}
		return list.stream();
	}
}

6.中间操作 - 排序

方法解释
sorted()使用元素原有排序规则 - Comparable
sorted(Comparator<? super T> comparator)使用自定义排序规则 - Comparator
import java.util.Arrays;
import java.util.List;

import org.junit.Test;

public class Test04 {

	List<Student> stuList = Arrays.asList(
			new Student("张三", 28, 4800,Course.JAVA),
			new Student("李四", 36, 7200,Course.JAVA),
			new Student("王五", 19, 9600,Course.HTML),
			new Student("赵六", 42, 6100,Course.HTML),
			new Student("孙七", 23, 9600,Course.PYTHON),
			new Student("吴八", 31, 3000,Course.PYTHON),
   			new Student("李四", 36, 7200,Course.JAVA));
	
	@Test
	public void test01(){
		//使用元素原有排序规则（Comparable<T>）
        //需求：按照年龄排序
		stuList.stream().sorted().forEach(System.out::println);
	}
	
	@Test
	public void test02(){
		//使用自定义排序规则（Comparator<T>）
        //需求：按照工资排序
		stuList.stream().sorted((stu1,stu2)->{
			if(stu1 == stu2){
				return 0;
			}
			if(stu1.getSalary() != stu2.getSalary()){
				return Double.compare(stu1.getSalary(), stu2.getSalary());
			}
			return 1;
		}).forEach(System.out::println);
	}
}

7.终止操作 - 匹配与查找

方法描述
allMatch(Predicate<? super T> predicate)检查是否匹配所有元素
anyMatch(Predicate<? super T> predicate)检查是否匹配至少一个元素
noneMatch(Predicate<? super T> predicate)检查是否没有匹配所有元素
findFirst()返回第一个元素
findAny()返回任意一个元素（但效果不好）
count()返回流中元素的个数
max(Comparator<? super T> comparator)返回流中最大值
min(Comparator<? super T> comparator)返回流中最小值
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

import org.junit.Test;

public class Test05 {

	List<Student> stuList = Arrays.asList(
			new Student("张三", 28, 4800,Course.JAVA),
			new Student("李四", 36, 7200,Course.JAVA),
			new Student("王五", 19, 9600,Course.HTML),
			new Student("赵六", 42, 6100,Course.HTML),
			new Student("孙七", 23, 9600,Course.PYTHON),
			new Student("吴八", 31, 3000,Course.PYTHON),
   			new Student("李四", 36, 7200,Course.JAVA));
	
	@Test
	public void test01(){
		//需求1：检查流中所有元素是否匹配 工资>5000
		boolean allMatch = stuList.stream().allMatch((stu)->{
			if (stu.getSalary() > 5000) {
				return true;
			}
			return false;
		});
		System.out.println(allMatch);
	}
	
	@Test
	public void tesst02(){
		//需求2：检查流中所有元素至少匹配一个 工资>5000
		boolean anyMatch = stuList.stream().anyMatch((stu)->{
			if (stu.getSalary() > 5000) {
				return true;
			}
			return false;
		});
		System.out.println(anyMatch);
	}
	
	@Test
	public void test03(){
		//需求3：检查流中所有元素是否没有匹配 工资>5000
		boolean noneMatch = stuList.stream().noneMatch((stu)->{
			if (stu.getSalary() > 5000) {
				return true;
			}
			return false;
		});
		System.out.println(noneMatch);
	}
	
	@Test
	public void test04(){
		//需求4：返回工资最高的学生信息
		//Optional是一个容器，该容器中存储了学生对象
		Optional<Student> max = stuList.stream().max((stu1,stu2)->{
			return Double.compare(stu1.getSalary(), stu2.getSalary());
		});
		System.out.println(max.get());
	}
	
	@Test
	public void test05(){
		//需求5：返回工资最低的学生信息
		//Optional是一个容器，该容器中存储了学生对象
		Optional<Student> min = stuList.stream().min((stu1,stu2)->{
			return Double.compare(stu1.getSalary(), stu2.getSalary());
		});
		System.out.println(min.get());
	}
	
	@Test
	public void test06(){
		//需求6：返回随机学生信息（但效果不好）
		Optional<Student> findAny = stuList.stream().findAny();
		Student stu = findAny.get();
		System.out.println(stu);
	}
	
	@Test
	public void test07(){
		//需求6：获取学生个数
		long count = stuList.stream().count();
		System.out.println(count);
	}
}
雨霖先森
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java对象创建过程
shuai的博客
12-31 245
java对象创建过程
Jdk 1.8 Lambda新特性 对象方法引用
科技之星==================>Future
09-21 254
1.创建对象方法引用业务操作类 package lambda; public final class ObjectMethodUse { public int getResult(){ return 8; } public int addResult(int a,int b){ return a+b; } public String stringConvert(int n,String str){ switch
jdk 1.8中 所创建的 实体类测试对象
qiwunongqingyin的博客
04-25 203
package lambda; import java.util.Objects; public class Person { private int id; private String name; private Integer age; private double salary; private Status status; public Person(){ } public Person(int id) {
java 瑞吉外卖day6 移动端 套餐 菜品展示 购物车加减，清空,用户下单
m0_73859807的博客
12-23 1155
@PostMapping("/add") public R add(@RequestBody ShoppingCart shoppingCart){ //获取当前线程用户的id并设置到shoppingCart中 Long currentId = BaseContext.getCurrentId(); shoppingCart.setUserId(currentId); //首先我们要判断当前购物车是否已经有同样的dish或者setmeal Lam
案例：jdk1.8函数式接口的定义和使用
诸葛小猿
03-24 1510
案例：jdk1.8函数式接口的定义和使用
jdk1.8中文文档 百度 chm
05-05
7. **新的集合工厂方法**：`Collections`和`Arrays`类增加了创建集合和数组的新方法，如`List.of()`、`Map.of()`等。 8. **改进的反射API**：提高了反射的性能和可用性，如`Class`类新增的`getDeclaredMethods()`...
jdk1.8-API中文版
08-10
在接口中，JDK 1.8引入了默认方法（default methods），接口可以在不破坏实现类的情况下添加新的方法。默认方法使用`default`关键字声明，并提供默认实现。 6. **日期与时间API的增强** JDK 1.8改进了日期和时间...
JDK1.8Linux安装包
12-12
JDK1.8是Java的一个重要版本，引入了许多新特性，如Lambda表达式、函数式编程接口、Stream API等，对提升开发效率和程序性能有着显著作用。 在Linux环境下安装JDK1.8，我们需要遵循以下步骤： 1. **下载JDK1.8...
jdk1.8 中文版api
04-27
方法引用和构造器引用是与Lambda表达式配套的新特性。它们允许直接引用已有方法或构造器，简化了代码并提高了效率。例如，`List.sort()`可以直接使用`Comparator.comparing()`方法引用，实现自定义排序。 四、默认...
linux-64位的jdk1.8版本
最新发布
04-25
JDK1.8，也被称为Java 8，是Java编程语言的一个重大更新，引入了许多新特性，如Lambda表达式、函数式编程接口、默认方法以及改进的Date/Time API等。对于Linux系统，尤其是64位架构的系统，选择合适的JDK版本至关...
jdk1.8——函数式接口
FlyLikeButterfly的博客
01-07 492
jdk8函数式接口
JDK1.8新特性---Lambda表达式
Mr.Cui的Java学习之路
09-18 1450
JDK1.8新特性---Lambda表达式
SpringBoot表单验证
weixin_40455265的博客
09-30 1017
限制 说明 @Null 限制只能为null @NotNull 限制必须不为null @AssertFalse 限制必须为false @AssertTrue 限制必须为true @DecimalMax(value) 限制必须为一个不大于指定值的数字 @DecimalMin(
jdk1.8新特性
码码码码码码农的博客
04-22 369
1.jdk1.8新特性 JDK1.8相比1.7之前版本，有以下几方面的优化： 速度更快； 代码更少(Lambda表达式)； 强大Stream API； 便于并行； 最大化减少空指针异常(OPtional类)。 新特性 JDK1.8新增了非常多的特性，最主要的包括以下几个方面： Lambda表达式：Lambda允许把函数作为一个方法的参数（函数作为参数传递到方法中）。 方法引用：方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语
jdk1.8 集合
weixin_45281605的博客
11-04 366
//差集（从旧对象中找出新对象没有的数据，即删除） List delPaylist = oldList.stream() .filter(item -> !newList.stream().map(e -> e.getId()).collect(Collectors.toList()).contains(item.getId())) .collect(Collectors.toList()); //取出某个属性值封装集合 userList=list.stream().map(UserConver
Java 1.8新特性 lambda表达式 函数式接口
qq_43382750的博客
07-26 187
Java 1.8新特性 lambda表达式 函数式接口 lambda表达式 lambda表达式是一种没有名字的函数,可称闭包和箭头函数等,它是Java8发布的最重要新特性,本质上是一段匿名内部类,也可以是一段可传递的代码,是匿名内部类的简写,代码更加简洁. 语法结构 参考匿名内部类在方法小括号类型后面 (参数,参数,参数…)->{方法体} 1 原方法无参和多参,上面的小括号必须写 2 只有一个参数的时候,可以不写小括号() 3 如果只有一条语句,大括号{}可以不写,并且结尾不用分号; 4
java中的接口（jdk1.8）与抽象类
哈喽羊
08-02 4272
主意：本文部分内容cv至：https://www.cnblogs.com/dolphin0520/p/3811437.html#，但本文更正了接口方法中的部分错误和修改了部分内容，特此申明!   一.抽象类 　　在了解抽象类之前，先来了解一下抽象方法。抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法的声明格式为： abstract void fun(); 抽象方法必须用...
JDK1.8接口的默认实现
热门推荐
Crazy.Mark
03-31 1万+
很多时候，别人问我接口和类的区别的时候，我都会回答接口里面只能有抽象方法，而不能够有具体方法，但是今天看Mybatis源码的时候，发现了有一段代码是判断接口里面的默认方法的，于是我发现原来对接口的认识太过于肤浅了。 JDK1.8之后，在接口里面可以定义default方法，default方法里面是可以具备方法体的，当子类实现该接口之后，不需要重写该方法即可以调用该方法。 ok，看看代码 /...
jdk1.8之--接口
gantianxing的博客
03-08 1464
jdk1.8对java接口的定义添加了新特性，比如可以有默认的实现方法，以及静态方法（或者称为类方法）。这里对java在jdk1.8中的相关特性，以及使用方法做个简单的总结。接口用法以及注意事项首先来看一个简单的例子：public interface RenderService {   //默认为public static final   int pc_page = 0;   //默认为publi...
JDK1.8新特性详解：Lambda、Stream API与时间日期API
"本文概述了JDK1.8的关键特性，包括Lambda表达式、函数式接口、方法引用和构造器调用、Stream API、接口的默认方法和静态方法以及新时间日期API。此外，还讨论了JDK1.8对HashMap数据结构的优化，引入了红黑树以提高...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雨霖先森

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值