Java基础：Optional类和lambda表达式

最新推荐文章于 2023-05-09 16:55:05 发布

Camellia0212

最新推荐文章于 2023-05-09 16:55:05 发布

阅读量749

点赞数

本文链接：https://blog.csdn.net/DoYouThinkAMe/article/details/118192522

版权

Optional类：为了在程序中避免出现空指针异常而创建的。

常用的方法：
ofNullable(T t)
orElse(T t)


Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
Optional.empty() : 创建一个空的 Optional 实例
Optional.ofNullable(T t)：t可以为null

Optional.of(对象)：对象不能为空

    public void test1(){
        Girl girl = new Girl();
        //girl = null;
        //of(T t):保证t是非空的
        Optional<Girl> optionalGirl = Optional.of(girl);
        System.out.println(optionalGirl);
    }

Optional.ofNullable(T t)和Optional.orElse(T t)的使用

    public void test2(){
        Girl girl = new Girl();
        girl = null;
        //ofNullable(T t)：t可以为null
        Optional<Girl> optionalGirl = Optional.ofNullable(girl);
        System.out.println(optionalGirl);
        //orElse(T t1):如果单前的Optional内部封装的t是非空的，则返回内部的t.
        //如果内部的t是空的，则返回orElse()方法中的参数t1.
        Girl girl1 = optionalGirl.orElse(new Girl("古力娜扎"));
        System.out.println(girl1);


        Girl girl2 = new Girl("迪丽热巴");
        Optional<Girl> optionalGirl2 = Optional.ofNullable(girl2);
        System.out.println(optionalGirl2);
        Girl orElse = optionalGirl2.orElse(new Girl("古力娜扎"));
        System.out.println(orElse);
    }

lambda表达式和方法引用

   @Test
    public void test2(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        int compare1 = com1.compare(12,21);
        System.out.println(compare1);

        //lambda表达式的解法
        Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1, o2);
        int compare2 = com2.compare(34,43);
        System.out.println(compare2);

        //方法引用
        Comparator<Integer> com3 = Integer :: compare;
        int compare3 = com3.compare(34,43);
        System.out.println(compare3);

    }

lambda表达式的说明

    Lambda表达式的使用

    1.举例：(o1,o2) -> Integer.compare(o1,o2);
    2.格式：
        -> :lambda操作符 或 箭头操作符
        ->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）
        ->右边：lambda体（其实就是重写的抽象方法的方法体）

    3.Lambda表达式的使用：（分为6种情况介绍）
        总结：
       ->左边：lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只有一个参数，其一对()也可以省略
       ->右边：lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句（可能是return语句），省略这一对{}和return关键字

    4.lambda表达式的本质：作为接口的实例

lambda语法格式一：无参、无表达式

//普通方式
Runnable r1 = new Runnable(){
    @Override
    public void run() {
        System.out.println("我爱北京天安门");
    }
};
r1.run();

//lambda表达式
Runnable r2 = () -> {System.out.println("我爱北京故宫");};
r2.run();

lambda语法格式二：Lambda 需要一个参数，但没有返回值

//普通方式
//Consumer是java提供的一个类：accept是Consumer的一个方法
Consumer<String> con = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};
con.accept("我干尼玛啊！");

//lambda表达式方法
Consumer<String> con1 = (String s) -> {System.out.println(s);};
con1.accept("我也...");

语法格式三；数据类型可以省略，因为可由编译器推断得出，称为”类型推断“

//普通方式
Consumer<String> con = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};
con.accept("我干尼玛啊！");

//lambda表达式方式
Consumer<String> con1 = (s) -> {System.out.println(s);};
con1.accept("我也...");

语法格式4：Lambda 若只需要一个参数时，参数的小括号可以省略

//普通方式
Consumer<String> con = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};
con.accept("我干尼玛啊！");

//lambda表达式方式
Consumer<String> con1 = s -> {System.out.println(s);};
con1.accept("我也...");

语法格式5：Lambda 需要两个或以上的参数，多条执行语句，并且有返回值


//普通形式
   Comparator<Integer> con = new Comparator<Integer>() {
       @Override
       public int compare(Integer o1, Integer o2) {
           System.out.println(o1);
           System.out.println(o2);
           return o1.compareTo(o2);
       }
   };

//lambda表达式形式
   Comparator<Integer> con1 = (o1,o2) -> {
       System.out.println(o1);
       System.out.println(o2);
       return o1.compareTo(o2);
   };

   int compare = con1.compare(123, 24);
   System.out.println(compare);

语法格式6：Lambda 体只有一条语句时，return 与大括号若有，都可以省略


Comparator<Integer> con = new Comparator<>(){
	 @Override
	 public int compareTo(Integer o1,Integer o2){
	 	return o1.compareTo(o2);
	 }
}
		

//lambda表达式方式
 Comparator<Integer> con = (o1,o2)->o1.compareTo(o2);
 int compare = con.compare(213, 242);
 System.out.println(compare);

引用和lambda在构造器中的使用:Supplier.get():空参构造器

	//构造器引用
    //Supplier中的T get()
    //Employee的空参构造器：Employee()
    @Test
    public void test1(){
		//普通方式
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println("*******************");
		//lambda表达式方式
        Supplier<Employee>  sup1 = () -> new Employee();
        System.out.println(sup1.get());

        System.out.println("*******************");
		//方法引用
        Supplier<Employee>  sup2 = Employee :: new;
        System.out.println(sup2.get());
    }

引用和lambda在构造器中的使用:Function.apply()：一个参数的构造器

	//Function中的R apply(T t)
    @Test
    public void test2(){
        //普通方式
        Function<Integer,Employee> func = new Function<Integer, Employee>() {
            @Override
            public Employee apply(Integer id) {
                return new Employee(id);
            }
        };
        Employee apply = func.apply(1000);
        System.out.println(apply);

        //lambda表达式方式
        Function<Integer,Employee> func1 = id -> new Employee(id);
        Employee employee = func1.apply(1001);
        System.out.println(employee);

        System.out.println("*******************");

        //引用表达式方式
        Function<Integer,Employee> func2 = Employee :: new;
        Employee employee1 = func2.apply(1002);
        System.out.println(employee1);

    }

引用和lambda在构造器中的使用:BiFunction.apply()：两个参数的构造器

	//BiFunction中的R apply(T t,U u)
    @Test
    public void test3(){
        //普通方式
        BiFunction<Integer,String,Employee> func = new BiFunction<Integer, String, Employee>() {
            @Override
            public Employee apply(Integer id, String name) {
                return new Employee(id,name);
            }
        };
        System.out.println(func.apply(1000, "tom"));
        
        System.out.println("*******************");
        //lambda表达式方式
        BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
        System.out.println(func1.apply(1001,"Tom"));

        System.out.println("*******************");
        //方法引用方式
        BiFunction<Integer,String,Employee> func2 = Employee :: new;
        System.out.println(func2.apply(1002,"Tom"));

    }

引用和lambda在构造器中的使用:Function.apply(T t)：多个参数的构造器

	//数组引用
    //Function中的R apply(T t)
    @Test
    public void test4(){
       Function<Integer,String[]> func = new Function<Integer, String[]>() {
            @Override
            public String[] apply(Integer length) {
                return new String[length];
            }
        };
        String[] apply = func.apply(5);
        System.out.println(Arrays.toString(apply));

		System.out.println("*******************");
		
        Function<Integer,String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));

        System.out.println("*******************");

        Function<Integer,String[]> func2 = String[] :: new;
        String[] arr2 = func2.apply(10);
        System.out.println(Arrays.toString(arr2));

    }

方法引用的使用情况一：对象 :: 实例方法

	// 情况一：对象 :: 实例方法
	//Consumer中的void accept(T t)
	//PrintStream中的void println(T t)
	@Test
	public void test1() {
		//普通方式：
		Consumer<String> con = new Consumer<String>() {
			@Override
			public void accept(String s) {
				System.out.println(s);
			}
		};
		con.accept("普通方式");
		
		System.out.println("*******************");
		
		//lambda表达式
		Consumer<String> con1 = str -> System.out.println(str);
		con1.accept("北京");
		
		System.out.println("*******************");
		
		//引用方式
		PrintStream ps = System.out;
		Consumer<String> con2 = ps::println;
		con2.accept("beijing");
	}

	//Supplier中的T get()
	//Employee中的String getName()
	@Test
	public void test2() {
		//普通形式
		Employee emp = new Employee(1001,"Tom",23,5600);
		Supplier<String> sup = new Supplier<String>() {
			@Override
			public String get() {
				return emp.getName();
			}
		};
		System.out.println(sup.get());
		
		System.out.println("*******************");

		//lambda接口
		//Supplier.get获取一个对象
		Supplier<String> sup1 = () -> emp.getName();
		System.out.println(sup1.get());

		System.out.println("*******************");
		//引用方式
		Supplier<String> sup2 = emp::getName;
		System.out.println(sup2.get());

	}

方法引用的情况二：类 :: 静态方法


	//Comparator中的int compare(T t1,T t2)
	//Integer中的int compare(T t1,T t2)
	@Test
	public void test3() {
		Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
		System.out.println(com1.compare(12,21));

		System.out.println("*******************");

		Comparator<Integer> com2 = Integer::compare;
		System.out.println(com2.compare(12,3));

	}

	//Function中的R apply(T t)
	//Math中的Long round(Double d)
	@Test
	public void test4() {
		Function<Double,Long> func = new Function<Double, Long>() {
			@Override
			public Long apply(Double d) {
				return Math.round(d);
			}
		};

		System.out.println("*******************");

		Function<Double,Long> func1 = d -> Math.round(d);
		System.out.println(func1.apply(12.3));

		System.out.println("*******************");

		Function<Double,Long> func2 = Math::round;
		System.out.println(func2.apply(12.6));
	}

方法引用的情况三：类 :: 实例方法 (有难度)


	// Comparator中的int comapre(T t1,T t2)
	// String中的int t1.compareTo(t2)
	@Test
	public void test5() {
		Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
		System.out.println(com1.compare("abc","abd"));

		System.out.println("*******************");

		Comparator<String> com2 = String :: compareTo;
		System.out.println(com2.compare("abd","abm"));
	}

上面构造器引用中所用到的类

public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	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 Employee() {
		System.out.println("Employee().....");
	}

	public Employee(int id) {
		this.id = id;
		System.out.println("Employee(int id).....");
	}

	public Employee(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public Employee(int id, String name, int age, double salary) {

		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	@Override
	public String toString() {
		return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
	}

	@Override
	public boolean equals(Object o) {
		if (this == o)
			return true;
		if (o == null || getClass() != o.getClass())
			return false;

		Employee employee = (Employee) o;

		if (id != employee.id)
			return false;
		if (age != employee.age)
			return false;
		if (Double.compare(employee.salary, salary) != 0)
			return false;
		return name != null ? name.equals(employee.name) : employee.name == null;
	}

	@Override
	public int hashCode() {
		int result;
		long temp;
		result = id;
		result = 31 * result + (name != null ? name.hashCode() : 0);
		result = 31 * result + age;
		temp = Double.doubleToLongBits(salary);
		result = 31 * result + (int) (temp ^ (temp >>> 32));
		return result;
	}
}

public class EmployeeData {
	
	public static List<Employee> getEmployees(){
		List<Employee> list = new ArrayList<>();
		
		list.add(new Employee(1001, "马化腾", 34, 6000.38));
		list.add(new Employee(1002, "马云", 12, 9876.12));
		list.add(new Employee(1003, "刘强东", 33, 3000.82));
		list.add(new Employee(1004, "雷军", 26, 7657.37));
		list.add(new Employee(1005, "李彦宏", 65, 5555.32));
		list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
		list.add(new Employee(1007, "任正非", 26, 4333.32));
		list.add(new Employee(1008, "扎克伯格", 35, 2500.32));
		
		return list;
	}
	
}

Camellia0212

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java基础：Optional类和lambda表达式

Optional类：为了在程序中避免出现空指针异常而创建的。常用的方法：ofNullable(T t)orElse(T t)Optional.of(T t) : 创建一个 Optional 实例，t必须非空；Optional.empty() : 创建一个空的 Optional 实例Optional.ofNullable(T t)：t可以为nullOptional.of(对象)：对象不能为空 public void test1(){ Girl girl = new
复制链接

扫一扫