Lambda表达式
Lambda表达式是java8的新特性,使用Lambda表达式可以省略很多代码,Lambda表达式是匿名内部类的简写;
import java.util.Comparator; import java.util.TreeSet; public class TestLambda { /** * 匿名内部类 */ public void test01() { Comparator<Integer> com = new Comparator<Integer>() { @Override public int compare(Integer o1,Integer o2) { return Integer.compare(o1,o2); } }; TreeSet<Integer> ts = new TreeSet<>(com); } /** * lambda */ public void test02() { Comparator<Integer> com = (x,y) -> Integer.compare(x,y); TreeSet<Integer> ts = new TreeSet<>(com); } }
test01和test02功能相同;
lambad 的条件是针对函数式接口
函数式接口:一个接口仅有一个待实现的方法;
可使用注解修饰函数式接口@FunctionalInterface
@FunctionalInterface public interface TestImpl { int add(int x,int y); }
语法格式一:没有参数,并且没有返回值
/** * 语法格式一:没有参数,并且没有返回值 * () -> System.out.println("没有参数,并且没有返回值"); */ @Test public void test03() { final String msg = "没有参数,并且没有返回值"; Runnable runnable = new Runnable() { @Override public void run() { System.out.println(msg); } }; runnable.run(); System.out.println("---------------------------------"); Runnable runnable1 = () -> System.out.println(msg); runnable1.run(); }
语法格式二:一个参数,并且没有返回值
/** * 语法格式二:一个参数,并且没有返回值 * 左边的括号可以省掉 * (x) -> System.out.println(x); * x -> System.out.println(x); */ @Test public void test04() { Consumer<String> consumer = (x) -> System.out.println(x); consumer.accept("一个参数,并且没有返回值"); System.out.println("---------------------------------"); Consumer<String> consumer1 = x -> System.out.println(x); consumer1.accept("左边的括号可以省掉"); }
语法格式三:多个参数,并且有返回值
/** * 语法格式三:多个参数,并且有返回值 * 多条语句时,需要{} * 方法体中就一条语句时,return和{}都可以省略 */ @Test public void test05() { Comparator<Integer> comparator = (x,y) -> { System.out.println("多条语句时,需要{}"); return Integer.compare(x,y); }; System.out.println(comparator.compare(1,3)); System.out.println("---------------------------------"); Comparator<Integer> comparator1 = (x,y) -> Integer.compare(x,y); System.out.println(comparator1.compare(1,3)); }
Java内置四大核心函数式接口
Consumer<T> : 消费型接口
void accept(T t);
Supplier<T> : 供给型接口
T get();
Function<T, R> : 函数型接口
R apply(T t);
Predicate<T> : 断言型接口
boolean test(T t);
//Predicate<T> 断言型接口: @Test public void test4() { List<String> list = Arrays.asList("Hello", "12345678", "Lambda", "www", "ok"); List<String> strList = filterStr(list, (s) -> s.length() > 3); for (String str : strList) { System.out.println(str); } } //需求:将满足条件的字符串,放入集合中 public List<String> filterStr(List<String> list, Predicate<String> pre) { List<String> strList = new ArrayList<>(); for (String str : list) { if (pre.test(str)) { strList.add(str); } } return strList; }
函数型接口
//Function<T, R> 函数型接口: @Test public void test3() { String newStr = strHandler("\t\t\t 一二三四五六七 ", (str) -> str.trim()); System.out.println(newStr); String subStr = strHandler("一二三四五六七", (str) -> str.substring(2, 5)); System.out.println(subStr); }
//需求:用于处理字符串
public String strHandler(String str, Function<String, String> fun) {
return fun.apply(str);
}
供给型接口
//Supplier<T> 供给型接口 : @Test public void test2() { List<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100)); for (Integer num : numList) { System.out.println(num); } }
//Consumer<T> 消费型接口 : @Test public void test1() { happy(10000, (m) -> System.out.println("每次消费:" + m + "元")); } public void happy(double money, Consumer<Double> con) { con.accept(money); }
![](https://images2017.cnblogs.com/blog/1155586/201712/1155586-20171222191646834-273397773.png)