吊打Java面试官之Lambda表达式 Stream API

目录
  • 一、jdk8新特性简介
  • 二、Lambda表达式
    • 简单理解一下Lambda表达式
    • Lambda表达式的使用
  • 三、函数式接口
    • 1.什么是函数式接口
    • 2.如何理解函数式接口
    • 3.Java内置四大核心函数式接口
  • 四、方法引用与构造器引用
    • 方法引用
    • 构造器引用和数组引用
  • 五、Stream API
    • 1.Stream API的说明
    • 2.为什么要使用Stream API
    • 3.创建Stream的四种方式
    • 4.Stream的中间操作及其测试
    • 5.Stream的终止操作及其测试
  • 六、Optional类的使用
    • Optional类的重要意义:

一、jdk8新特性简介

二、Lambda表达式

简单理解一下Lambda表达式

public class LambdaTest {
    @Test
    public void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        System.out.println("******************************************");
        Runnable r2 = () -> System.out.println("我爱北京故宫");
        r2.run();
    }
    @Test
    public void test2(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare1 = com1.compare(12,21);
        System.out.println(compare1);
        System.out.println("**********************************");
        //Lambda表达式的写法
        Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);
        int compare2 = com2 .compare(32,21);
        System.out.println(compare2);
        System.out.println("************************************");
        //方法引用
        Comparator<Integer> com3 = Integer :: compare;
        int compare3 = com3.compare(32,21);
        System.out.println(compare2);
    }

Lambda表达式的使用

1.举例:(o1,o2) -> Integer.compare(o1,o2);
2.格式:
->:lambda操作符 或 箭头操作符
->:左边:lambda形参列表 (其实就是接口中的抽象方法的形参列表)
->:右边:lambda体 (其实就是重写的抽象方法的方法体)
3.Lambda表达式的使用:(分为6种情况介绍)
总结:(重点看这个)
->左边:lambda形参列表的参数类型可以省略(类型推断);如果lambda形参列表只有一个参数,其一对()也可以省略
->右边:lambda体应该使用一对{}包裹;如果lambda体只有一条执行语句(可能时return语句),可以省略这一对{}和return关键字
4.Lambda表达式的本质:作为函数式接口的实例
5.如果一个接口中,只声明了一个抽象方法,则此接口就称为函数式接口

public class LambdaTest1 {
    //语法格式一:无参,无返回值
    @Test
    public void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        System.out.println("******************************************");
        Runnable r2 = () -> {
            System.out.println("我爱北京故宫");
        };

        r2.run();
    }
    //语法格式二:Lambda需要一个参数,但是没有返回值。
    @Test
    public void test2(){
        Consumer<String> con = new Consumer<String>() {

            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("谎言和誓言的区别什么?");
        System.out.println("**********************************");
        Consumer<String>con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听得人当真了,一个是说的人当真了");
    }
    //语法格式三:数据类型可以省略,因为可由编译器推断得出,称为"类型推断"
    @Test
    public void test3(){
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听的人当真了,一个是说的人当真了");
        System.out.println("****************************");
        Consumer<String> con2 = (s) -> {
            System.out.println(s);
        };
        con2.accept("一个是听的人当真了,一个是说的人当真了");
    }
    @Test
    public void test4(){
        ArrayList<String> objects = new ArrayList<>();//类型推断(泛型)
        int[] arr = {1,2,3};//类型推断(int[] arr = new int[]{1,2,3};)
    }
    //语法格式四:Lambda若只需要一个参数时,参数的小括号可以省略
    @Test
    public void test5(){
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听的人当真了,一个是说的人当真了");
        System.out.println("****************************");
        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("一个是听的人当真了,一个是说的人当真了");
    }
    //语法格式五:Lambda需要两个或两个以上的参数,多条执行语句,并且可以有返回值
    @Test
    public void test6(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return Integer.compare(o1,o2);
            }
        };
        System.out.println(com1.compare(12,21));
        System.out.println("*******************************");
        Comparator<Integer> com2 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(com2.compare(12,6));
    }
    //语法格式六:当Lambda体只有一条语句时,return与大括号若有,都可以省略
    @Test
    public void test7(){
        Comparator<Integer> com1 = (o1,o2) ->{
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(12,6));
        System.out.println("******************************");
        Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
        System.out.println(com2.compare(12,21));
    }
    @Test
    public void test8(){
        Consumer<String> con1 = s -> {
            System.out.println(s);
        };
        con1.accept("一个是听的人当真了,一个是说的人当真了");
        System.out.println("*********************************");

        Consumer<String> con2 = s -> System.out.println(s);
        con2.accept("一个是听的人当真了,一个是说的人当真了");
    }
}

三、函数式接口

1.什么是函数式接口

2.如何理解函数式接口

总结:只有函数式接口在实例化的时候,才可以用上Lambda表达式!!!!!!!!!

3.Java内置四大核心函数式接口

java内置的4大核心函数式接口

消费型接口Consumer<T>       void accept(T t)
供给型接口Supplier<T>       T get()
函数式接口Function<T,R>     R apply(T t)
断定型接口Predicate<T>      boolean test(T t)

 public class LambdaTest2 {
    @Test
    public void test1(){
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("学习太累了,去天上人间买了瓶矿泉水,价格为:" + aDouble);
            }
        });
        System.out.println("*************************************");
        happyTime(400,money -> System.out.println("学习太累了,去天上人间喝两口矿泉水,价格为:" + money));
    }
    public void happyTime(double money, Consumer<Double> con){
        con.accept(money);
    }
    @Test
    public void test2(){
        List<String> list = Arrays.asList("北京", "南京", "天津", "东京", "西京", "普京");
        List<String> filterStrs = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(filterStrs);
        List<String> filterStrs1 = filterString(list, s -> s.contains("京"));
        System.out.println(filterStrs1);
    }
    //根据给定的规则,过滤集合中的字符串,此规则由Predicate的方法决定
    public List<String> filterString(List<String> list,Predicate<String> pre){
        ArrayList<String> filterList = new ArrayList<>();
        for(String s : list){
            if(pre.test(s)){
                filterList.add(s);
            }
        }
        return filterList;
    }

四、方法引用与构造器引用

方法引用

1.使用情境:当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用!
2.方法引用,本质上就是Lambda表达式,而Lambda表达式作为函数式接口的实例,所以,方法引用,也是函数式接口的实例。
3.使用格式:类(或对象) :: 方法名
4.具体分为如下的三种情况:
情况1 对象 :: 非静态方法
情况2 类 :: 静态方法
情况3 类 :: 非静态方法
5.方法引用使用的要求:

> 要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同!(针对于情况1、2)

> 当函数式接口方法的第一个参数是需要引用方法的调用者,并且第二个参数是需要引用方法的参数(或无参数)时:ClassName::methodName(针对于情况3)

6.使用建议:

如果给函数式接口提供实例,恰好满足方法引用的使用情境,大家就可以考虑使用方法引用给函数式接口提供实例。如果大家不熟悉方法引用,那么还可以使用lambda表达式。

 情况一:对象 :: 实例方法
    Consumer中的void accept(T t)
    PrintStream中的void println(T t)
    @Test
    public void test1(){
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");
        System.out.println("**************************");
        PrintStream ps = System.out;
        Consumer<String> con2 = ps :: println;
        con2.accept("beijing");
    }
    //Supplier中的T get()
    //Employee中的String getName()
    @Test
    public void test2(){
        Employee emp = new Employee(1001, "Tom", 23, 5600);
        Supplier<String> sup1 = () -> emp.getName();
        System.out.println(sup1.get());
        System.out.println("****************************");
        Supplier<String> sup2 = emp :: getName;
        System.out.println(sup2.get());
    }
    //情况二:类 :: 静态方法
    //Comparator中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)
    @Test
    public void test3(){
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1,t2);
        System.out.println(com1.compare(12,21));
        System.out.println("*********************************");
        Comparator<Integer> com2 = Integer :: compare;
        System.out.println(com2.compare(12,3));
    }
    //Function中的R apply(T t)
    //Math中的Long round(Double d)
    @Test
    public void test4(){
        Function<Double, Long> func = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };
        System.out.println("************************************");
        Function<Double,Long> func1 = d -> Math.round(d);
        System.out.println(func1.apply(12.3));

        System.out.println("*****************************");
        Function<Double,Long> func2 = Math :: round;
        System.out.println(func2.apply(12.6));
    }
    //情况三:类 :: 实例方法(有难度)
    //String 中的 int t1.compareTo(t2)
    @Test
    public void test5(){
        Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc","abd"));
        System.out.println("*****************************");
        Comparator<String> com2 = String :: compareTo;
        System.out.println(com2.compare("abd","abm"));
    }
    //BiPredicate中的boolean test(T t1,T t2);
    //String中的boolean t1.equals(t2)
    @Test
    public void test6(){
        BiPredicate<String,String> pre1 = (s1, s2) -> s1.equals(s2);
        System.out.println(pre1.test("abc","abc"));
        System.out.println("**************************");
        BiPredicate<String,String> pre2 = String :: equals;
        System.out.println(pre1.test("abc","abd"));
    }
    //Function中的R apply(T t)
    //Employee中的String getName();
    @Test
    public void test7(){
        Employee employee = new Employee(1001, "Jerry", 23, 6000);
        Function<Employee,String> func1 = e -> e.getName();
        System.out.println(func1.apply(employee));
        System.out.println("****************************");
        Function<Employee,String> func2 = Employee :: getName;
        System.out.println(func2.apply(employee));
    }

构造器引用和数组引用

一、构造器引用
和方法引用类似,函数式接口的抽象方法的形参列表构造器的形参列表一致。
抽象方法的返回值类型即为构造器所属的类的类型
二、数组引用
大家可以把数组看作是一个特殊的类,则写法与构造器引用一致。

构造器引用
    Supplier中的T get()
    Employee的空参构造器:Employee()
    @Test
    public void test1(){
        Supplier<Employee> sup = new Supplier<Employee>(){
            @Override
            public Employee get(){
                return new Employee();
            }
        };
        System.out.println("****************************");
        Supplier<Employee> sup1 = () -> new Employee();
        System.out.println(sup1.get());
        System.out.println("***********************************");
        Supplier<Employee> sup2 = Employee :: new;
        System.out.println(sup2.get());
    }
    //Function中的R apply(T t)
    @Test
    public void test2(){
        Function<Integer,Employee> func1 = id -> new Employee(id);
        Employee employee = func1.apply(1001);
        System.out.println(employee);
        System.out.println("********************************");
        Function<Integer,Employee> func2 = Employee :: new;
        Employee employee1 = func2.apply(1002);
        System.out.println(employee1);
    }
    //BiFunction中的R apply(T t,U u)
    @Test
    public void test3(){
        BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
        System.out.println(func1.apply(1001,"Tom"));
        System.out.println("**********************************");
        BiFunction<Integer,String,Employee> func2 = Employee :: new;
        System.out.println(func2.apply(1002,"Tom"));
    }
    //数组引用
    //Function中的R apply(T t)
    @Test
    public void test4(){
        Function<Integer,String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));
        System.out.println("************************");
        Function<Integer,String[]> func2 = String[] :: new;
        String[] arr2 = func2.apply(10);
        System.out.println(Arrays.toString(arr2));
    }

五、Stream API

1.Stream API的说明

2.为什么要使用Stream API

1.Stream关注的是对数据的运算,与CPU打交道
集合关注的是数据的存储,与内存打交道
2.
A.Stream 自己不会存储元素。
B.Stream 不会改变源对象。相反,他们会返回一个持有结果的型Stream
C.Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
3.Stream 执行流程
A.Stream的实例化
B.一系列的中间操作(过滤、映射、...)
C.终止操作

4.说明:
4.1 一个中间操作链,对数据源的数据进行处理
4.2 一旦执行终止操作,就执行中间操作链,并产生结果。之后,不会再被使用

3.创建Stream的四种方式

//创建Stream方式一:通过集合
    @Test
    public void test1(){
        List<Employee>employees = EmployeeData.getEmployees();
//        default Stream<E> stream(): 返回一个顺序流
        Stream<Employee> stream = employees.stream();
//        default Stream<E> parallelStream(): 返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();
    }
    //创建Stream方式二:通过数组
    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //调用Arrays类的static <T> stream(T[] array):返回一个流
        IntStream stream = Arrays.stream(arr);
        Employee e1 = new Employee(1001,"Tom");
        Employee e2 = new Employee(1001,"Jerry");
        Employee[] arr1 = new Employee[]{e1,e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);
    }
    //创建Stream方式三:通过Stream的of()
    @Test
    public void test3(){
        Steram<Integer> stream = Stream.of(1,2,3,4,5,6);
    }
    //创建Stream方式四:创建无限流(用的少)
    @Test
    public void test4(){
        //迭代
//        public static<T> Stream<T> iterate(final T seed,final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0,t -> t + 2).limit(10).forEach(System.out :: println);
        //生成
//        public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

4.Stream的中间操作及其测试

    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
//        filter(Predicate p)--接收Lambda,从流中排除某些元素
        Stream<Employee> stream = list.stream();
        //练习:查询员工表中薪资大于7000的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
        System.out.println();
//      limit(n)--截断流,使其3元素不超过给定数量
        list.stream().limit(3).forEach(System.out::println);
        System.out.println();
//        skip(n) -- 跳过元素,返回一个扔掉了前n个元素的流。若流中元素不足n个,则返回一个空流。与limit(n)互补
        list.stream().skip(3).forEach(System.out::println);
//        distinct()--筛选,通过流所生成元素的hashCode()和equals()去除重复元素
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.stream().distinct().forEach(System.out::println);
    }
    //映射
    @Test
    public void test2(){
//        map(Function f)--接收一个函数作为参数,将元素转换成其他形式或提取信息,该函数
        List<String> list = Arrays.asList("aa","bb","cc","dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
//        练习1:获取员工姓名长度大于3的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> namesStream = employees.stream().map(employee::getName);
        namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
//        练习2
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s ->{
            s.forEach(System.out::println);
        });
        System.out.println();
//        flatMap(Function f)--接受一个函数作为参数,将流中的每个值都换成另一个流,然后
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);
    }
    //将多个字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list = new ArrayList<>();
        for(Character c : str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }
    //帮助理解Stream映射的集合例子
    @Test
    public void test3(){
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        ArrayList list2 = new ArrayList();
        list2.add(4);
        list2.add(5);
        list2.add(6);
//        list1.add(list2);
        list1.addAll(list2);
        System.out.println(list1);
    }
    @Test
    public void test4(){
//        sorted()--自然排序
        List<Integer> list = Arrays.asList(12,43,65,34,87,0,-98,7);
        list.stream().sorted().forEach(System.out::println);
        //抛异常,原因:Employee没有实现Comparable接口
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1,e2) ->{
            int ageValue = Integer.compare(e1.getAge(),e2.getAge());
            if(ageValue != 0){
                return ageValue;
            }else{
                return Double.compare(e1.getSalary(),e2.getSalary());
            }
        }).forEach(System.out::println);
    }

5.Stream的终止操作及其测试

Collector需要使用Collectors提供实例。

    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();
//        allMatch(Predicate p)--检查是否匹配所有元素
//        练习:是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);
//        anyMatch(Predicate p)--检查是否至少匹配一个元素
//        练习:是否存在员工的工资大于10000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);
//        noneMatch(Predicate p)--检查是否没有匹配的元素
//        练习:是否存在员工姓"雷"
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startWith("雷"));
        System.out.println(noneMatch);
//        findFirst--返回第一个元素
        Optional<Employee> employee = employees.stream().findFist();
        System.out.println(employee);
//        findAny--返回当前流中的任意元素
        Optional<Employee> employees = employees.parallelStream().findAny();
        System.out.println(employee1);

    }
    @Test
    public void test2(){
//        count--返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);
//        max(Comparator c)--返回流中最大值
//        练习:返回最高的工资:
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> maxSalary = salaryStream.max(Double::compare);
        System.out.println(maxSalary);
//        min(Comparator c)--返回流中最小值
//        练习:返回最低工资的员工
        Optional<Employee> employee = employees.stream().min((e1,e2) -> Double.compare(e1.getSalary(),e2.getSalary()));
        System.out.println(employee);
//        forEach(Consumer c)--内部迭代
        employees.stream().forEach(System.out::println);
        employees.forEach(System.out::println);
    }
    //归约
    @Test
    public void test3(){
//        reduce(T identity,BinaryOperator)--可以将流中元素反复结合起来,得到一个值,返回T
//        练习1:计算1-10的自然数的和
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream().reduce(0,Itneger::sum);
        System.out.println(sum);
//        reduce(BinaryOperator)--可以将流中元素反复结合起来,得到一个值。返回Optional(T)
//        练习2:计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
        Optional<Double> sumMoney = salaryStream.reduce((d1, d2) -> d1 + d2);
        System.out.println(sumMoney);
    }
    //3-收集
    @Test
    public void test4(){
//        collect(Collector c)--将流转换为其他形式。接受一个Collector接口的实现,用于给Stream中元素做汇总的方法
//        练习1:查找工资大于6000的员工,结果返回一个List或Set
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        employeeList.forEach(System.out::println);
        System.out.println();
        Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
        employeeSet.forEach(System.out::println);
    }

六、Optional类的使用

Optional类的重要意义:

Optional类:为了在程序中避免出现空指针异常而创建的
常用的方法:ofNullable(T t)
orElse(T t)

 /*
    Optional.of(T t):创建一个Optional 实例,t必须非空
    Optional.empty():创建一个空的Optional实例
    Optional.ofNullable(T t):t可以为null
     */
    @Test
    public void test1(){
        Girl girl = new Girl();
        girl = null;
        //of(T t):保证t是非空的
        Optional<Girl> optionalGirl = Optional.of(girl);
    }
    @Test
    public void test2(){
        Girl girl = new Girl();
//        //ofNullable(T t):t可以为null
        Optional<Girl> optionalGirl = Optional.ofNullable(girl);
        System.out.println(optionalGirl);
        //orElse(T t1):如果当前的Optional内部封装的t是非空的,则返回内部的t.
        //入股偶内部的t是空的,则返回orElse()方法中的参数t1.
        Girl girl1 = optionalGirl.orElse(new Girl("憨憨"));
        System.out.println(girl1);
    }
    public String getGirlName(Boy boy){
        return boy.getGirl().getName();
    }
    @Test
    public void test3(){
        Boy boy = new Boy();
        boy = null;
        String girlName = getGirlName(boy);
        System.out.println(girlName);
    }
    //优化以后的getGirlName():
    public String getGirlName1(Boy boy){
        if(boy != null){
            Girl girl = boy.getGirl();
            if(girl != null){
                return girl.getName();
            }
        }
        return null;
    }
    @Test
    public void test4(){
        Boy boy = new Boy();
        boy = null;
        String girlName = getGirlName1(boy);
        System.out.println(girlName);//null
    }
    //使用Optional类的getGirlName()
    public String getGirlName2(Boy boy){
        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        //此时的boy1一定非空
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("漂亮妹妹")));
        Girl girl = boy1.getGirl();
        Optional<Girl> girlOptional = Optional.ofNullable(girl);
        //girl1 一定非空
        Girl girl1 = girlOptional.orElse(new Girl("古力娜扎"));
        return girl1.getName();
    }
    @Test
    public void test5(){
        Boy boy = null;
        String girlName = getGirlName2(boy);
        System.out.println(girlName);
    }

到此这篇关于吊打Java面试官之jdk8新特性全面刨析面试无忧的文章就介绍到这了,更多相关jdk8特性内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java8新特性之Stream API详解

    一.前言 StreamAPI在Java8版本中使用,关注的是对数据的筛选.查找.存储等 它可以做的事情有:过滤.排序.映射.归约 二.使用流程 Stream实例化中间操作(过滤.排序.映射.规约)终止操作(匹配查找.归约.收集) 三.案例演示 public class EmployeeData { public static List<Employee> getEmployees(){ List<Employee> list = new ArrayList<>(); l

  • Java8 Stream API 详细使用方法与操作技巧指南

    本文实例讲述了Java8 Stream API 详细使用方法与操作技巧.分享给大家供大家参考,具体如下: 1. 概述 Java 8 引入的一个重要的特性无疑是 Stream API.Stream 翻译过来是"流",突然想到的是大数据处理有个流式计算的概念,数据通过管道经过一个个处理器(Handler)进行筛选,聚合,而且流都具有向量性,强调的是对数据的计算处理,而集合强调的是数据集.Stream可以看做是一个可操作的数据集序列,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找.

  • 基于JDK8-lambda表达式四种forEach性能对比

    jdk8新特性流Stream编程 看了网上一些性能的比较,这里自己写一个进行测试 对比以下四种 普通forEach. java8中新的forEach. stream+forEach. parallelStream+forEach package com.huajie.Lambda; import lombok.extern.slf4j.Slf4j; import org.junit.Before; import org.junit.Test; import java.util.ArrayList

  • 一篇文章带你了解jdk1.8新特性--为什么使用lambda表达式

    目录 一.为什么使用Lambda表达式 二.匿名内部类的方式与Lambda表达式方式的比较(示例) 三.需求演示示例 一.创建一个员工实体类 二.普通方式实现 1.代码如下 2.运行main函数,输出结果如下图: 3. 普通方式实现的缺点 三.优化方式一(策略模式实现) 1.定义一个策略接口 2.定义一个过滤年龄的接口实现类 3.定义一个过滤薪资的接口实现类 4.测试类如下: 5.运行main函数,输出如下: 6. 策略模式实现的缺点 四.优化方式二(匿名内部类实现) 1.定义一个策略接口 2.

  • 基于Java8 Stream API实现数据抽取收集

    目标&背景 我们以"处理订单数据"为例,假设我们的应用是一个分布式应用,有"订单应用","物流应用","商品应用"等都是独立的服务.本次我们的目的需要展示订单列表完整数据: 1.查询订单列表. 2.批量查询物流信息. 3.将物流信息填充到订单主信息中. 假设我们定义了一个订单类,具有几个关键的属性:订单号,状态,订单价,快递信息.如下所示: class Order{ String orderSeq; String st

  • Java中Lambda表达式基础及使用

    目录 一.举例说明 1.无参无返回 1.1 定义一个接口 1.2接口实现类 1.3 测试类 2.有参无返回代码示例 3.有参有返回 二.简单事项 1.省略模式 2.注意事项 三.Lambda表达式和匿名内部类的区别 1.所需类型不同: 2.使用限制不同: 3.实现原理不同: 标准格式: 三要素:形式参数 箭头 代码块 格式:(形式参数)->{代码块} 形式参数:如果多个参数用逗号隔开,无参留空 ->:英文中划线和大于号组成 代码块:具体要做的事 使用前提: 有一个接口 接口中有且仅有一个抽象方

  • Java 8中Stream API的这些奇技淫巧!你Get了吗?

    上次老师跟大家分享了 cookie.session和token,今天给大家分享一下Java 8中的Stream API. Stream简介 1.Java 8引入了全新的Stream API.这里的Stream和I/O流不同,它更像具有Iterable的集合类,但行为和集合类又有所不同. 2.stream是对集合对象功能的增强,它专注于对集合对象进行各种非常便利.高效的聚合操作,或者大批量数据操作. 3.只要给出需要对其包含的元素执行什么操作,比如 "过滤掉长度大于 10 的字符串".&

  • Java中forEach使用lambda表达式,数组和集合的区别说明

    1.数组怎么使用lambda 数组不能直接在forEach中使用lambda表达式 PartnerType[] values = PartnerType.values(); //提示Cannot resolve method 'forEach(<method reference>) values.forEach(System.out::println);//错误使用 想要使用必须转换,如下 (1)转成list (2)转成steam PartnerType[] values = PartnerT

  • 吊打Java面试官之Lambda表达式 Stream API

    目录 一.jdk8新特性简介 二.Lambda表达式 简单理解一下Lambda表达式 Lambda表达式的使用 三.函数式接口 1.什么是函数式接口 2.如何理解函数式接口 3.Java内置四大核心函数式接口 四.方法引用与构造器引用 方法引用 构造器引用和数组引用 五.Stream API 1.Stream API的说明 2.为什么要使用Stream API 3.创建Stream的四种方式 4.Stream的中间操作及其测试 5.Stream的终止操作及其测试 六.Optional类的使用 O

  • 吊打Java面试官!整理了一周的Spring面试大全(附答案)

    目录 Q1:什 么 是 spring? Q2:使 用 Spring 框 架 的 好 处 是 什 么 ? Q3:使 用 Spring 缺点是什么? Q4:IoC 是什么? Q5:IOC的优点是什么 Q6:IoC 容器初始化过程? Q7:依赖注⼊的实现方法有哪些? Q8:依赖注入的相关注解? Q9:依赖注入的过程? Q10:Bean 的生命周期? Q11:Bean 的作⽤范围? Q12:如何通过 XML ⽅式创建 Bean? Q13:Spring 有几种配置方式? Q14:如何用基于 XML 配置的

  • 详解Java面试官最爱问的volatile关键字

    本文向大家分享的主要内容是Java面试中一个常见的知识点:volatile关键字.本文详细介绍了volatile关键字的方方面面,希望大家在阅读过本文之后,能完美解决volatile关键字的相关问题.  在Java相关的岗位面试中,很多面试官都喜欢考察面试者对Java并发的了解程度,而以volatile关键字作为一个小的切入点,往往可以一问到底,把Java内存模型(JMM),Java并发编程的一些特性都牵扯出来,深入地话还可以考察JVM底层实现以及操作系统的相关知识. 下面我们以一次假想的面试过

  • 详解Java函数式编程和lambda表达式

    为什么要使用函数式编程 函数式编程更多时候是一种编程的思维方式,是种方法论.函数式与命令式编程的区别主要在于:函数式编程是告诉代码你要做什么,而命令式编程则是告诉代码要怎么做.说白了,函数式编程是基于某种语法或调用API去进行编程.例如,我们现在需要从一组数字中,找出最小的那个数字,若使用用命令式编程实现这个需求的话,那么所编写的代码如下: public static void main(String[] args) { int[] nums = new int[]{1, 2, 3, 4, 5,

  • Java十分钟精通Lambda表达式

    目录 1.简介 2.Lambda表达式的使用: 1.在普通方法内的使用 2.带参方法的使用 3.Lambda表达式实现多线程 4.Lambda表达式操作运算 5.Lambda表达式方法引用 6.Lambda表达式对集合的使用 3.总结 1.简介 首先Lambda表达式是属于Java8的 一个新特性,提供Java编程中对于函数式编程的支持,有助于代码的简洁,可以取代大半部分的匿名函数,尤其对于集合的遍历和集合的操作,极大的简化了代码. Lambda表达式的主体: 函数式接口: 注意: Lambda

  • Java中常用的Lambda表达式案例解析

    目录 1.ForEach 2.Collect 3.Filter 4.Map 5.MapToInt 6.Distinct 7.Sorted 8.groupingBy 9.FindFirst 10.Reduce 11.Peek 12.Limit 13.Max,Min 总结 前言: 我们日常工作中,Lambda 使用比较多的场景,就是集合类下的 Lambda 流操作,往往几行代码可以帮助我们实现复杂代码 接下来我们把 Lambda 流的常用方法用案列讲解一下. 1.ForEach 集合的遍历forEa

  • Java分析Lambda表达式Stream流合并分组内对象数据合并

    目录 前言 需求 代码实现 依赖引入 设计实体类 测试代码 前言 之前写过<Lambda使用——JDK8新特性>,现在有一个分组合并的需求正好拿来小试牛刀. 需求 数据出自许多接口数据,需要将几个接口数据根据省份id进行分组合并.举例说明: A接口返回List里面有值的的字段为:provinceId.field1.field2.field3 B接口返回List里面有值的的字段为:provinceId.field4.field5.field6 C接口返回List里面有值的的字段为:provinc

  • 使用Java 8中的Lambda表达式实现工厂模式

    前言 工厂模式是面向对象设计模式中大家最为熟知的设计模式之一.传统的实现方式大家都在熟悉不过了,今天将向大家介绍使用Java8 Lambda 表达式更加优雅的实现工厂模式. 封面 工厂模式在java中最常用的设计模式之一,它提供了一种很好的实例化对象的方法,是替代new操作的一种模式常用的方式.工厂设计模式可以让你实例化对象的逻辑不用暴露给客户端. 在下面的文章中我将给出使用传统的代码实现工厂模式的一个例子,然后再使用 Java8 Lambada 方式重新实现 一个例子 首先我将创建一个 Sha

  • Java编程中使用lambda表达式的奇技淫巧

    为什么使用Lambda表达式 先看几个例子: 第一个例子,在一个独立的线程中执行某项任务,我们通常这么实现: class Worker implements Runnable { public void run() { for (int i = 0; i < 100; i++) doWork(); } ... } Worker w = new Worker(); new Thread(w).start(); 第二个例子,自定义字符串比较的方法(通过字符串长度),一般这么做: class Leng

  • Java面试官最喜欢问的关键字之volatile详解

    前言 笔者去年面试过几家公司,基本上每家公司都会问到volatile,甚至有的公司每轮面试的时候都会问到.面试官这么喜欢问volatile就是因为这个关键字涉及到的知识点较多比如Java内存模型.内存屏障.happen-befor等知识,可以继续挖掘到系统指令.超线程等知识. Java内存模型(JMM) volatile是Java虚拟机提供的最轻量的同步机制,但很难被正确的理解与使用,通过学习Java内存模型对volatile专门定义的一些特殊访问规则,或许会对理解volatile有一定帮助.

随机推荐