Java 8 新特性 lambda表达式
2024-05-05 10:28:09
/
- Created by Manager on 2021/4/1.
- Java 8 新特性
- lambda表达式
- StreamAPI
- 新日期
- 新注解
*/
视频连接
1https://www.bilibili.com/video/BV1ut411g7E9
2https://www.bilibili.com/video/BV164411E7Ny?from=search&seid=476315511879331377
public interface TestInterface {//语法糖void testMethod();
}
class Godness {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public Godness(String name) {this.name = name;}public Godness() {}
}
class myclass implements TestInterface {public myclass() {}public myclass(String name) {this.name = name;}public myclass(Optional<Godness> godness) {this.godness = godness;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Optional<Godness> getGodness() {return godness;}public void setGodness(Optional<Godness> godness) {this.godness = godness;}// Optionalprivate Optional<Godness> godness = Optional.empty();private String name;private int age;public Status getStatus() {return status;}public void setStatus(Status status) {this.status = status;}private Status status;public int getAge() {return age;}public void setAge(int age) {this.age = age;}public enum Status {Free,BUSY,VOCATION}@Overridepublic void testMethod() {System.out.print("aaaaaaaaaaaaaaaa");}void doTest() {//创建接口对象实现类TestInterface test = new myclass();test.testMethod();//匿名内部类TestInterface test2_ = new TestInterface() {@Overridepublic void testMethod() {System.out.print("bbbbb");}};test2_.testMethod();//lambda 接口的实现类的 具体对象 test2=====================//{方法体中 只有一句 可省略}//-> lambda操作符 goes to//() 接口抽象方法 形参列表//右边 接口抽象方法 方法体//无参数 无返回值TestInterface test3 = () -> System.out.print("lambda");test3.testMethod();//一个参数 无返回值 类型推断 int可省//参数只有一个 ()可省TestInterface3 test3_ = (x, y) -> x;test3_.testMethod(1, 2);//多参数 多代码(){} 不可省TestInterface3 t3 = (x, y) -> {return 2;};//只有return return 可省TestInterface3 t3_ = (x, y) -> 20;int a = t3_.testMethod(1, 2);}//lambda表达式使用的接口只能有一个抽象方法 ====函数式接口//@FunctionalInterface 限定===》函数式接口 只有一个抽象函数//一定是函数式接口@FunctionalInterfaceinterface TestInterface3 {int testMethod(int num1, int num2);}void dofour() {String str = getString("aa", x -> x.toUpperCase());op(100L, 100L, (x, y) -> x * y);
//==========================//四个经常用内置的函数式 接口
//1 消费型接口 Consumer<T> void accept(T t)传递参数 无返回值
//2 供给型接口 Supplier<T> T get(); 无参数 返回 T
//3 函数型接口 Function<T,R> R apply(T t) T参数 返回 R
//4 断言型接口 Predicate<T> boolean test(T t)T参数 返回 boolean
// lambda中引用的参数 必须是常量fina 不可修改 默认加了 闭包中引用局部变量默认都是常量Consumer<Double> consumer = x -> System.out.print("aaaaaaaaaaa" + x);consumer.accept(1000.0);Supplier<Integer> sup = () -> (int) (Math.random() * 100);//返回100内的随机数Integer in = sup.get();Function<String, String> fun1 = x -> x.trim();String res = fun1.apply("1111");Function<String, Integer> fun = x -> Integer.parseInt(x);Integer res2 = fun.apply("1111");Predicate<String> pre = x -> x.length() > 9;Boolean bo = pre.test("101111");//方法引用三种使用情况=============================//lambda体中的内容有方法已经实现//方法体的实现 引用指向一个已经实现的方法//前面的 函数式接口 的 参数列表(数量 类型) 和返回值 和具体的实现方法体 的参数 和返回值 一致// 可以使用方法引用//1 对象:: 实例方法名 非静态Consumer<String> con = x -> System.out.println("aaaaaaaaaaa" + x);con.accept("1000.0");Consumer<String> con2 = System.out::println;con2.accept("aaaaaaaaaaa" + "1000.0");//2 类 :: 静态方法名Comparator<Integer> com = (x, y) -> Integer.compare(x, y);int a = com.compare(10, 20);Comparator<Integer> com2 = Integer::compare;int a2 = com2.compare(10, 20);//3 类 :: 实例方法名 x作为调用者 y为参数BiPredicate<String, String> bp = (x, y) -> x.equals(y);bp.test("nihao", "你好");BiPredicate<String, String> bp2 = String::equals;bp2.test("nihao", "你好");
//================================
// 构造器引用 className::new
// get()无参数 对应无参数构造器
// get() 一个参数对应构造器一个参数Supplier<myclass> supplier = () -> new myclass();Supplier<myclass> supplier2 = myclass::new;myclass mc = supplier2.get();Supplier<ArrayList> supplier3 = ArrayList::new;List<String> list = supplier3.get();Function<String, myclass> ff1 = x -> new myclass(x);ff1.apply("wn1");Function<String, myclass> ff2 = myclass::new;myclass my = ff2.apply("wn2");
// 数组引用 Type::newFunction<Integer, String[]> f1 = x -> new String[x];String[] strs = f1.apply(10);Function<Integer, String[]> f2 = String[]::new;String[] strs2 = f2.apply(10);
// 线程实例化 runnable 无参无返回值Thread t = new Thread(()->{});t.start();
// Stream ====================
// 1原数据源(集合 数组) 不变 2转化成流Stream 3流水线式的中间操作 4终止操作 生成新的数据源(集合 数组)
// 1 创建Stream 2 中间操作 3终止操作
// 1 Collection系列集合提供的 stream()串行流 或者 parallelStream()并行流List<String> list_s = new ArrayList<>();list_s.add("11");list_s.add("22");list_s.add("33");list_s.add("44");list_s.removeIf(x -> x.length() > 4);//满足条件则删除Stream<String> st = list_s.stream();
// 2 Stream中的静态方法Stream.of() 数组也可以Stream<String> st1 = Stream.of("a", "b");Stream<String> st11 = Stream.of(strs);// 3 Arrays 中静态方法Arrays.stream()获取数组流Stream<String> st2 = Arrays.stream(strs);
// 4 创建无限流
// 迭代Stream<Integer> st3 = Stream.iterate(0, x -> x + 2);st3.limit(5).forEach(System.out::println);
// 生成Stream<Double> st4 = Stream.generate(() -> Math.random());
// 一 筛选与切片 ===========
// 1 排除 filter(Predicate<T>)// 中间操作 不执行任何处理且没有任何结果
// 内部迭代 Stream API完成迭代Stream<String> new1 = st.filter(x -> x.equals("11"));
// 终止才 执行全部内容且有结果 叫做 惰性求值new1.forEach(System.out::println);
// 2 limit() 截断流 使元素不超过指定数量
// 只执行 目标数据操作 不执行其他 短路 2 只执行俩
// 3 skip(n) 跳过元素 扔掉前n个不要 执行后面的,总数不足n返回一个空流
// 4 distinct 筛选 通过流生成元素的 重写 hashCode()和equals()去除重复元素new1.limit(1).skip(1).distinct().forEach(System.out::println);
// 二 映射 =================
// map 接受lambda 将元素转换成其他形式或者提取信息
// 将流中每一个元素 用在传递的函数上 生成新流List<String> list2 = Arrays.asList("aa", "bb", "cc", "dd", "ee");list2.stream().map(x -> x.toUpperCase()).forEach(System.out::println);List<myclass> mylist = new ArrayList<>();mylist.stream().map(myclass::getName);//提取信息
// flatMap 接收一个函数作为参数,将流中每一个值都转换为另一个流
// 然后把所有流都连城一个流
// list2.stream().map(x -> filterCharacter(x));Stream<Stream<Character>> st_ch = list2.stream().map(myclass::filterCharacter);st_ch.forEach(x -> x.forEach(System.out::println));
// flatMap map{{aaa},{bbb},{ccc}} flatMap{aaabbbccc}添加子流中元素所有流都连城一个流 最后变一个
// 类似 list中 add addAllStream<Character> st_ch2 = list2.stream().flatMap(myclass::filterCharacter);
// 三 排序======================
// sorted(Comparable) --自然排序 由小到大 字母顺序拍list2.stream().sorted();
// sorted(Comparator com)--定制排序 指定条件 然后排序mylist.stream().sorted((my1, my2) -> {if (my1.getAge() == my2.getAge()) {
// 年龄相同按名字排return my1.getName().compareTo(my2.getName());} else {
// 不相同安年龄排 年龄降序my2.getAge()- my1.getAge()return (my1.getAge() + "").compareTo((my2.getAge() + ""));}});
// 终止操作==============================
// 查找与匹配
// allMatch --检查是否匹配所有元素
// 全部都是 返回truemylist.stream().allMatch(x -> x.getStatus().equals(Status.BUSY));
// anyMatch--检查是否至少匹配一个元素
// 有一个就可以 truemylist.stream().anyMatch(x -> x.getStatus().equals(Status.BUSY));
// noneMatch--检查是否没有匹配所有元素
// 全部都不是 返回truemylist.stream().noneMatch(x -> x.getStatus().equals(Status.VOCATION));
// findFirst--返回第一个元素 Optional 避免为空Optional<myclass> myfirst = mylist.stream().sorted((my1, my2) -> Integer.compare(my1.getAge(), my2.getAge())).findFirst();myclass myf = myfirst.get();
// findAndy--返回当前流中任意元素Optional<myclass> myAny = mylist.stream().filter(x -> x.getStatus().equals(Status.Free)).findAny();
// count--返回流中元素中和long count = mylist.stream().count();
// max--返回流中最大值 类似 sorted(Comparator com)--定制排序 指定条件 然后排序Optional<myclass> myMax = mylist.stream().max((my1, my2) -> Integer.compare(my1.getAge(), my2.getAge()));
// min--返回流中最小值Optional<myclass> myMin = mylist.stream().min((my1, my2) -> Integer.compare(my1.getAge(), my2.getAge()));
// mylist.stream().map(myclass::getAge)
// .min((x,y) ->Integer.compare(x,y))Optional<Integer> opInt = mylist.stream().map(myclass::getAge).min(Integer::compare);int opi = opInt.get();
// 规约 reduce 将流中元素反复结合起来得到一个值List<Integer> list3 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 0为起始值 1作为Y 0+ 1 然后 作为x 2作为y 继续到底Integer sum = list3.stream().reduce(0, (x, y) -> x + y);
// mylist 中年龄总和Integer allAge = mylist.stream().map(myclass::getAge).reduce(0, (x, y) -> x + y);
// 没有起始值 可能为空 所以返回OptionalOptional<Integer> allAge2 = mylist.stream().map(myclass::getAge).reduce((x, y) -> x + y);Optional<Integer> allAge3 = mylist.stream().map(myclass::getAge).reduce(Integer::sum);allAge3.get();
// 收集 collect 将流转换为其他形式 接受一个Collector接口 给Stream中元素做汇总
// 提取 名字 添加到集合中 collectors里面静态方法 Collectors.toList()List<Integer> newList = mylist.stream().map(myclass::getAge).collect(Collectors.toList());newList.forEach(System.out::println);
// set中Set<String> newset = mylist.stream().map(myclass::getName).collect(Collectors.toSet());
// 生成指定的 类型HashSet<String> newHashSet = mylist.stream().map(myclass::getName).collect(Collectors.toCollection(HashSet::new));
// 总数long count2 = mylist.stream().collect(Collectors.counting());
// 平均值Double aver = mylist.stream().collect(Collectors.averagingDouble(myclass::getAge));
// 总和Double summ = mylist.stream().collect(Collectors.summingDouble(myclass::getAge));
// Double summ2 = mylist.stream().collect(Collectors.summingDouble(new ToDoubleFunction<myclass>() {
// @Override
// public double applyAsDouble(myclass value) {
// return value.getAge();
// }
// }));Double summ3 = mylist.stream().map(myclass::getAge).collect(Collectors.summingDouble(x -> x));
// Double summ4 = mylist.stream().map(myclass::getAge).collect(Collectors.summingDouble
// (new ToDoubleFunction<Integer>() {
// @Override
// public double applyAsDouble(Integer value) {
// return value;
// }
// }));
// 最大值 orted(Comparator com)--定制排序 max min maxBy minByOptional<myclass> myMax_ = mylist.stream().max((my1, my2) -> Integer.compare(my1.getAge(), my2.getAge()));Optional<myclass> myMax2 = mylist.stream().collect(Collectors.maxBy((x, y) -> Integer.compare(x.getAge(), y.getAge())));
// 最小值Optional<Integer> myMMin2 = mylist.stream().map(myclass::getAge).collect(Collectors.minBy(Integer::compare));
// 分组 安状态分组Map<Status, List<myclass>> map = mylist.stream().collect(Collectors.groupingBy(myclass::getStatus));
// 遍历map
// 多级分组Map<Status, Map<String, List<myclass>>> map2 = mylist.stream().collect(Collectors.groupingBy(myclass::getStatus,Collectors.groupingBy(x -> {if (x.getAge() <= 35) {return "青年";} else if (x.getAge() <= 50) {return "中年";} else {return "老年";}})));
// 分区 分为 true false 俩区Map<Boolean, List<myclass>> map3 = mylist.stream().collect(Collectors.partitioningBy(x -> x.getAge() > 100));
// 另外一种方式获取DoubleSummaryStatistics ss = mylist.stream().collect(Collectors.summarizingDouble(myclass::getAge));ss.getSum();ss.getAverage();ss.getMax();
// 连接字符串String str4 = mylist.stream().map(myclass::getName).collect(Collectors.joining());// 连接字符串时加 ,String str5 = mylist.stream().map(myclass::getName).collect(Collectors.joining(","));
// 连接字符串时加 , 头部加=== 尾部加===String str6 = mylist.stream().map(myclass::getName).collect(Collectors.joining(",", "===", "==="));
//parallelStream 并行流
// 切换并行流parallel() 切换顺序流sequential()LongStream.rangeClosed(0, 100000000L).parallel().reduce(0, Long::sum);
// Optional 类 避免空指针 快速锁定 null位置Optional<myclass> op = Optional.of(new myclass());myclass myop = op.get();
// of不能为空 empty()为空 ofNullable()参数不为空 创建of 为空 创建空emptyop.isPresent();//是否包含值 booleanop.orElse(new myclass());//有值获取 没值 获取默认的new myclass()myclass my4 = op.orElseGet(() -> new myclass());//有值获取 没值 获取默认的 函数式接口中的 new myclass()Optional<String> name = op.map(myclass::getName);//有值 map处理 没有empty();//flatMap 里面 function接口返回值必须是optionalOptional<String> flatop = op.flatMap(e -> Optional.ofNullable(e.getName()));
//避免空指针 每次 if判断
// Optional<myclass> op1 = Optional.ofNullable(null);Optional<Godness> gd = Optional.ofNullable(new Godness("andy"));Optional<myclass> op1 = Optional.ofNullable(new myclass(gd));op1.orElse(new myclass())//没有构造函数赋值 则是Optional empty.getGodness().orElse(new Godness("aa")).getName();
//========================
// 全新的时间日期 API 之前的 线程不安全
// 1 LocalDate LocalTime LocalDateTime 人看的时间LocalDateTime ldt = LocalDateTime.now();LocalDateTime ldt2 = LocalDateTime.of(2021, 10, 19, 13, 22, 33);LocalDateTime ldt3 = ldt.plusYears(2);//加两年 新实例ldt.minusMonths(2);//减俩月ldt.getYear();//获取年ldt.getMonthValue();//获取月ldt.getDayOfMonth();//获取日ldt.getHour();//获取时ldt.getMinute();//获取分ldt.getSecond();//获取秒
// 2 Instant 时间戳 1970年1月1号00:00:00 -现在毫秒值Instant ins = Instant.now();//默认 UTC时区 跟中国差8 现在时间ins.toEpochMilli(); //毫秒OffsetDateTime ofd = ins.atOffset(ZoneOffset.ofHours(8));//偏移量运算Instant.ofEpochSecond(60);//1970年1月1号00:00:00 加 60秒
// Duration 时间间隔Instant ins2 = Instant.now();Duration du = Duration.between(ins, ins2);du.getSeconds();du.toDays();LocalTime ldt4 = LocalTime.now();LocalTime ldt5 = LocalTime.now();Duration du2 = Duration.between(ldt4, ldt5);du2.toMillis();
// Period 日期之间的间隔LocalDate ld = LocalDate.of(2015, 1, 1);LocalDate ld2 = LocalDate.now();Period pd = Period.between(ld, ld2);pd.getMonths();
// TemporalAdjuster 时间矫正器LocalDateTime ldt6 = LocalDateTime.now();LocalDateTime ldt7 = ldt6.withDayOfMonth(10);//指定月为10月ldt6.with(TemporalAdjusters.next(DayOfWeek.MONDAY));//指定下一个周一
//自定义 下一个工作日ldt6.with(x -> {LocalDateTime l = (LocalDateTime) x;DayOfWeek day = l.getDayOfWeek();if (day.equals(DayOfWeek.FRIDAY)) {return l.plusDays(3);} else if (day.equals(DayOfWeek.SATURDAY)) {return l.plusDays(2);} else {return l.plusDays(1);}});
// DateTimeFormatter 格式化时间日期LocalDateTime ldt8 = LocalDateTime.now();DateTimeFormatter df = DateTimeFormatter.ISO_DATE_TIME;String date = ldt8.format(df);
// 指定自己DateTimeFormatter df2 = DateTimeFormatter.ofPattern("yyyy年MM月DD日HH:MM:SS");String date2 = ldt8.format(df2);
// 字符串 to时间LocalDateTime strdate = LocalDateTime.parse(date2, df2);
// 时区 指定时区LocalDateTime ldt9 = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));ZonedDateTime zdt = ldt9.atZone(ZoneId.of("Asia/Shanghai"));
//}interface MyFun3<T, U, R> {public R getStr(T t1, U t2);//default 默认方法
// 1 类优先原则 优先选择父类的同名方法 后接口中
// 2 实现多个接口 有同名 同参数方法 实现类中要明确是那个接口的default String getName() {return "aaaa";}// 静态方法public static void show() {}}public static Stream<Character> filterCharacter(String str) {List<Character> list = new ArrayList<>();for (Character ch : str.toCharArray()) {list.add(ch);}return list.stream();}public String getString(String str, MyFun<String> myfun) {return myfun.getStr(str);}private void op(Long a, Long b, MyFun2<Long, Long, Long> mf) {mf.getStr(a, b);}
}
//函数式 接口 只有一个抽象方法
@FunctionalInterface
interface MyFun<T> {public T getStr(T t);
}
interface MyFun2<T, U, R> {public R getStr(T t1, U t2);
}**
Java 8 新特性 lambda表达式相关推荐
- Java 8 新特性Lambda 表达式
Java 8 新特性Lambda 表达式 一.常用循环 二.匿名内部类 三.排序集合 四.循环打印对象 五.根据条件修改 六.排序 七.求和 八.统计方法 九.材料 一.常用循环 public cla ...
- 【Java】Java 8 新特性-----Lambda 表达式
一.Lambda 表达式的主要改进点 Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性. Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中). 使用 ...
- java lambda表达式详解_Java8新特性Lambda表达式详解
课程目标: 通过本课程的学习,详细掌握Java8新特性之Lambda表达式: 适用人群:有Java基础的开发人员: 课程概述:从Java 8出现以来lambda是最重要的特性之一,它可以让我们用简洁流 ...
- java新特性lambda表达式快速入门
文章目录 序 常规写法 写法一:新建类并实现该接口 写法二:使用匿名函数 lambda写法 写法一:lambda常规写法 写法二:lambda简写 中场疑问 lambda的方法引用 写法一 写法二 练 ...
- Java8新特性----Lambda表达式详细探讨
Java8新特性 Lambda表达式 入门演示 案例1 如何解决 cannot be cast to java.lang.Comparable问题? 案例2 优化方式一 : 策略设计模式 优化方式二: ...
- C++11新特性——λ(lambda)表达式详解
C++11新特性--λ(lambda)表达式 C++11中引入了λ表达式,它可以用来定义一个内联(inline)的函数,作为一个本地的对象或者一个参数.有了λ表达式,我们可以很方便的使用stl标准库. ...
- java三目表达式_Java8新特性Lambda表达式
1 Lambda表达式 对于很多计算机语言来说,Lambda表达式并不是陌生的语法格式,而对于Java而言,它的到来比较晚,直到Java8更新之后,Lambda表达式才正式出现在Java语法中.所以如 ...
- 【Java】jdk 1.8 新特性——Lambda表达式
Lambda表达式 jdk 1.8 新加入的特性,简化了简单接口的实现 函数式接口 函数式中只有一个待实现的方法,可以使用@FunctionalInterface注解标注函数式接口.这个接口中只能有一 ...
- java thread lambda_Java8新特性--Lambda表达式
从java8出现以来lambda是最重要的特性之一,它可以让我们用简洁流畅的代码完成一个功能. 很长一段时间java被吐槽是冗余和缺乏函数式编程能力的语言,随着函数式编程的流行java8种也引入了 这 ...
最新文章
- 网络爬虫-自动推送小说最新章节的小应用--懒惰的追小说者
- 双链表的创建，求长，插入，删除，打印，释放（循环和非循环）
- python003 一 Python起步、pyhthon运行方式、语法结构、python变量
- JSON.stringify()还可以这么用
- Ouroboros：一个可证明安全的PoS区块链协议 （共识介绍）
- python日期格式转换_python中有关时间日期格式转换问题
- Django------多表操作
- 计算机固态加机械硬盘,笔记本装固态硬盘和机械硬盘双硬盘
- 寻址方式(立即寻址、直接寻址、间接寻址、寄存器寻址、寄存器间接寻址）
- oracle01004,Oraclegoldengate的OGG-01004OGG-1296错误
- 因果效应,典型模型及wasserstein距离, BNN,CFR,SITE,NetDeconf
- 25款经典老芯片，认识5款以上的工程师证明你老了！
- PP-YOLOE论文解析
- 杨辉三角 c语言 二维数组
- 香港主要房产公司计划寻求监管机构对代币化房地产的许可
- 机器学习之K-Means
- 教你使用华为Ensp模拟器配置OSPF路由协议(二)
- 华为S2300系列交换机忘了console登录密码怎么办？
- python 字典的值可以为集合吗_Python 集合（Set）、字典（Dictionary）
- Android so导入表,Android so注入(inject)和Hook技术学习（二）——Got表hook之导入表hook...