java8：（Lambda 表达式，Supplier，@FunctionalInterface，foreach()，Optional，Stream().collect，双冒号，joining，partitioningBy分区，collectingAndThen，filter()）

1.Lambda 表达式：

 引导：http://www.cnblogs.com/yulinfeng/p/8452379.html

DEMO1:

   
          List<String> names1 = new ArrayList<String>();
          names1.add("Google ");
          names1.add("Runoob ");
          names1.add("Taobao ");
          names1.add("Baidu ");
          names1.add("Sina ");
            
          List<String> names2 = new ArrayList<String>();
          names2.add("Google ");
          names2.add("Runoob ");
          names2.add("Taobao ");
          names2.add("Baidu ");
          names2.add("Sina ");
            
          Compare tester = new Compare();
          System.out.println("使用 Java 7 语法: ");
            
          tester.sortUsingJava7(names1);
          System.out.println(names1);
          System.out.println("使用 Java 8 语法: ");
            
          tester.sortUsingJava8(names2);
          System.out.println(names2);
       }
       
       // 使用 java 7 排序
       private void sortUsingJava7(List<String> names){   
          Collections.sort(names, new Comparator<String>() {
             @Override
             public int compare(String s1, String s2) {
                return s1.compareTo(s2);
             }
          });
       }
       
       // 使用 java 8 排序
       private void sortUsingJava8(List<String> names){
          Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
       }

DEMO2:

final static String salutation = "Hello! ";

    public static void main(String args[]) {
        Declare tester = new Declare();

        // 类型声明
        MathOperation addition = (int a, int b) -> a + b;

        // 不用类型声明
        MathOperation subtraction = (a, b) -> a - b;

        // 大括号中的返回语句
        MathOperation multiplication = (int a, int b) -> {
            return a * b;
        };

        // 没有大括号及返回语句
        MathOperation division = (int a, int b) -> a / b;

        // System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
        // System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
        // System.out.println("10 x 5 = " + tester.operate(10, 5,
        // multiplication));
        // System.out.println("10 / 5 = " + tester.operate(10, 5, division));

        // 不用括号
        // GreetingService greetService1 = message ->
        // System.out.println("Hello " + message);
        //
        // // 用括号
        // GreetingService greetService2 = (message) ->
        // System.out.println("Hello " + message);

        // greetService1.sayMessage("Runoob");
        // greetService2.sayMessage("Google");

        // lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda
        // 内部修改定义在域外的局部变量，否则会编译错误。
        // GreetingService greetService1 = message ->
        // System.out.println(salutation + message);
        // greetService1.sayMessage("Runoob");

        // 我们也可以直接在 lambda 表达式中访问外层的局部变量：
//        final int num = 1;
//        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
//        s.convert(2); // 输出结果为 3
        
        
        //lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）
//        int num = 1;  
//        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
//        s.convert(2);
        //num =2会报错
        
//        在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。
//        String first = "";  
//        Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());  //编译会出错 
    
    }

    public interface Converter<T1, T2> {
        void convert(int i);
    }

    interface MathOperation {
        int operation(int a, int b);
    }

    interface GreetingService {
        void sayMessage(String message);
    }

    private int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }

 

 2.Supplier：

public class SupplierTest {
    private int age;

    public SupplierTest() {
        System.out.println(age);
    }

    public static void main(String[] args) {
        //创建Supplier容器，声明为SupplierTest类型，此时并不会调用对象的构造方法，即不会创建对象
        Supplier<SupplierTest> s = SupplierTest::new;
        //调用get()方法，此时会调用对象的构造方法，即获得到真正对象
        s.get();
        //每次get都会调用构造方法，即获取的对象不同
        s.get();
    }
    
}

3.@FunctionalInterface

　　　　@FunctionalInterface标记在接口上，“函数式接口”是指仅仅只包含一个抽象方法的接口

　　　　  （1）该注解只能标记在"有且仅有一个抽象方法"的接口上。

　　　　（2）JDK8接口中的静态方法和默认方法，都不算是抽象方法。

　　　　（3）接口默认继承java.lang.Object，所以如果接口显示声明覆盖了Object中方法，那么也不算抽象方法。

              （4）该注解不是必须的，如果一个接口符合"函数式接口"定义，那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口，但是加上了@FunctionInterface，那么编译器会报错。

4.foreach()

package com.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Other {
    public static void main(String[] args) {
        testForeach2();
    }
    
    private static void testForeach2() {
        List<String> items = new ArrayList<>();
        items.add("A");
        items.add("B");
        items.add("C");
        items.add("D");
        items.add("E");
//        items.forEach((x)->{System.out.println(x);});
//        items.forEach(System.out::println);
//        items.stream().filter(s->s.contains("B")).forEach(System.out::println);
        
    }
    
    private static void testForeach1() {
        Map<String, Integer> items = new HashMap<>();
        items.put("A", 10);
        items.put("B", 20);
        items.put("C", 30);
        items.put("D", 40);
        items.put("E", 50);
        items.put("F", 60);

        items.forEach((k,v)->System.out.println("Item : " + k + " Count : " + v));

        items.forEach((k,v)->{
            System.out.println("Item : " + k + " Count : " + v);
            if("E".equals(k)){
                System.out.println("Hello E");
            }
        });

    }
}

5.Optional:

package test;

import java.util.Optional;

public class Test1 {
    public static void main(String[] args) {
          Test1 java8Tester = new Test1();
          Integer value1 = null;
          Integer value2 = new Integer(10);
            
          // Optional.ofNullable - 允许传递为 null 参数
          Optional<Integer> a = Optional.ofNullable(value1);
          // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
          Optional<Integer> b = Optional.of(value2);
          System.out.println(a.ofNullable(3).orElse(2));
    }
    
    public Integer sum(Optional<Integer> a, Optional<Integer> b){
        
          // Optional.isPresent - 判断值是否存在
          System.out.println("第一个参数值存在: " + a.isPresent());
          System.out.println("第二个参数值存在: " + b.isPresent());
            
          // Optional.orElse - 如果值存在，返回它，否则返回默认值
          Integer value1 = a.orElse(new Integer(0));
            
          //Optional.get - 获取值，值需要存在
          Integer value2 = b.get();
          return value1 + value2;
    }
       
}

6.Stream().collect

7.双冒号

 

 8.joining:

9.partitioningBy分区：

10.collectingAndThen:

        <!-- https://mvnrepository.com/artifact/com.google.code.google-collections/google-collect -->
        <dependency>
            <groupId>com.google.code.google-collections</groupId>
            <artifactId>google-collect</artifactId>
            <version>snapshot-20080530</version>
        </dependency>

11.filter():