JDK8新特性_JDK8面试题

JDK8新特性_JDK8面试题JDK8新特性lambda表达式要求:接口必须是函数式接口,一个接口如果只有一个抽象方法,那他就是函数式接口,我们可以在一个接口上使用_Functionallnterface_注解package com.atguigu.java;import java.util.Comparator;public class LambaTest { public static void main(String[] args) { Runnable r1 = new Runnable()

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

JDK8新特性

lambda表达式

要求:接口必须是函数式接口,一个接口如果只有一个抽象方法,那他就是函数式接口,我们可以在一个接口上使用__Functionallnterface__注解

package com.atguigu.java;

import java.util.Comparator;

public class LambaTest { 
   
    public static void main(String[] args) { 
   
        Runnable r1 = new Runnable() { 
   
            @Override
            public void run() { 
   
                System.out.println("我爱北京天安门");
            }
        };
        r1.run();
        System.out.println("------------------------");
        Runnable r2 = () -> System.out.println("我爱北京故宫");
        r2.run();


        Comparator<Integer>com1 = new Comparator<Integer>() { 
   
            @Override
            public int compare(Integer o1, Integer o2) { 
   
                return Integer.compare(o1,o2);
            }
        };
        System.out.println("-------------------------");
        //lambda表达式
        Comparator<Integer>com2 = (o1, o2) ->  Integer.compare(o1,o2);

        System.out.println("-------------------------");
        //方法引用
        Comparator<Integer>com3 = Integer::compare;
        
    }
}

java中的lambda本质是接口的实例

lambda表达式6种类型

package com.atguigu.java;

import java.util.Comparator;
import java.util.function.Consumer;

public class LambaTest { 
   
    public static void main(String[] args) { 
   
        //1.无参数 无返回值
        Runnable runnable = () -> System.out.println("我爱中国");

        //2.lambda需要一个参数,没有返回值
        Consumer<String> consumer = (String s) -> { 
   System.out.println(s);};

        //3.数据类型可以省略,因为可由编译器推断得出,称为"类型推断"
        Consumer<String> consumer1 = (s) -> { 
   System.out.println(s);};

        //4.Lambda若只有一个参数 参数的小括号可以省略
        Consumer<String> consumer2 = s -> { 
   System.out.println(s);};

        //5.lambda需要两个或以上的参数,多条执行语句,并且可以有返回值
        Comparator<Integer> con1 = (o1,o2) -> { 
   
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };

        //6.lambda只有一条语句的时候,return与大括号若都有,均可省略
        Comparator<Integer> con2 = (o1,o2) -> o1.compareTo(o2);
        
    }
}

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

  1. 消费型接口 Consumer void accept(T t)
  2. 供给型接口 Supplier T get()
  3. 函数式接口 Function<T,R>R apply(T t)
  4. 断定型接口 Predicateboolean test(T t)
package com.atguigu.java;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class LambaTest { 
   
    public static void main(String[] args) { 
   
        List<String> list = Arrays.asList("北京","南京","天津","东京","西京","普京");
        List<String> filters = filterString(list,s -> s.contains("京"));
        System.out.println(filters);
    }
    static 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;
    }
}

方法引用

函数引用就是lambda表达式,是lambda表达式更深层次的表达。
使用场景:当要传递给lambda体的操作,已经有实现的方法了,可以使用方法引用!
格式主要有以下三种:

  1. 对象 :: 非静态方法
  2. 类 :: 静态方法
  3. 类 :: 非静态方法
    使用要求:要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同(适用于情况1和2)
public static void main(String[] args) { 
   
        //BiPredicate中的Boolean test(T t1,T t2);
        //String中的boolean t1.equals(t2);
        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;


        //Comparator中的int compare(T t1,T t2)
        //String中的int t1.compareTo(t2)
        Comparator<String>com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc","bcd"));
        System.out.println("********************");
        Comparator<String> com2 = String::compareTo;
        
    }

构造器引用

public static void main(String[] args) { 
   
        //构造器引用
        Supplier<String> stringSupplier = new Supplier<String>() { 
   
            @Override
            public String get() { 
   
                return new String();
            }
        };
        System.out.println("****************");
        Supplier<String> stringSupplier1 = () -> new String();
        System.out.println("****************");
        Supplier<String> stringSupplier2 = String::new;


        //数组引用
        Function<Integer,String[]>func1 = length -> new String[length];
        System.out.println("****************");
        Function<Integer,String[]>func2 = String[]::new;
        
    }

Stream API

  1. Stream关注的是对数据的运算,与CPU打交道,集合关注的是数据,与内存打交道
  2. Stream自己不会存储内存。不会改变源对象,返回一个Stream对象。操作是延迟执行的,等到需要的结果的时候才会执行
  3. Stream执行流程:1.Stream实例化2.一系列中间操作3.终止操作

说明:

  1. 一个中间操作链,对数据源的数据进行处理
  2. 一旦执行终止操作,就执行中间操作链,之后,不会再被重写

Stream创建3种方式

public static void main(String[] args) { 
   
        //1.
        List<String>list = null;
        Stream<String> stream = list.stream();
        //2.
        int arr[] = { 
   1,2,3};
        IntStream stream1 = Arrays.stream(arr);
        //3.
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4);
    
    }

Stream的中间操作

  1. 筛选与切片
public static void main(String[] args) { 
   
        List<Employee> list = Employee.getEmployees();
        Stream<Employee> stream = list.stream();
        //filter(Predicate p)--接收 Lambda,从流中排除某些元素
        stream.filter(e -> e.getSalary() > 70000).forEach(System.out::println);
        System.out.println();

        //limit(n)截断流,使其元素不超过给定数量
        list.stream().limit(3).forEach(System.out::println);
        System.out.println();

        //skip(n)--跳过元素,返回一个扔掉前n个元素的流,若流中元素不足n个,则返回一个空流
        list.stream().skip(3).forEach(System.out::println);

        //distinct()--筛选,通过流所生成元素的hashCode()和equals去除重复元素
        list.stream().distinct().forEach(System.out::println);
        
    }
  1. 映射
public static void main(String[] args) { 

//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 = Employee.getEmployees();
Stream<String> stringStream = employees.stream().map(Employee::getName);
stringStream.filter(name -> name.length() > 3).forEach(System.out::println);
//flatMap(Fcuntion f)--接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有的流换成另一个流
//map方式
Stream<Stream<Character>> streamStream = list.stream().map(LambaTest::fromStringToStream);
streamStream.forEach(s -> { 

s.forEach(System.out::println);
});
//flatmap方式
Stream<Character>characterStream = list.stream().flatMap(LambaTest::fromStringToStream);
}
public static Stream<Character> fromStringToStream(String str){ 

ArrayList<Character> strings = new ArrayList<>();
for (Character c : str.toCharArray()){ 

strings.add(c);
}
return strings.stream();
}
  1. 排序

public static void main(String[] args) { 

//sorted自然排序
List<Integer> list = Arrays.asList(12, 43, 65, 34, 84, 0, -98, 7);
list.stream().sorted().forEach(System.out::println);
//sorted(Comparator)
List<Employee> employees = Employee.getEmployees();
employees.stream().sorted((e1,e2) -> { 

boolean b = e1.getSalary() > e2.getSalary();
return b;
}).forEach(System.out::println);
}
  1. 匹配与查找
public static void main(String[] args) { 

//allMatch(Predicate e)检查是否匹配所有的元素
List<Employee> employees = Employee.getEmployees();
boolean b = employees.stream().allMatch(e -> e.getSalary() > 1000);
System.out.println(b);
//allMatch(Predicate e)检查是否匹配所有的元素
boolean b1 = employees.stream().anyMatch(e -> e.getSalary() > 10000);
System.out.println(b1);
//noneMatch(Predicate e)检查是否没有匹配的元素
//findfirst()查找第一个元素
Optional<Employee> first = employees.stream().findFirst();
System.out.println(first);
//findAny()返回当中流的任意一个元素
//count()求个数
long count = employees.stream().filter(e -> e.getSalary() > 50000).count();
System.out.println(count);
//max(Comparator c)
Stream<Integer> integerStream = employees.stream().map(e -> e.getSalary());
Optional<Integer> max = integerStream.max(Integer::compareTo);
System.out.println(max);
//min(Comparator c)
Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
System.out.println(min);
//foreach(Consumer c)
employees.stream().forEach(System.out::println);
}
  1. 规约

// reduce(T identity, BinaryOperator) 可以将流中的元素反复结合起来,得到一个值,返回一个T
// 练习:计算1-10自然数的和
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer reduce = list.stream().reduce(0, Integer::sum);
System.out.println(reduce);
//reduce(BinaryOperator)--可以将流中元素反复结合起来,得到一个值,返回Optimal<T>
List<Employee> employees = Employee.getEmployees();
Stream<Integer> integerStream = employees.stream().map(Employee::getSalary);
Optional<Integer> reduce1 = integerStream.reduce(Integer::sum);
System.out.println(reduce1);
}
  1. 收集
public static void main(String[] args) { 

//收集
//collect(Collector c)将流转换为其他形式,接收一个Collector接口的实现,用于给Stream中元素做汇总的方法
//Collector接口中方法的实现决定了如何对流执行收集的操作(如收集到List,Set,Map)
//另外,Collectors实用类提供了很多静态方法,可以方便地创建常见收集器实例
// 练习:超照工资大于6000的员工,结果返回为一个list或set
List<Employee> employees = Employee.getEmployees();
Stream<Employee> employeeStream = employees.stream().filter(e -> e.getSalary() > 6000);
List<Employee> collect = employeeStream.collect(Collectors.toList());
employees.forEach(System.out::println);
}

Optimal类

空指针异常是导致java应用程序失败的最常见的原因。为了解决空指针异常,开发出了Optimal类.
目的:为了避免空指针

package com.atguigu.java;
import java.util.Optional;
public class LambaTest { 

public static void main(String[] args) { 

}
}
class Boy{ 

private Girl girl;
@Override
public String toString() { 

return "Boy{" +
"girl=" + girl +
'}';
}
public Boy(Girl girl) { 

this.girl = girl;
}
public void setGirl(Girl girl) { 

this.girl = girl;
}
public Girl getGirl() { 

return girl;
}
public static void main(String[] args) { 

//Optimal.of(T t)创建一个Optimal实例,t必须非空
//Optimal.empty()创建一个空的Optimal实例
//Optimal.ofNullable(T t)t 可以为null
//orElse()
Boy boy = null;
Optional<Boy> boy1 = Optional.ofNullable(boy);
Boy boy2 = boy1.orElse(new Boy(new Girl("迪丽热吧")));
Girl girl = boy2.getGirl();
Optional<Girl> girl1 = Optional.ofNullable(girl);
Girl girl2 = girl1.orElse(new Girl("古力娜扎"));
System.out.println(girl2);
}
}
class Girl{ 

private String name;
public void setName(String name) { 

this.name = name;
}
public Girl() { 

}
public String getName() { 

return name;
}
public Girl(String name) { 

this.name = name;
}
}
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/168824.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • 打印菱形Java_for循环打印菱形

    打印菱形Java_for循环打印菱形Java打印菱形Java打印菱形先看效果:题目分析代码Java打印菱形先看效果:题目分析1、星号前面的空白要用空格代替。2、把图形分为上下两部分,分别找出行数与“空格”和“*”的关系上半部分(正三角):空格个数与行数的关系橘色框:代表行号。红色框:正三角形成的最大行号(maxNum)。计算公式:(总行数+1)/2&nbsp;&nbsp;&nbsp;&nbsp;&nb…

  • sklearn库的功能_numpy库

    sklearn库的功能_numpy库sklearn是目前python中十分流行的用来实现机器学习的第三方包,其中包含了多种常见算法如:决策树,逻辑回归、集成算法等。即使你还不太懂机器学习的具体过程,依旧可以使用此库进行机器学习操作,因为其对各种算法进行了良好的封装,可以在不了解算法实现过程的情况下使用算法,所以可以把sklearn库当作学习过程中的一个过度,如果你想快速建立一个模型,这也是一个不错的选择。数据导入skle…

    2022年10月17日
  • 简易聊天系统-聊天服务

    聊天负责私人聊天,群组聊天。私人聊天接受信息后保存至数据库再转发给目标用户。群组聊天当前没有离线消息保存,也就是用户登录后无法知道多少消息未读,而是直接拉取指定数量群聊天。当有成员发送后会将聊天信息存储数据库(没有缓存进redis,因为在线用户会直接发送,目前没有这个优化必要),从redis中检索所有群组在线用户并通过消息队列发送至对应网关。大致代码如下://处理群消息funcDealGroupMsg(delivery*amqp.Delivery,transfer1*transfer)

  • 如何进行网页背景音乐的设置和播放_html怎么加背景音乐

    如何进行网页背景音乐的设置和播放_html怎么加背景音乐前天制作网站最大的问题来源于背景音乐的设置,最后采用了制作音乐播放器的方式代替,但是对于除IE浏览器之外的其它浏览器仍然存在不适配的问题。在这里找到了几种比较好的解决办法,先mark一下。https://www.cnblogs.com/Format2012/archive/2012/06/15/2551381.html…

  • ssdp java_SSDP协议 – 实施[通俗易懂]

    ssdp java_SSDP协议 – 实施[通俗易懂]我正在尝试实现SSDP协议,但我不确定它是如何工作的.SSDP通过udp发送数据,这很清楚.如果控制器连接到网络,它可以搜索具有MSEARCH消息的设备,该消息可以发送到多播地址239.255.255.250:1900.每个设备都必须收听此地址并做出响应.但我不知道他们是如何回应的.我在wireshark中看到他们用单播响应,但我不知道如何确定接收响应的端口.编辑–…

    2022年10月11日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号