Java8简明学习之Lambda表达式

函数式接口

　　就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口，函数式接口可以被隐式转换为lambda表达式。

　　之前已有的函数式接口:
　　java.lang.Runnable
　　java.util.concurrent.Callable
　　java.util.Comparator
　　java.io.FileFilter

　　1.8新增的函数式接口：
　　java.util.function包下

　　Predicate<T>――接收 T 并返回 boolean （常用）
　　Consumer<T>――接收 T，不返回值（常用）
　　Function<T, R>――接收 T，返回 R （常用）
　　Supplier<T>――提供 T 对象（例如工厂），不接收值
　　UnaryOperator<T>――接收 T 对象，返回 T
　　BinaryOperator<T>――接收两个 T，返回 T

lambda表达式

　　lambda表达式的语法由参数列表、箭头符号 -> 和函数体组成。函数体既可以是一个表达式，也可以是一个语句块。
　　eg: (int x, int y) -> x + y （表达式）
　　eg：(Integer e) -> {
　　　　double sqrt = Math.sqrt(e);
　　　　double log = Math.log(e);

　　　　return sqrt + log;
　　} （语句块）
　　意义：传入参数x和y，返回x和y的和
　　表达式：表达式会被执行然后返回执行结果。
　　语句块：语句块中的语句会被依次执行，就像方法中的语句一样。

方法引用:

　　方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。
　　方法引用有很多种，它们的语法如下：
　　静态方法引用：ClassName::methodName
　　实例上的实例方法引用：instanceReference::methodName
　　超类上的实例方法引用：super::methodName
　　类型上的实例方法引用：ClassName::methodName
　　构造方法引用：Class::new
　　数组构造方法引用：TypeName[]::new

List<String> names5 = Arrays.asList("peter", "anna", "mike", "xenia");         names5.sort(String::compareTo);         System.out.println(names5);

public void testFun1() {
// comparing 是 Function<? super T, ? extends U> Function<T, R>――接收 T，返回 R
Person p1 = new Person();
p1.setName("hy");
p1.setAge(18);

Person p2 = new Person();
p2.setName("dax");
p2.setAge(19);

Person[] people = {p1, p2};
Comparator<Person> byName = Comparator.comparing(Person::getName);
Arrays.sort(people, byName);
for (Person person : people) {
System.out.println(person);
}
}

Stream

Stream与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念，Stream 是对集合（Collection）对象功能的增强。

eg：内部迭代和外部迭代

 void innerOrOuter() {         List<Person> list = new ArrayList<>();         Person p1 = new Person();         p1.setName("hy");         p1.setAge(18);          Person p2 = new Person();         p2.setName("dax");         p2.setAge(19);          list.add(p1);         list.add(p2);          for (Person p: list) {             p.setAge(20);         }         System.out.println(list);          List<Person> list2 = new ArrayList<>();         Person p21 = new Person();         p21.setName("hy");         p21.setAge(18);          Person p22 = new Person();         p22.setName("dax");         p22.setAge(19);          list2.add(p21);         list2.add(p22);          list2.stream().forEach(p->p.setAge(20));         System.out.println(list2);     }

　　Stream通用语法：

　　Stream的操作：
　　Intermediate（中间操作）：
　　　　map (mapToInt, flatMap 等)、 filter、 distinct（去重）、 sorted（排序）、 peek（对某个元素做单独处理生成新的Stream）、
　　　　limit（取前N个元素）、 skip（丢弃前N个元素）、 parallel、 sequential、 unordered

　　Terminal（结束操作，非短路操作）：
　　　　forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

　　Short-circuiting（结束操作，短路操作）：
　　　　anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

　　代表例子：

@Test public void testNormal() {     // 1 线程     new Thread(()-> testThread()).start();      // 2 遍历集合     List<String> list = Arrays.asList("abd", "nba", "cba", "mctrady");     list.stream().forEach(n-> System.out.println(n));     list.forEach(n-> System.out.println(n));      // 3 map运用     List<Integer> listInt = Arrays.asList(123, 456, 789, 101);     listInt.stream().map(n->n*10).forEach(n-> System.out.println(n));     System.out.println(listInt.stream().mapToInt(n->n).sum());     System.out.println(listInt.stream().mapToInt(n->n).average().getAsDouble());      // 4 filter     List<Integer> listInt2 = Arrays.asList(123, 456, 789, 101);     listInt2.stream().filter(n->n>200).forEach(n-> System.out.println(n));       // 5 对每个元素应用函数     List<Integer> listInt3 = Arrays.asList(123, 456, 789, 101);     String str = listInt3.stream().map(n->n.toString()).collect(Collectors.joining(","));     System.out.println(str); }  private void testThread() {     System.out.println("线程操作"); }

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");         Collections.sort(names, new Comparator<String>() {             @Override             public int compare(String a, String b) {                 return b.compareTo(a);             }         });         System.out.println(names);          List<String> names1 = Arrays.asList("peter", "anna", "mike", "xenia");         Collections.sort(names1, (String a, String b) -> {             return b.compareTo(a);         });         System.out.println(names1);          List<String> names2 = Arrays.asList("peter", "anna", "mike", "xenia");         Collections.sort(names2, (String a, String b) -> b.compareTo(a));         System.out.println(names2);          List<String> names3 = Arrays.asList("peter", "anna", "mike", "xenia");         Collections.sort(names3, (a, b) -> b.compareTo(a));         System.out.println(names3);          List<String> names4 = Arrays.asList("peter", "anna", "mike", "xenia");         Collections.sort(names4, String::compareTo);         System.out.println(names4);          List<String> names5 = Arrays.asList("peter", "anna", "mike", "xenia");         names5.sort(String::compareTo);         System.out.println(names5);          List<String> names6 = Arrays.asList("peter", "anna", "mike", "xenia");         // 反转         names6.sort(Comparator.comparing(String::toString).reversed());         System.out.println(names6);

　　总结：

　　关于lambda和Stream的学习暂时先到这，如果日常用的就是1.8版本，这些就慢慢熟悉了，习惯了1.7以前面向对象编程的思维需要一些时间转换。而1.8里面lambda和Stream无疑是让Java更加的拥抱变化，在函数式编程里面也有了一些说话的位置。

　　参考：

　　http://zh.lucida.me/blog/java-8-lambdas-insideout-language-features/

　　https://blog.csdn.net/hanyingzhong/article/details/60965197

　　https://segmentfault.com/a/1190000008876546

文章来源: Java8简明学习之Lambda表达式

标签

string

lambda表达式