记Java8新特性的学习(一)---lambda表达式基本使用

一:Lamdba表达式使用及介绍:

Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

格式:

(parameters) -> expression
或
(parameters) ->{ statements; }

 

以下是lambda表达式的重要特征:

  • 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值。
  • 可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
  • 可选的大括号:如果主体包含了一个语句,就不需要使用大括号。
  • 可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定明表达式返回了一个数值

二:Lambda 表达式实例

2.1 参数说明

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

 2.2 接口参数Lamdba调用说明

package com.atguigu.lamdba;

/**
 * 接口类  
 * 通过Lambda表达式可以便捷实现接口的具体实现
 */
public class Java8Tester {

    interface MathOperation {
        int operation(int a, int b);
    }

    interface GreetingService {
        void sayMessage(String message);
    }

    public int operate(int a, int b, MathOperation mathOperation){
        return mathOperation.operation(a, b);
    }
}

  

public class Main {
    public static void main(String args[]){
        Java8Tester tester = new Java8Tester();
        /**
         * Lamdba表达式可以简便的实现接口作为函数
         * 以下为接口的实现,使用Lamdba可以便捷声明接口的实现方法
         */
        // 类型声明   算数+法
        Java8Tester.MathOperation addition = (int a, int b) -> a + b;

        // 不用类型声明   算数-法
        Java8Tester.MathOperation subtraction = (a, b) -> a - b;

        // 大括号中的返回语句    算数*法   -标准写法  -当然我们有时为了简便 类型有时候很明显时可以省略
        Java8Tester.MathOperation multiplication = (int a, int b) -> { return a * b; };

        // 没有大括号及返回语句  算数/法
        Java8Tester.MathOperation division = (int a, int b) -> a / b;

        System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
        System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
        System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
        System.out.println("10 / 5 = " + tester.operate(10, 5, division));

        // 不用括号
        Java8Tester.GreetingService greetService1 = message ->
                System.out.println("Hello " + message);

        // 用括号
        Java8Tester.GreetingService greetService2 = (message) ->
                System.out.println("Hello " + message);

        greetService1.sayMessage("Runoob");
        greetService2.sayMessage("Google");
    }
}

 我们可以看到,通过接入Lamdba表达式,可以非常便捷的实现策略模式。做一事所需要的不同实现,可以很方便的展示。

   下面是一个进阶的例子,对比lamdba使用前后内容

	//原来的匿名内部类
	@Test
	public void test1(){
		Comparator com = new Comparator(){
			@Override
			public int compare(String o1, String o2) {
				return Integer.compare(o1.length(), o2.length());
			}
		};
		
		TreeSet ts = new TreeSet<>(com);
		
		TreeSet ts2 = new TreeSet<>(new Comparator(){
			@Override
			public int compare(String o1, String o2) {
				return Integer.compare(o1.length(), o2.length());
			}
			
		});
	}
	
	//现在的 Lambda 表达式
	@Test
	public void test2(){
		Comparator com = (x, y) -> Integer.compare(x.length(), y.length());
		TreeSet ts = new TreeSet<>(com);
	}
	
	List emps = Arrays.asList(
			new Employee(101, "张三", 18, 9999.99),
			new Employee(102, "李四", 59, 6666.66),
			new Employee(103, "王五", 28, 3333.33),
			new Employee(104, "赵六", 8, 7777.77),
			new Employee(105, "田七", 38, 5555.55)
	);

	//需求:获取公司中年龄小于 35 的员工信息
	public List filterEmployeeAge(List emps){
		List list = new ArrayList<>();
		
		for (Employee emp : emps) {
			if(emp.getAge() <= 35){
				list.add(emp);
			}
		}
		
		return list;
	}
	
	@Test
	public void test3(){
		List list = filterEmployeeAge(emps);
		
		for (Employee employee : list) {
			System.out.println(employee);
		}
	}
	
	//需求:获取公司中工资大于 5000 的员工信息
	public List filterEmployeeSalary(List emps){
		List list = new ArrayList<>();
		
		for (Employee emp : emps) {
			if(emp.getSalary() >= 5000){
				list.add(emp);
			}
		}
		
		return list;
	}
	
	//优化方式一:策略设计模式
	public List filterEmployee(List emps, MyPredicate mp){
		List list = new ArrayList<>();
		
		for (Employee employee : emps) {
			if(mp.test(employee)){
				list.add(employee);
			}
		}
		
		return list;
	}
	
	@Test
	public void test4(){
		List list = filterEmployee(emps, new FilterEmployeeForAge());
		for (Employee employee : list) {
			System.out.println(employee);
		}
		
		System.out.println("------------------------------------------");
		
		List list2 = filterEmployee(emps, new FilterEmployeeForSalary());
		for (Employee employee : list2) {
			System.out.println(employee);
		}
	}
	
	//优化方式二:匿名内部类
	@Test
	public void test5(){
		List list = filterEmployee(emps, new MyPredicate() {
			@Override
			public boolean test(Employee t) {
				return t.getId() <= 103;
			}
		});
		
		for (Employee employee : list) {
			System.out.println(employee);
		}
	}
	
	//优化方式三:Lambda 表达式
	@Test
	public void test6(){
		List list = filterEmployee(emps, (e) -> e.getAge() <= 35);
		list.forEach(System.out::println);
		
		System.out.println("------------------------------------------");
		
		List list2 = filterEmployee(emps, (e) -> e.getSalary() >= 5000);
		list2.forEach(System.out::println);
	}
	

  

你可能感兴趣的:(记Java8新特性的学习(一)---lambda表达式基本使用)