JAVA之Lambda的使用

必须是函数式接口才可以使用Lambda

函数式接口：内部只有一个方法。

lambda表达式，其实本质来讲，就是⼀个匿名函数。因此在写lambda表达式的时候，不需要关心方法名是什么。

实际上，我们在写lambda表达式的时候，也不需要关心返回值类型。

我们在写lambda表达式的时候，只需要关注两部分内容即可：参数列表和方法体

lambda表达式的基础语法：
(参数1,参数2,…) -> {
方法体
};

参数部分：方法的参数列表，要求和实现的接口中的方法参数部分⼀致，包括参数的数量和类型。

方法体部分 ： 方法的实现部分，如果接口中定义的方法有返回值，则在实现的时候，注意返回值的返回。

-> : 分隔参数部分和方法体部分。

用Lambda表达式实现接口

public class Test04 {
    public static void main(String[] args) {
        //使用lambda表达式实现接口
        Test test = () -> {
            System.out.println("test");
        };
        test.test();
    }
}

interface Test{
    public void test();
}

 2.格式说明：
                - 小括内的语法与传统方法参数列表一致，没有参数就留空，有多个参数就用逗号分隔

                -  【->】  是新引入的语法格式，代表指向动作

                - 大括号内的语法与传统方法体要求一致

市场非常AV

package atest;

import java.util.Arrays;
import java.util.Comparator;


public class pratise2 {
//内部类
//	static class StudentCompare implements Comparator<Student>{
//		public int compare(Student o1, Student o2) {
//			
//			return o1.name.length() - o2.name.length();//正序
//			
//		}
//	}
	public static void main(String[] args) {
/*		class StudentCompare implements Comparator<Student>{
			public int compare(Student o1, Student o2) {
				
				return o1.name.length() - o2.name.length();//正序				
			}
		}*/
		Student[] s = new Student[4];
		s[0] = new Student();
		s[0].age = 17;
		s[0].name = "lucy";
		s[1] = new Student();
		s[1].age = 18;
		s[1].name = "tom";
		s[2] = new Student();
		s[2].age = 19;
		s[2].name = "danny";
		s[3] = new Student();
		s[3].age = 20;
		s[3].name = "jan";
		Arrays.sort(s);
		for(Student student :s) {
			System.out.println(student.age);
		}
		
/*		Arrays.sort(s,new StudentCompare());
		for(Student student :s) {
			System.out.println(student.name);
		}*/
//函数
		
/*		Arrays.sort(s,new Comparator<Student>() {
			public int compare(Student o1, Student o2) {
							
							return o1.name.length() - o2.name.length();//正序				
						}
			
		});*/
		Arrays.sort(s,(o1,o2)->{return o1.name.length() - o2.name.length();});
		for(Student student :s) {
			System.out.println(student.name);
		}
		
	}
	
	
}
class Student implements Comparable<Student>{
	String name;
	int age;
	
	@Override
	public int compareTo(Student o) {//0相等  正数--正序  负数--倒序
		  
		//return o.age - age;
		return age - o.age;
	}
}

//class StudentCompare implements Comparator<Student>{
//	public int compare(Student o1, Student o2) {
//		
//		return o1.name.length() - o2.name.length();//正序
//		
//	}
//}

Lambada表达式

统调用借口中的方法就可以调用｛

｝中所有的东西

public class LambadaTest {
/*    （2）静态内部类
    static class Like implements  ILike{
        @Override
        public void lambda() {
            System.out.println("我是Lambda");
        }
    }*/

    public static void main(String[] args) {
        /*(3)局部内部类
        class Like implements  ILike{
            @Override
            public void lambda() {
                System.out.println("我是Lambda");
            }
        }*/

/*        Like bh=new Like();
        ILike il=new Like();*/

        //(4）匿名内部类
/*         like=new ILike(){

            @Override
            public void lambda() {

            }
        };*/
        //Lambada 表达式
        ILike like=()->{
            System.out.println("Lambada表达式");
        };
        like.lambda();


        /*il.lambda();*/

    }


}

interface ILike{
    void lambda();
}
/*
（1）
class Like implements  ILike{
    @Oerride
    public void lambda() {
        System.out.println("我是Lambda");
    }
}*/

简单一点来说就是不用建类  直接new 接口

ILike like=new ILike() {

            @Override
            public void lambda(int a) {

            }
        };

然后自new开始删除 直到方法名  加上->即可

ILike like=(int a)-> {
            System.out.println("zhilishi"+a);
        };

那么我们是否可以继续简化呢

//仅有一行时才可以简化  有多行只能用花括号
like=a -> System.out.println(a);