JDK1.8新特性-lambda表达式

jdk1.8新特性

一、jdk1.8新特性之lambda表达式

我们先来看一段代码，再来分析lambda表达式

@Test
	public void test1() {
		// Runnable接口是一个函数式接口，最常规的实例化方式即匿名实现类的
		Runnable runnable=new Runnable() {

			@Override
			public void run() {
				// TODO 自动生成的方法存根
				System.out.println("我爱北京天安门");
			}
			
		};
		runnable.run();
		// 使用lambda表达式实例化
		Runnable running=()->System.out.println("我爱福建厦门");
		running.run();
	}

什么是lambda表达式？

就是函数式接口的实例，可能有人就会问什么是函数式接口？即接口中只声明了一个抽象方法的接口就称为函数式接口，例如Comparable接口

怎么使用lambda表达式？

首先，就需要了解lambda表达式中的结构

->:lambda操作符

():lambda的参数列表，与实现接口方法的参数列表一致

{}:lambda体，与实现接口方法的方法体一致

为什么可以这样写呢？原因是因为lambda表达式是函数式接口中的实例，函数式接口就一个抽象方法需要实现其实就可以不用写，只需要写参数列表和方法体即可，简化了代码量，使代码看起来更简洁明了。当然，也增加了一些难度。

lambda表达式使用规则：

1.对于lambda参数列表，可以根据类型推断省略数据类型

@Test
	public void test2() {
		//类型推断
		List<String> list=new ArrayList<>(); 
		// 本来ArrayList后面的泛型中要写String但是可以根据前面的数据类型推断出来，所以可以省略，
		// 这就叫做类型推断
		// Predicate  boolean Test(T t)
		Predicate pre=new Predicate() {

			@Override
			public boolean test(Object t) {
				// TODO 自动生成的方法存根
				return false;
			}
			
		};
		// lambda表达式
		Predicate<String> pre1=(s)->{
			if("abc".equals(s)) {
				return true;
			}else
				return false;
		};
	}

2.若lambda的参数列表只有一个参数，则省略一对"()"

@Test
	public void test3() {
		// 类型推断省略数据类型，只有一个参数省略()
		Predicate<String> pre=str->{
			return str.contains("abc");
		};
	}

3.若lambda体中只有一句执行语句(可以是return语句)，则省略{}。若为return语句，则省略{}和return关键字

//lambda体只有一句执行语句且为return语句，省略{}和return
		Predicate<String> pre1=str->str.contains("abc");

4.对于lambda参数列表，两个或者两个以上再或者没有参数需要用括号包住

   对于lambda体，有多条执行语句必须用一对{}包住

@Test
	public void test4() {
		Comparator<String> com=new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				// TODO 自动生成的方法存根
				return 0;
			}	
		};
		// lambda
		Comparator<String> com1=(s1,s2)->{
			System.out.println("s1>s2 return 1");
			System.out.println("s1=s2 return 0");
			System.out.println("s1<s2 return -1");
			return s1.compareTo(s2);
		};
	}

lambda表达式使用规则总结：

1.数据类型可以直接省略

2.一个参数省略()，没有参数或者两个参数一个必须有()

3.lambda体中只有一条执行语句(可以是return语句)，若不是return语句省略{}，若为return语句省略{}和return。多条执行语句必须有{}

二、方法引用

方法引用也是函数式接口的实例

使用前提：引用的方法必须和接口的抽象方法具有相同的返回值类型和参数列表

怎么使用方法引用？

1.对象::方法名

@Test
	public void test1() {
		//1.无参无返回值
		// Consumer void accept(T t)
		// PrintStream  void println(T t)
		PrintStream ps=System.out;
		Consumer con=new Consumer() {
			@Override
			public void accept(Object t) {
				// TODO 自动生成的方法存根
				ps.println(t);
			}
		};
		con.accept("我爱北京天安门");
		// 方法引用 对象
		Consumer con1=ps::println;
		con1.accept("我爱福建厦门");
	}

2.类::静态方法

@Test
	public void test2() {
		// Comparator int compare(T t1,T t2)
		// Integer int compare(T t1,T t2)
		Comparator com=new Comparator() {

			@Override
			public int compare(Object o1, Object o2) {
				// TODO 自动生成的方法存根
				return 0;
			}
			
		};
		// lambda
		Comparator<Integer> com1=(t1,t2)->Integer.compare(t1, t2);
		System.out.println(com1.compare(12, 22));
		// 方法引用 类名::静态方法
		Comparator<Integer> com2=Integer::compare;
		System.out.println(com2.compare(22, 12));
	}

3.类::非静态方法

@Test
	public void test3() {
		//Comparator int compare(T t1,T t2)
		//Integer int t1.compareTo(T t2)
		Comparator<Integer> com=(t1,t2)->t1.compareTo(t2);
		System.out.println(com.compare(12, 12));
		//类::非静态方法
		Comparator<Integer> com1=Integer::compareTo;
		System.out.println(com1.compare(18, 12));
	}

三、构造器引用

 

// 构造器引用
		// Supplier T get()  适合于无参构造函数
		Supplier sup=Employee::new;
		System.out.println(sup.get().toString());
	    //BiFunction
		BiFunction<Integer,String,Employee> fun=Employee::new;
		System.out.println(fun.apply(1001, "小明"));

 

四、数组引用

@Test
	public void test2() {
		//数组引用
		//Function R apply(T t)
		Function<Integer,String[]> fun1=l->new String[l];
		Function<Integer,String[]> fun=String[]::new;
		System.out.println(Arrays.toString(fun.apply(5)));
		
	}

 五、设计模式之观察者模式

这里只是进行一个代码的手撕，推荐看这个

设计模式（五）观察者模式_BATcoder - 刘望舒-CSDN博客_观察者模式

public class ObserverPattern {
		@Test
		public void test1() {
			Observer o1=new WechatUser("张三");
			Observer o2=new WechatUser("李四");
			Observer o3=new WechatUser("王五");
			Subject s1=new WechatOfficialAccount();
			s1.attach(o1);
			s1.attach(o2);
			s1.attach(o3);
			s1.notifyUser();
		}
}
// 抽象订阅者
interface Observer{
	void update(String message);
}
// 具体订阅者
class WechatUser implements Observer{
	private String name;
	
	WechatUser(String name){
		this.name=name;
	}
	
	@Override
	public void update(String message) {
		// TODO 自动生成的方法存根
		System.out.println(name+"-"+message);
	}
}
//抽象发布者
interface Subject{
	void attach(Observer o); //添加订阅用户
	void disattach(Observer o); //删除订阅用户
	void notifyUser(); //通知方法
	void setChanged();
}
class WechatOfficialAccount implements Subject{
	
	private List<Observer> list=new ArrayList<>();
	@Override
	public void attach(Observer o) {
		// TODO 自动生成的方法存根
		list.add(o);	
	}

	@Override
	public void disattach(Observer o) {
		// TODO 自动生成的方法存根
		list.remove(o);
	}

	@Override
	public void notifyUser() {
		// TODO 自动生成的方法存根
		for(Observer o:list) {
			o.update("今天兰州新增6例新冠病毒");
		}
	}

	@Override
	public void setChanged() { //可以对更新的方法设置时间间隔
		// TODO 自动生成的方法存根
		notifyUser();
	}
	
}