Java8-新特性

飞翔荷兰号

已于 2022-04-10 17:10:55 修改

阅读量366

点赞数

分类专栏： Java 基础文章标签： java 分布式数据库

于 2022-04-01 00:56:24 首次发布

本文链接：https://blog.csdn.net/weixin_43374578/article/details/123887906

版权

Java 基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、Lambda

1. 基本使用

package com.nike.erick.d01;


/*1. 假如一个接口中只包含一个方法
      1.1 在接口上添加@FunctionalInterface， 提醒这个接口可以使用Lambda
      1.2 创建继承这个接口的时候，()->{}
           2.1 忽略方法名字，因为只包含一个方法
           2.2 ()括号中表示具体的参数
           2.3 {}表示具体的逻辑
           2.4 如果逻辑只包含一行代码，{}也可以省略*/
public class Demo05 {
    public static void main(String[] args) {
        ErickInter inter = (fo, age) -> {
            System.out.println("food is:" + fo);
        };

        inter.eat("peach", 1);
    }
}

@FunctionalInterface
interface ErickInter {

    void eat(String food, int age);

}

三、Optional

- Optional就是一个包装类，可以将具体的数据封装在Optional中
- 然后可以利用Optional 提供的api来进行调用

优点： 
   1. 解决代码冗余
   2. 可以和java8特性中的链式编程结合

1. 传统写法

 /*1. 为什么要使用?
  *      1.1 判断空指针的问题，让代码比较臃肿
  *      1.2 Optional可以和函数式编程结合起来*/
 @Test
 public void first() {
     // 假如获取的student为空， 不判断就会出现 NullPointerException
     Student student = getStudent();

     if (student != null) {
         if (student.getHobbies() != null) {
             System.out.println("爱好数量为：" + student.getHobbies().size());
         } else {
             System.out.println("hobby为空");
         }
     } else {
         System.out.println("student为空");
     }
 }

 private Student getStudent() {
     return null;
 }

2. 创建对象

Optional是一个工具类

# 可以传递null和正常对象，  更加常用
public static <T> Optional<T> ofNullable(T value) 

# 在确定不会null的情况下使用， 如果为null则会报空指针
public static <T> Optional<T> of(T value)

# 如果一个方法的返回值是 Optional类型，如果经过计算发现是null，这个时候就需要把null封装
public static<T> Optional<T> empty()

package com.erick;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Test;

import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;


public class Test01 {

    @Test
    public void test01() {
        Optional<Student> studentOptional = getStudent01();
        // 如果不会空，则执行。。。。
        studentOptional.ifPresent(new Consumer<Student>() {
            @Override
            public void accept(Student student) {
                System.out.println(student.getName());
            }
        });
    }

    /*lambda简化*/
    @Test
    public void second02() {
        Optional<Student> studentOptional = getStudent01();
        // 如果不会空，则执行。。。。
        studentOptional.ifPresent(student -> System.out.println(student.getName()));
    }

    private Optional<Student> getStudent01() {
        // Optional<Student> student = Optional.ofNullable(null);
        Optional<Student> student = Optional.ofNullable(new Student("erick", 10, "xian", null));
        return student;
    }

    @Test
    public void test02() {
        Optional<Student> student02 = getStudent02();
    }

    /*如果确定传入的对象不会null，则可以使用，
     * 如果传入的是null，则会报空指针问题*/
    private Optional<Student> getStudent02() {
        // Optional<Student> student = Optional.of(null);
        Optional<Student> student = Optional.of(new Student("erick", 10, "xian", null));
        return student;
    }

    @Test
    public void test03() {
        getStudent03();
    }

    /*1. 如果一个方法的返回值是 Optional类型，如果经过计算发现是null，这个时候就需要把null封装*/
    private Optional<Student> getStudent03() {
        Student student = null;
        /*如果为null，则封装到empty中，负责封装到of里面，保证不会报空指针错误*/
        return student == null ? Optional.empty() : Optional.of(student);
    }
}

@Data
@AllArgsConstructor
class Student {
    private String name;
    private int age;
    private String address;
    private List<String> hobbies;
}

3. 消费数据

# 方式一： 获取并处理
#         1. 如果不为空，则按照逻辑处理
#         2. 如果为空，则什么也不做
public void ifPresent(Consumer<? super T> action)

# 方式二：直接获取
#       1. 如果有值，则获取值
#       2. 如果为空，则抛出 NoSuchElementException
public T get()


# 方式三： 获取，  推荐
#     1. 如果不为null，则获取到包含的值
#     2. 如果为null，则返回一个自定义的值
public T orElseGet(Supplier<? extends T> supplier)

# 方式四： 获取， 推荐， 比较简单的逻辑
#     1. 如果不为null，则获取到包含的值
#     2. 如果为null，则返回一个自定义的值
public T orElse(T other)

# 方式五： 获取， 推荐
#      1. 如果为null，则抛出异常并处理
#      2. 如果不会null，则获取实际的值

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X

# 方式六
#   1. 如果为null，则抛出 NoSuchElementException
#   2. 如果不会null，则获取到对象
public T orElseThrow()

package com.erick;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Test;

import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Supplier;


public class Test01 {
    
    /*方式一：获取并处理
     *    1. 如果不为空，则按照逻辑处理
     *    2. 如果为空，则什么也不做*/
    @Test
    public void test01() {
        Optional<Student> studentOptional = getStudent();
        studentOptional.ifPresent(new Consumer<Student>() {
            @Override
            public void accept(Student student) {
                System.out.println(student.getName());
            }
        });
    }

    /* 方式二： 直接获取， 不推荐
     *         1. 如果为空，则抛出 NoSuchElementException
     *         2. 如果不为空，则获取到对应的数据*/
    @Test
    public void test02() {
        Optional<Student> studentOptional = getStudent();
        Student student = studentOptional.get();
        System.out.println(student);
    }

    /* 方式三： 获取
     *          1. 如果不为null，则获取到包含的值
     *          2. 如果为null，则返回一个自定义的值*/
    @Test
    public void test03() {
        Optional<Student> studentOptional = getStudent();

        Student student = studentOptional.orElseGet(new Supplier<Student>() {
            @Override
            public Student get() {
                return new Student("mock", 10, "mock", null);
            }
        });
        System.out.println(student);
    }

    /* 方式四： 获取，推荐， 如果简单的逻辑，则使用比较方便
     *      1. 如果为null，则活到到包含的值
     *      2. 如果不会null，则返回一个自定义的值*/
    @Test
    public void test04() {
        Optional<Student> studentOptional = getStudent();
        Student student = studentOptional.orElse(new Student("mock", 11, "mock", null));
        System.out.println(student);
    }

    /*方式五： 获取然后抛异常
     *       1. 如果为null，则抛出异常并处理
     *       2. 如果不会null，则获取实际的值*/
    @Test
    public void test05() {
        Optional<Student> studentOptional = getStudent();

        try {
            Student student = studentOptional.orElseThrow(new Supplier<Throwable>() {
                @Override
                public Throwable get() {
                    return new RuntimeException("ERICK-NULL");
                }
            });

            System.out.println(student);
        } catch (Throwable e) {
            System.out.println("传入的值是空");
            e.printStackTrace();
        }
    }


    /* 方式六： 获取，如果为空，则直接抛出异常
     *          1. 如果为空，则直接抛出异常
     *          2. 如果不会空，则获取对应的值*/
    @Test
    public void test06() {
        Optional<Student> studentOptional = getStudent();
        Student student = studentOptional.orElseThrow();
        System.out.println(student);
    }

    private Optional<Student> getStudent() {
        Student student = null;
        //Student student = new Student("erick", 10, "xian", null);
        return student == null ? Optional.empty() : Optional.of(student);
    }
}

@Data
@AllArgsConstructor
class Student {
    private String name;
    private int age;
    private String address;
    private List<String> hobbies;
}

4. 过滤数据

package com.erick;

import org.junit.Test;

import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class Test02 {

    /*过滤功能：  链式调用*/
    @Test
    public void test01() {
        Optional<Student> studentOptional = getStudent();

        /*链式调用：
         *  1. filter 过滤功能,  根据属性来过滤掉不合适的数据*/
        studentOptional.filter(new Predicate<Student>() {
            @Override
            public boolean test(Student student) {
                return student.getAge() >= 100;
            }
        }).ifPresent(new Consumer<Student>() {
            @Override
            public void accept(Student student) {
                System.out.println(student.getName());
                System.out.println(student.getAge());
            }
        });
    }

    /* lambda表达式写法*/
    @Test
    public void test02() {
        Optional<Student> studentOptional = getStudent();

        studentOptional.filter(student -> student.getAge() >= 100).ifPresent(student -> {
            System.out.println(student.getName());
            System.out.println(student.getAge());
        });
    }

    private Optional<Student> getStudent() {
        // Student student = null;
        Student student = new Student("erick", 100, "xian", null);
        return student == null ? Optional.empty() : Optional.of(student);
    }
}

5. map获取

package com.erick;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;

public class Test02 {


    @Test
    public void test01() {
        Optional<Student> studentOptional = getStudent();
        /*1. 获取到student类的一个属性, 通过map来过滤*/

        studentOptional.map(new Function<Student, List<String>>() {
            @Override
            public List<String> apply(Student student) {
                return student.getHobbies();
            }
        }).ifPresent(new Consumer<List<String>>() {
            @Override
            public void accept(List<String> list) {
                System.out.println(list.size());
            }
        });
    }

    /*lambda写法*/
    @Test
    public void test02() {
        Optional<Student> studentOptional = getStudent();
        /*1. 获取到student类的一个属性, 通过map来过滤*/
        studentOptional.map(student -> student.getHobbies()).ifPresent(list -> System.out.println(list.size()));
    }

    private Optional<Student> getStudent() {
        // Student student = null;
        List<String> hobbies = new ArrayList<>();
        hobbies.add("swim");
        hobbies.add("sing");
        Student student = new Student("erick", 100, "xian", hobbies);
        return student == null ? Optional.empty() : Optional.of(student);
    }
}

飞翔荷兰号

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java8-新特性

一、Lambda1. 基本使用package com.nike.erick.d01;/*1. 假如一个接口中只包含一个方法 1.1 在接口上添加@FunctionalInterface，提醒这个接口可以使用Lambda 1.2 创建继承这个接口的时候，()->{} 2.1 忽略方法名字，因为只包含一个方法 2.2 ()括号中表示具体的参数 2.3 {}表示具体的逻辑 2.4 如果
复制链接

扫一扫