JavaDay25学习总结

一、笔记

Lambda表达式
1、是对匿名内部类对象的一种简化写法
2、java8中引入了一个新的操作符”->”，叫做箭头操作符，Lambda操作符
3、箭头操作符，将表达式分隔成两部分
4、左边：表示的Lambda表达式的参数列表
5、右边：表示的是方法的方法体，Lambda体
6、语法格式1：没有参数，也没有返回值
() -> System.out.println(“Hello Lambda”);
7、语法格式2：有一个参数，没有返回值
(x)->System.out.println(x);
说明：如果只有一个参数，那么前面的小括号可以不写
x -> System.out.println(x);
8、语法格式3：有两个参数，没有返回值
(x, y) -> System.out.println(x + “…” + y);
9、语法格式4：lambda体有多句，需要在多句话外面加上大括号
x -> {
System.out.println(x);
System.out.println(x + “…”);
}
10、语法格式5：如果Lambda体只有一句，那么大括号和return关键字都可以省略
x -> x * x;
11、注意事项:
使用lambda表达式的前提条件：接口中只有一个抽象方法
如果在一个接口中只有一个抽象，称这种接口为：函数式接口
使用注解：@FunctionalInterface，检查当前接口是否是函数式接口。

代码示例1

public class Demo08_Lambda表达式1 {

	public static void main(String[] args) {
		Inter1 i1 = new Inter1() {
			@Override
			public void test() {
				System.out.println("Hello NoName innerClass!!");
			}
		};
		i1.test();
		
		Inter1 i2 = () -> System.out.println("Hello Lambda");
		i2.test();
	}
}

interface Inter1 {
	public abstract void test();
}

代码示例2

public class Demo09_Lambda表达式2 {

	public static void main(String[] args) {
		Inter2 i1 = new Inter2() {
			@Override
			public void test(String x) {
				System.out.println(x);
			}
		};
		i1.test("Hello Noname innerclass");
		
		Inter2 i2 = qq -> System.out.println(qq);
		i2.test("Hello Lambda");
	}
}

interface Inter2 {
	public abstract void test(String x);
}

代码示例3

public class Demo10_Lambda表达式3 {

	public static void main(String[] args) {
		Inter3 i1 = new Inter3() {
			@Override
			public void test(int x) {
				System.out.println(x);
				System.out.println(x + "...");
			}
		};
		i1.test(666);
		
		Inter3 i2 = x -> {
			System.out.println(x);
			System.out.println(x + "...");
		};
		i2.test(888);
	}

}

interface Inter3 {
	public abstract void test(int x);
}

代码示例4

public class Demo11_Lambda表达式4 {
	public static void main(String[] args) {
		Inter4 i1 = new Inter4() {
			@Override
			public int op(int x) {
				x = x + 1;
				return x * x;
			}
		};
		System.out.println(i1.op(5));
		
		Inter4 i2 = x -> {
			x = x + 1;
			return x * x;
		};
		System.out.println(i2.op(5));
		
		Inter4 i3 = x -> x * x;
		System.out.println(i3.op(5));
	}
}
@FunctionalInterface
interface Inter4 {
	public abstract int op(int x);
}

函数式接口
函数式接口概述

1、lambda表达式使用的前提，就是接口必须是一个函数式接口。
2、函数式接口：
 	在接口中，如果只有一个方法，那么这种接口就是函数式接口
3、用注解来检查当前的接口是否是函数式接口：
 	@FunctionalInterface
 	如果不是函数式接口，就编译报错
4、作用：
 	想表达的是一个方法的内容，需要把这个方法传递到其他需要这个方法的位置
 	Java中不能将方法当做一个数据，不能作为方法的参数进行传递，也不能作为对象的成员变量存在。
 	只能在方法外加一层接口的声明

常用内置函数式接口

1、Consumer<T> ：消费型接口
 	 	void accept(T t);
2、Supplier<T> ：供给型接口
 	 	T get();
1、Function<T, R>：函数型接口
 		R Apply(T t)
2、Predicate<T>：断言型接口
 		boolean test(T t)

代码示例1

public class Demo12_函数式接口_消费性接口 {

	public static void main(String[] args) {
		happy(8000, x -> System.out.println("班长喜欢大宝剑，每次消费" + x + "元"));
	}
	
	public static void happy(int money, Consumer<Integer> con) {
		con.accept(money);
	}

}

代码示例2

ublic class Demo13_函数式接口_供给型接口 {

	public static void main(String[] args) {
//		List<Integer> list = getNumList(10, () -> {
//			Random rd = new Random();
//			int x = rd.nextInt(31) + 20;
//			return x;
//			
//		});
		List<Integer> list = getNumList(10, () -> new Random().nextInt(31) + 20);
		System.out.println(list);
	}
	
	public static List<Integer> getNumList(int num, Supplier<Integer> sup) {
		List<Integer> list = new ArrayList<>();
		for(int i = 1; i <= num; i++) {
			list.add(sup.get());
		}
		return list;
	}

}

代码示例3

public class Demo14_函数式接口_函数型接口 {

	public static void main(String[] args) {
		//调用strHandler方法，将字符串两端的空格删除
		String result = strHandler("\t\t\t我优就业威武   ！  ", x -> x.trim());
		System.out.println(result);
	}
	
	public static String strHandler(String str, Function<String, String> fun) {
		return fun.apply(str);
	}

}

代码示例4

public class Demo15_函数式接口_断言型接口 {

	public static void main(String[] args) {
		List<String> list = Arrays.asList("Hello", "www", "ujiuye", "ok", "Lambda");
		//将满足条件的字符串，筛选出来，存储到另外一个集合中
		List<String> result = filtStr(list,x -> x.length() > 3);
		System.out.println(result);
	}
	
	public static List<String> filtStr(List<String> list, Predicate<String> pre) {
		List<String> result = new ArrayList<>();
		for (String str : list) {
			if (pre.test(str)) {
				result.add(str);
			}
		}
		return result;
	}

}