Lambda表达式

Author: MyHerux

.gitignore

@@ -0,0 +1,3 @@
+# Created by .ignore support plugin (hsz.mobi)
+.idea/
+java-java8-learning.iml

pom.xml

@@ -7,6 +7,18 @@
     <groupId>com.xu</groupId>
     <artifactId>java-java8-learning</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
 
 </project>

src/main/java/com/xu/java8/interface_new/Formula.java

@@ -0,0 +1,13 @@
+package com.xu.java8.interface_new;
+
+/**
+ * 接口的默认方法
+ */
+interface Formula {
+    double calculate(int a);
+
+    default double sqrt(int a) {
+        return Math.sqrt(a);
+    }
+}
+

src/main/java/com/xu/java8/lambda/InterfaceT.java

@@ -0,0 +1,41 @@
+package com.xu.java8.lambda;
+
+/**
+ * Class 接口的默认方法
+ *
+ * @author hua xu
+ * @version 1.0.0
+ * @date 16/08/30
+ */
+public class InterfaceT {
+
+    /**
+     * Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法
+     */
+    interface Formula {
+        double calculate(int a);
+
+        default double sqrt(int a) {
+            return Math.sqrt(positive(a));
+        }
+
+        static int positive(int a) {
+            return a > 0 ? a : 0;
+        }
+    }
+
+    public static void main(String[] args) {
+        Formula formula1 = new Formula() {
+            @Override
+            public double calculate(int a) {
+                return sqrt(a * 100);  //默认方法sqrt将在子类上可以直接使用
+            }
+        };
+        System.out.println(formula1.calculate(100));
+        System.out.println(formula1.sqrt(-23));
+        System.out.println(Formula.positive(-4));
+
+    }
+}
+
+

src/main/java/com/xu/java8/lambda/Lambda1.java

@@ -0,0 +1,48 @@
+package com.xu.java8.lambda;
+
+import java.util.*;
+
+/**
+ * Class lambda表达式
+ *
+ * @author hua xu
+ * @version 1.0.0
+ * @date 16/08/30
+ */
+public class Lambda1 {
+    public static void main(String args[]){
+        List<String> names= Arrays.asList("peter", "anna", "mike", "xenia");
+
+        /**java8以前的字符串排列，创建一个匿名的比较器对象Comparator然后将其传递给sort方法*/
+        Collections.sort(names, new Comparator<String>() {
+            @Override
+            public int compare(String a, String b) {
+                return b.compareTo(a);
+            }
+        });
+        /**java8使用lambda表达式就不需要匿名对象了*/
+        Collections.sort(names,(String a,String b)->{return b.compareTo(a);});
+
+        /**对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字*/
+        Collections.sort(names,(String a,String b)->b.compareTo(a));
+
+        /**Java编译器可以自动推导出参数类型，所以你可以不用再写一次类型*/
+        Collections.sort(names, (a, b) -> b.compareTo(a));
+
+        System.out.println(names);
+
+        names.sort(Collections.reverseOrder());
+
+        System.out.println(names);
+
+        List<String> names2 = Arrays.asList("peter", null, "anna", "mike", "xenia");
+        names2.sort(Comparator.nullsLast(String::compareTo));
+        System.out.println(names2);
+
+        List<String> names3 = null;
+
+        Optional.ofNullable(names3).ifPresent(list -> list.sort(Comparator.naturalOrder()));
+
+        System.out.println(names3);
+    }
+}

src/main/java/com/xu/java8/lambda/Lambda2.java

@@ -0,0 +1,71 @@
+package com.xu.java8.lambda;
+
+/**
+ * Class 函数式接口,方法，构造器
+ *
+ * @author hua xu
+ * @version 1.0.0
+ * @date 16/08/30
+ */
+public class Lambda2 {
+
+    /**
+     * 每一个lambda表达式都对应一个类型，通常是接口类型。而“函数式接口”是指仅仅只包含一个抽象方法的接口，
+     * 每一个该类型的lambda表达式都会被匹配到这个抽象方法。
+     * 因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法。我们可以将lambda表达式当作任意只包含一个抽象方法的接口类型，
+     * 确保你的接口一定达到这个要求，你只需要给你的接口添加 @FunctionalInterface 注解，
+     * 编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。
+     */
+
+    @FunctionalInterface
+    public static interface Converter<F, T> {
+        T convert(F from);
+    }
+
+    static class Something {
+        String startsWith(String s) {
+            return String.valueOf(s.charAt(0));
+        }
+    }
+
+    interface PersonFactory<P extends Person> {
+        P create(String firstName, String lastName);
+    }
+
+    public static void main(String[] args) {
+
+        /**基本的接口实现*/
+        Converter<String, Integer> integerConverter1 = new Converter<String, Integer>() {
+            @Override
+            public Integer convert(String from) {
+                return Integer.valueOf(from);
+            }
+        };
+
+        /**使用lambda表达式*/
+        Converter<String, Integer> integerConverter2 = (from) -> Integer.valueOf(from);
+
+        Integer converted1 = integerConverter1.convert("123");
+        Integer converted2 = integerConverter2.convert("123");
+        System.out.println(converted1);   // result: 123
+        System.out.println(converted2);   // result: 123
+
+        /**简写的lambda表达式*/
+        Converter<String, Integer> integerConverter3 = Integer::valueOf;
+        Integer converted3 = integerConverter3.convert("123");
+        System.out.println(converted3);   // result: 123
+
+        /**简写的lambda表达式:method*/
+        Something something = new Something();
+        Converter<String, String> stringConverter = something::startsWith;
+        String converted4 = stringConverter.convert("Java");
+        System.out.println(converted4);    // result J
+
+        /**简写的lambda表达式:constructor*/
+        PersonFactory<Person> personFactory = Person::new;
+        Person person = personFactory.create("Peter", "Parker");//Java编译器会自动根据PersonFactory.create方法的签名来选择合适的构造函数。
+        System.out.println(person.toString());
+    }
+}
+
+

src/main/java/com/xu/java8/lambda/Lambda3.java

@@ -0,0 +1,11 @@
+package com.xu.java8.lambda;
+
+/**
+ * Created by xu on 2016/8/30.
+ */
+public class Lambda3 {
+    @FunctionalInterface
+    interface Fun {
+        void foo();
+    }
+}

src/main/java/com/xu/java8/lambda/Lambda4.java

@@ -0,0 +1,48 @@
+package com.xu.java8.lambda;
+
+/**
+ * Class Lambda作用域。
+ *
+ * @author hua xu
+ * @version 1.0.0
+ * @date 16/08/30
+ */
+public class Lambda4 {
+    /**
+     * 在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。
+     * 你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。
+     */
+    static int outerStaticNum;
+
+    int outerNum;
+
+    void testScopes() {
+        int num = 1;
+
+        Lambda2.Converter<Integer, String> stringConverter =
+                (from) -> String.valueOf(from + num);
+
+        String convert = stringConverter.convert(2);
+        System.out.println(convert);    // 3
+
+        Lambda2.Converter<Integer, String> stringConverter2 = (from) -> {
+            outerNum = 13;
+            return String.valueOf(from);
+        };
+
+        String[] array = new String[1];
+        Lambda2.Converter<Integer, String> stringConverter3 = (from) -> {
+            array[0] = "Hi there";
+            return String.valueOf(from);
+        };
+
+        stringConverter3.convert(23);
+
+        System.out.println(array[0]);
+    }
+    public static void main(String[] args) {
+        new Lambda4().testScopes();
+    }
+}
+
+

src/main/java/com/xu/java8/lambda/Person.java

@@ -0,0 +1,21 @@
+package com.xu.java8.lambda;
+
+/**
+ * @author Benjamin Winterberg
+ */
+public class Person {
+    public String firstName;
+    public String lastName;
+
+    public Person() {
+    }
+
+    public Person(String firstName, String lastName) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public String toString(){
+        return firstName+lastName;
+    }
+}