1 Lamda表达式

lamda表达式构成, 参数,箭头,方法体.
为什么使用lamda表达式, 最只直观的就是简洁了.
这里举个例子: 我们来比较字节数组的大小,进行排序
不使用lamda表达式时,

package java8;

import org.apache.hadoop.hbase.util.Bytes;
import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.Stream;

/**
 * Created by zhangkai12 on 2018/6/13.
 */
public class Test {
    public static void main(String[] args) {
        //Comparator<byte[]> byteCompare = (byte[] b1, byte[] b2) -> {return Bytes.compareTo(b1,b2);};
        Comparator<byte[]> byteCompare = new Comparator<byte[]>() {
            @Override
            public int compare(byte[] o1, byte[] o2) {
                return Bytes.compareTo(o1, o2);
            }
        };
        Stream<byte[]> result = Stream.of(new byte[]{-128},new byte[]{0},new byte[]{127});
        Stream<byte[]> sorted = result.sorted(byteCompare);
        sorted.forEach(res -> {
            System.out.println(Arrays.toString(res));
        });
    }
}

使用lamda表达式时,

package java8;

import org.apache.hadoop.hbase.util.Bytes;
import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.Stream;

/**
 * Created by zhangkai12 on 2018/6/13.
 */
public class Test {
    public static void main(String[] args) {
        Comparator<byte[]> byteCompare = (byte[] b1, byte[] b2) -> {return Bytes.compareTo(b1,b2);};
        Stream<byte[]> result = Stream.of(new byte[]{-128},new byte[]{0},new byte[]{127});
        Stream<byte[]> sorted = result.sorted(byteCompare);
        sorted.forEach(res -> {
            System.out.println(Arrays.toString(res));
        });
    }
}

由上面对比可以发现, 使用lamda表达式可以减少不少代码量. 看起来也更加的简单.

2 lamda表达式使用场景\

谈到lamda表达式, 则不得不提到函数式接口, 任何一个可以接受函数式接口的地方都可以使用lamda表达式进行替换.

什么是函数式接口, 即只包含一个抽象方法的接口.
此处写一个函数式接口的例子:

package java8.one;

/**
 * Created by zhangkai12 on 2018/6/28.
 */
@FunctionalInterface
public interface CheckBoolean {
    boolean check(int a);
}

package java8.one;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by zhangkai12 on 2018/6/28.
 */
public class Test {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(16);
        list.add(1);
        list.add(2);
        list.add(3);
        CheckBoolean checkBoolean = new CheckBoolean() {
            @Override
            public boolean check(int a) {
                return a == 3;
            }
        };
        List<Integer> re = find(list, checkBoolean);
    }

    public static List<Integer> find(List<Integer> list, CheckBoolean checkBoolean) {
       List<Integer> result = new ArrayList<>();
        for (int a : list){
            if (checkBoolean.check(a)){
                result.add(a);
            }
        }
        return result;
    }
}

上面例子定义了一个函数式接口CheckBoolean, 使用注解@FunctionalInterface标记. 之后实例化这个函数式接口,并传递给find函数作为参数.
常见的Java 函数式接口:

函数式接口

3方法引用

方法引用的使用场景:

• 静态方法 例子如下

package java8.one;

import java.util.stream.Stream;

/**
 * Created by zhangkai12 on 2018/6/28.
 */
public class Test2 {
    public static void main(String[] args) {
        MyObj myObj = new MyObj();

        //Stream.of(1,2,3,4).map((res) -> myObj.change(res)).forEach(System.out::println);

        //Stream.of(1,2,3,4).map(myObj::change).forEach(System.out::println);
        
        Stream.of(1,2,3,4).map(MyObj::staticChange).forEach(System.out::println);
    }
}
class MyObj {
    public MyObj() {
    }

    public int change(int num) {
        return num * 2;
    }

    public static int staticChange(int num) {
        return num * 2;
    }
}

再比如一开始比较byte[]字节数组时现在可以修改为:

package java8;

import org.apache.hadoop.hbase.util.Bytes;
import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.Stream;

/**
 * Created by zhangkai12 on 2018/6/13.
 */
public class Test {
    public static void main(String[] args) {

        Stream<byte[]> result = Stream.of(new byte[]{-128},new byte[]{0},new byte[]{127});
        Stream<byte[]> sorted = result.sorted(Bytes::compareTo);
        sorted.forEach(res -> {
            System.out.println(Arrays.toString(res));
        });
    }
}

• 实例方法比如

 (String s) -> s.toUpperCase() 可以写成String::toUpperCase

• 使用外部对象的实例方法 例子如下:

package java8.one;

import java.util.stream.Stream;

/**
 * Created by zhangkai12 on 2018/6/28.
 */
public class Test2 {
    public static void main(String[] args) {
        MyObj myObj = new MyObj();

        Stream.of(1,2,3,4).map((res) -> myObj.change(res)).forEach(System.out::println);

        //Stream.of(1,2,3,4).map(myObj::change).forEach(System.out::println);
    }
}
class MyObj {
    public MyObj() {
    }

    public int change(int num) {
        return num * 2;
    }
}

可以转为

Stream.of(1,2,3,4).map(myObj::change).forEach(System.out::println);

如果使用图来表达这三种情况的话,如下:

方法引用