java8新特性

介绍流程：

Lambda表达式

流Stream

Optional

附上思维导图：

 

1.Lambda表达式

 (1)特点：通过表达式来实现相关接口方法，简化使用匿名类的操作，提高代码整洁性。

 (2):常见的几种使用方式：

public class TestLambda {
    //常见形式
    private Math add = (a, b) -> a + b;
    private Math remove = (int a, int b) -> a - b;
    private Math decade = (a, b) -> a * b;
    private Math square = (int a, int b) -> a / b;
    private Message msg = (a) -> System.out.println("测试" + a);
    private Map map = new HashMap();

    @Test
    //测试
    public void test() {
        Integer[] i = new Integer[]{1, 2, 3, 4};
        map.put(1, "x");
        map.put(2, "y");
        //通过表达式实现接口方法 ->有返回值
        System.out.println(add.caculate(1, 2));
        System.out.println(remove.caculate(1, 2));
        System.out.println(decade.caculate(1, 2));
        System.out.println(square.caculate(1, 2));
        //无返回值
        msg.play(1);
        //集合的遍历 ->遍历所有值
        map.forEach((c, v) -> System.out.println(v));
        //集合的遍历 ->遍历所有键
        map.forEach((c, v) -> System.out.println(c));
        Arrays.asList(i).sort((a, b) -> {
            if (a > b) {
                return a;
            }
            return b;
        });
    }
}

//声明为函数式接口：仅包含一个方法，且方法符合Lambda表达式使用规范
@FunctionalInterface
interface Math {
    int caculate(int a, int b);
}

@FunctionalInterface
interface Message {
    void play(int a);
}

效果截图：

(3)Lambda表达式的优缺点：

优点：使用lambda表达式代替匿名类使用，接口方法实现，提高了代码的整洁性。

缺点：维护较难，对开发人员的要求也比较高。

2.流Stream

(1)特点：能够对集合对象进行包装，对集合元素进行相关操作，如遍历，过滤，去重等等。

(2)常用方法：

public class TestStream {
    private List<String> list = new ArrayList<>();

    @Test
    public void test() {
        list.add(0, "123");
        list.add(1, "456");
        list.add(2, "789");
        list.add(3, "456");
        //运用流Stream进行过滤，将内容不是123字符串的内容过滤出来并获得个数
        System.out.println(list.stream().filter(e -> !e.equals("123")).count());
        //集合遍历forEach
        list.stream().forEach(e -> System.out.println(e));
        //将过滤出来的元素再放入一个集合列表中
        List l2 = (List) list.stream().filter(e -> !e.equals("123")).collect(Collectors.toList());
        //操作集合元素去重后拼接成字符串
        String str = (String) list.stream().distinct().collect(Collectors.joining("-"));
        System.out.println(str);
        //遍历
        l2.stream().forEach(e -> System.out.println(e));
        //通过流stream获取新集合的首个Optional元素
        System.out.println("首元素：" + l2.stream().findFirst());
        //通过流Stream去重后元素个数
        System.out.println("去重后个数为：" + l2.stream().distinct().count());
        //lambda表达式的内部可以引用外部变量或局部变量，
        // 但是不允许在表达式中对该变量进行修改，该变量只能被声明为final
        int factor = 1;
        //若修改该变量直接编译错误
        /*  list.stream().forEach(e-> System.out.println(factor++));*/
        //使用reduce可以操作集合内元素然后返回一个新值，
        //可实现自定义值结果获取
        System.out.println(list.stream().reduce((e, e2) -> {
            return (Integer.parseInt(e) > Integer.parseInt(e2) ? e : e2);
        }));
    }
}

数组->流过滤->数组：

集合元素移除不需要的值：

 对集合进行判断 是否 符合某条件：

字符串去重：

效果截图：

 常用方法图解:

3.Optional

(1)特点：对于那些空对象的存在，在程序运行时报空指针异常使程序无法继续执行的情况下，可以对这类情况进行避免，使用Option类对这类空指针对象进行获取，判断，设默认值等。

(2)常用方法：

public class TestOptional {
    private String str = "abc";

    @Test
    public void test() {
        //判断str对象是否为空
        Optional<String> optional = Optional.ofNullable(str);
        //如果为空或者null则返回Optional.empty，不为空返回Optional对象
        System.out.println(optional);
        //若对象为空则报空指针异常->如果不确定为空尽量使用ofNullable()方法判断对象是否为空
        System.out.println(Optional.of(str).get());
        //获取与字符串内容为123不相同的字符串值
        System.out.println("过滤"+optional.filter(e -> !e.equals("123")).get());
        //判断当前的对象会否存在且不为空
        System.out.println("当前对象不为空？"+optional.isPresent());
        //对数据元素进行一定的修改，返回修改后的元素
        System.out.println("map方法修改后："+optional.map(e-> e+"x").get());
        //如果获取的对象为空，那么就返回传入的参数值，如果不为空则返回原有值
        str=null;
        Optional<String> optional2 = Optional.ofNullable(str);
        System.out.println(optional2.orElse("456"));
    }
}

效果截图：

文章待完善。。。