Java8新特性/java

news/2024/11/8 3:42:54/

1.lambda表达式

区别于js的箭头函数，python、cpp的lambda表达式，java8的lambda是一个匿名函数，java8运行把函数作为参数传递进方法中。

  • 语法格式

    (parameters) -> expression 或
(parameters...) ->{ statements; }

  • 实战

    1. 替代匿名内部类：java8之前如果想把方法传给函数(动态传递参数)，那么需要匿名内部类

      • Runnable接口

        java">new Thread(new Runnable() {@Overridepublic void run() {System.out.println("The runable now is using!");}
}).start();
//用lambda
new Thread(() -> System.out.println("It's a lambda function!")).start();
        特性静态传参动态传参
        参数数量固定：编译时确定可变：调用时可以变化
        方法定义参数数量和类型明确指定参数用 ... 形式声明，数量可变
        适用场景当参数数量固定时当参数数量不确定时
        调用方式需要按照方法定义传递确切的参数数量可以传递任意数量的同类型参数
        例子void method(int a, int b)void method(int... numbers)

      • Comparator 接口

        java">List<Integer> strings = Arrays.asList(1, 2, 3);Collections.sort(strings, new Comparator<Integer>) {
@Overridepublic int compare (Integer o1, Integer o2) {return o1 - o2;}
}Collections.sort(strings, (Integer o1, Integer o2) -> o1 - o2);

      • Listener接口

        java">JButton button = new JButton();
button.addItemListener(new ItemListener() {
@Override
public void itemStateChanged(ItemEvent e) {e.getItem();
}
});
//lambda
button.addItemListener(e -> e.getItem());

      • 不难发现这些匿名内部类只重写了接口的一个方法，当然也只有一个方法要重写。这就是上文提到的函数式接口，也就是说只要方法的参数是函数式接口就可以用lambda表达式。

      • 自定义一个，java中的lambda就是减少实例化类这一步

        java">public class lambda {@FunctionalInterfacepublic interface LambdaInterface {void f();}//使用public static class LambdaClass {public static void forEg() {lambdaInterfaceDemo(() -> System.out.println("自定义函数式接口"));}//函数式接口参数static void lambdaInterfaceDemo(LambdaInterface i) {i.f();}}public static void main(String[] args) {LambdaClass.forEg();}
}

    2. 集合迭代

      java">void lamndaFor() {List<String> strings = Arrays.asList("1", "2", "3");//传统foreachfor (String s : strings) {System.out.println(s);}//Lambda foreachstrings.forEach((s) -> System.out.println(s));//orstrings.forEach(System.out::println);//mapMap<Integer, String> map = new HashMap<>();map.forEach((k,v)->System.out.println(v));
}

    3. 方法的引用

      • 静态方法的引用

        类名::静态方法

        java">package lambda;import java.util.Arrays;public class reference {public static void main(String[] args) {Student[] s = new Student[6];s[0] = new Student("张三", 18, "男", "北京");s[1] = new Student("李四", 19, "男", "上海");s[2] = new Student("王五", 20, "男", "广州");s[3] = new Student("赵六", 21, "男", "深圳");s[4] = new Student("孙七", 22, "男", "武汉");s[5] = new Student("周八", 23, "男", "西安");// lambda表达式，传入函数作为参数， 如果参数和调用的函数参数是一样的，才可以使用静态函数引用Arrays.sort(s, (o1, o2) -> o1.getAge() - o2.getAge());// 将类的静态方法作为引用，传送给函数式接口Arrays.sort(s, Student::compareByAge);}}

        java">package lambda;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {private String name;private int age;private String gender;private String address;public static int compareByAge(Student s1, Student s2){return s1.getAge() - s2.getAge();}
}

        实例方法

        java">package lambda;import java.util.Arrays;public class reference {public static void main(String[] args) {Student[] s = new Student[6];s[0] = new Student("张三", 18, "男", "北京");s[1] = new Student("李四", 19, "男", "上海");s[2] = new Student("王五", 20, "男", "广州");s[3] = new Student("赵六", 21, "男", "深圳");s[4] = new Student("孙七", 22, "男", "武汉");s[5] = new Student("周八", 23, "男", "西安");// lambda表达式，传入函数作为参数， 如果参数和调用的函数参数是一样的，才可以使用静态函数引用Arrays.sort(s, (o1, o2) -> o1.getAge() - o2.getAge());Student s1 = new Student();// 将类的静态方法作为引用，传送给函数式接口Arrays.sort(s, s1::compareByAge);}}

        特定类的调用

        java">public void Demo3 {public static void main(String[] args) {String[] names = {"Tom", "Cat", "Jerry"};}// Arrays.sort(names); // 默认按照首字母的升序排序// 忽略字母大小写升序  如果是特定类型的实例方法，以及是对应类方法// Arrays.sort(names, (o1, o2) -> o1.compareToIgnore(o2));Arrays.sort(names, String::compareToIgnore);System.out.println(Array.toString(names));
}

        构造方法

        在这里插入图片描述

        java">class Car{String name;String getName() {return this.name;}
}interface CarFactory {Car getCar(String name);
}
// CarFactory cf = new CarFactory {
//	@override
//	public Car getCar(String name);
//		return new Car(name);
//}
// CarFactory cf = name -> new Car(name);CarFactory cf = Car::new;
Car c1 = cd.getCar();

  • 这些方法是可遇不可求的，一般都是重构写出来的代码。

2.Interface

背景：

  1. 传统接口的缺点：

    • 一旦接口需要修改或增加方法，实现该接口的所有类都需要进行改动**。例如，假设 Animal 接口增加了一个新的方法 eat()，那么所有已经实现 Animal 接口的类 (Dog、Cat 等) 都必须去实现这个新增加的方法，否则代码会报错。

    • 这给代码的维护和扩展带来了很大的问题，尤其当你有很多实现类时，修改接口将变得代价非常高昂。

  2. default修饰的方法，是普通的实例方法，可以用this调用，也可以被子类继承、重写。

  3. static修饰的方法，使用上和一般的类静态方法一样。但它不能被子类继承、重写。

  4. private修饰的方法，接口内部类才可以使用

​ 例子：

java">public interface InterfaceNew {static void sm() {System.out.println("interface提供的方式实现");}static void sm2() {System.out.println("interface提供的方式实现");}default void def() {System.out.println("interface default方法");}default void def2() {System.out.println("interface default2方法");}//须要实现类重写void f();
}public interface InterfaceNew1 {default void def() {System.out.println("InterfaceNew1 default方法");}
}

因为两个接口没有继承关系，如果不重写def函数会编译出错

public class InterfaceNewImpl implements InterfaceNew , InterfaceNew1{public static void main(String[] args) {InterfaceNewImpl interfaceNew = new InterfaceNewImpl();interfaceNew.def();}@Overridepublic void def() {InterfaceNew1.super.def();}@Overridepublic void f() {}
}
  1. 抽象类和接口的区别

  • interface 和 class 的区别，好像是废话，主要有：

    • 接口多实现，类单继承
    • 接口的方法是 public abstract 修饰，变量是 public static final 修饰。 abstract class 可以用其他修饰符

  • interface 的方法是更像是一个扩展插件。而 abstract class 的方法是要继承的。

  1. functional interface接口
    • 也称SAM接口，既只有一个抽象方法的接口，在java8中有一个专门存放函数式接口的包java.util.function，该包下的所有接口都有@FunctionalInterface注解，提供函数式编程，提醒编译器，如果不是SAM接口解报错。

3.stream流

在这里插入图片描述

  • 实例

    java">package stream;import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;public class demo1 {public static void main(String[] args) {// 目标：认证stream流List<String> list = new ArrayList<>();list.add("hello");list.add("world");list.add("java");list.add("hello");list.add("hello");// 1.常规方法List<String> newList = new ArrayList<>();for (String name : list) {if (name.startsWith("h") && name.length() != 1) {newList.add(name);}}System.out.println(newList);// 2.stream流List<String> list2 =  list.stream().filter(name -> name.startsWith("h")).filter(name -> name.length() != 1).collect(Collectors.toList());System.out.println("------------------");System.out.println(list2);}
}

在这里插入图片描述

3.1获取Stream流

  • Stream流是一个接口

    在这里插入图片描述

    java">package stream;import java.util.*;
import java.util.stream.Stream;public class demo2 {public static void main(String[] args) {// 1.获取stream流// 获取集合里的stream流可以调用stream方法List<String> list = new ArrayList<>();Stream<String> s1 = list.stream();// 2.mapMap<String, Integer> map = new HashMap<>();// 获取键流Stream<String> s2 = map.keySet().stream();// 获取值流Stream<Integer> s3 = map.values().stream();// 获取键值对流  entrySet把map转为set集合Stream<Map.Entry<String, Integer>> s4 = map.entrySet().stream();Set<Map.Entry<String, Integer>> test = new HashMap<String, Integer>().entrySet();// 3.数组 两种方式String[] arr = {"hello", "world", "java"};Stream<String> s5 = Arrays.stream(arr);System.out.println(s5.count());  // 计数System.out.println(s5.max(Comparator.comparingInt(String::length)));Stream<String> s6 = Stream.of("hello", "world", "java");}
}

3.2处理stream流

在这里插入图片描述

  • 返回值是一个新流

    java">package stream;import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;public class demo3 {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("hello");list.add("world");list.add("java");list.add("hello");// 1.过滤方法    foreach将每个遍历出的元素塞给方法内。list.stream().filter(name -> name.startsWith("h") && name.length() != 1).forEach(System.out::println);// 2.排序方法List<Double> list1 = new ArrayList<>();list1.add(1.2);list1.add(2.3);list1.add(3.4);list1.add(1.2);// double可以排是因为里面实现了compare方法  默认是升序list1.stream().sorted().forEach(System.out::println);System.out.println("------------------");list1.stream().sorted((s1, s2) -> Double.compare(s2, s1)).forEach(System.out::println);// 只要前两名System.out.println("------------------");list1.stream().sorted().limit(2).forEach(System.out::println);// 跳过前两名System.out.println("------------------");list1.stream().sorted().skip(2).forEach(System.out::println);// 去重 如果需要自定义对象能够去重要重写hashCode和equals方法System.out.println("------------------");list.stream().distinct().forEach(System.out::println);// 映射方法， 把原来的数据拿出来加工并返回新流System.out.println("------------------");list1.stream().map(s -> s * 2).forEach(System.out::println);// 合并List<String> list2 = new ArrayList<>();list2.add("hello");list2.add("world");list2.add("java");Stream<String> list3 = list2.stream();Stream<String> list4 = list2.stream();Stream<String> s3 = Stream.concat(list4, list3);System.out.println(s3.count());}
}

  • 如果需要自定义对象能够去重要重写hashCode和equals方法

  • 映射方法， 把原来的数据拿出来加工并返回新流

  • 都是一个个方法，记住就好，看源码收益低

3.3终结stream流

在这里插入图片描述

  • 抽象方法就是没实现的方法

    java">package stream;import java.util.ArrayList;
import java.util.List;
import java.util.Optional;public class demo4 {public static void main(String[] args) {// 创建一个教师列表并添加教师对象List<Teacher> teachers = new ArrayList<>();teachers.add(new Teacher("张三", 18, 3000));teachers.add(new Teacher("李四", 19, 4000));teachers.add(new Teacher("王五", 20, 5000));teachers.add(new Teacher("赵六", 21, 6000));teachers.add(new Teacher("钱七", 22, 7000));// 使用流的收集操作：// 过滤出工资大于4000的教师，并打印他们的信息teachers.stream().filter(teacher -> teacher.getSalary() > 4000) // 过滤条件.forEach(System.out::println); // 打印符合条件的教师，自动调用toString方法// countlong count = teachers.stream().filter(teacher -> teacher.getSalary() > 4000).count();System.out.println("~~~~~~~~~~~~~~");// 放到Optional<T>中防止空指针异常Optional<Teacher> max = teachers.stream().max(Teacher::compareTo);Teacher teacher = max.get();System.out.println(teacher.getName() + " " + teacher.getAge() + " " + teacher.getSalary());}
}

在这里插入图片描述

  • 添加到集合中

    java">package stream;import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class demo4 {public static void main(String[] args) {// 收集到数组或者集合上List<String> test = new ArrayList<>();test.add("hello");test.add("world");Stream<String> s1 = test.stream().filter(s -> s.length() > 1);// 收集到List集合// Collectors.toList()返回一个ArrayList对象，明确调用了一个Collector的实现，明确使用ArrayList调用方法List<String> list = s1.collect(Collectors.toList());System.out.println(list);System.out.println("~~~~~~~~~~~~~~");// 收集到Set集合，流终止后不能再使用List<String> test2 = new ArrayList<>();test2.add("hello");test2.add("world");Set<String> set = test2.stream().filter(s -> s.length() > 1).collect(Collectors.toSet());System.out.println(set);// 收集到数组中 两个版本的toArray，参数是数组的构造器，默认返回的类型是Object[]Stream<String> s2 = test2.stream().filter(s -> s.length() > 1);String[] arr = s2.toArray(String[]::new);// Objects[] arr1 = s2.toArray();System.out.println(Arrays.toString(arr));// 收集到Map集合中，需要指定key和value的类型，否则会报错List<Teacher> list2 = new ArrayList<>();list2.add(new Teacher("张三", 18, 3000));list2.add(new Teacher("李四", 19, 4000));list2.add(new Teacher("王五", 20, 5000));list2.add(new Teacher("赵六", 21, 6000));list2.add(new Teacher("钱七", 22, 7000));Map<String, Integer> map = list2.stream().collect(Collectors.toMap(Teacher::getName, Teacher::getAge));System.out.println(map);}
}

  • 在这里插入图片描述

  • 可以看到toList调用的是ArrayList

  • 每个方法都有默认的构造方法，按需调用即可


http://www.ppmy.cn/news/1545245.html

相关文章

MySQL 批量删除海量数据的几种方法

MySQL 批量删除海量数据的几种方法

目录 一、问题分析 二、批量删除海量数据的几种方法 方法 1&#xff1a;使用 LIMIT 分批删除 方法 2&#xff1a;通过主键范围分批删除 方法 3&#xff1a;通过自定义批量删除存储过程 方法 4&#xff1a;创建临时表替换旧表 三、性能优化建议 总结 在数据库的日常维护…
阅读更多...
用图说明 CPU、MCU、MPU、SoC 的区别

用图说明 CPU、MCU、MPU、SoC 的区别

CPU CPU 负责执行构成计算机程序的指令&#xff0c;执行这些指令所指定的算术、逻辑、控制和输入/输出&#xff08;I/O&#xff09;操作。 MCU (microcontroller unit) 不同的 MCU 架构如下&#xff0c;注意这里的 MPU 表示 memory protection unit MPU (microprocessor un…
阅读更多...
鸿蒙进阶篇-网格布局 Grid/GridItem（二）

鸿蒙进阶篇-网格布局 Grid/GridItem（二）

hello大家好&#xff0c;这里是鸿蒙开天组&#xff0c;今天让我们来继续学习鸿蒙进阶篇-网格布局 Grid/GridItem&#xff0c;上一篇博文我们已经学习了固定行列、合并行列和设置滚动&#xff0c;这一篇我们将继续学习Grid的用法&#xff0c;实现翻页滚动、自定义滚动条样式&…
阅读更多...
配置文件中spring.main.allow-bean-definition-overriding属性

配置文件中spring.main.allow-bean-definition-overriding属性

spring.main.allow-bean-definition-overriding属性是SpringBoot应用中的一个关键配置&#xff0c;它决定了是否允许在Spring容器中存在名称相同的Bean定义覆盖。以下是对该属性的详细介绍&#xff1a; 一、属性作用 • 控制Bean定义覆盖&#xff1a;当多个配置类或组件定义了…
阅读更多...
OpenResty 1.27.1.1 已经正式发布

OpenResty 1.27.1.1 已经正式发布

OpenResty 1.27.1.1 已经正式发布&#xff0c;这是一个基于 NGINX 和 LuaJIT 的 web 平台。以下是关于此次发布的一些重点信息和更新内容&#xff1a; 下载与安装 你可以在此处下载最新版本的 OpenResty。提供了便携式源代码分发、Win32/Win64 二进制分发以及为 Ubuntu、Debi…
阅读更多...
掌握 PyQt5：从零开始的桌面应用开发

掌握 PyQt5：从零开始的桌面应用开发

PyQT5——图形化界面 文章目录 PyQT5——图形化界面集成化图形界面工具为什么使用 \$ProjectFileDir$?示例场景其他 Varaiablespyuic参数解释整体含义示例使用PyQt5和pyuic 创建pyqt5的程序创建一个窗口app.exec\_()和sys.exit(app.exec_())的区别1. app.exec_()2. sys.exit(a…
阅读更多...
论文 | Legal Prompt Engineering for Multilingual Legal Judgement Prediction

论文 | Legal Prompt Engineering for Multilingual Legal Judgement Prediction

这篇文章探讨了如何利用“法律提示工程”&#xff08;LPE&#xff09;来指导大型语言模型&#xff08;LLM&#xff09;进行多语言法律判决预测&#xff08;LJP&#xff09;。主要内容&#xff1a; LPE 的概念&#xff1a; LPE 是指通过设计特定的提示&#xff08;promp…
阅读更多...
WebSocket实现消息实时推送

WebSocket实现消息实时推送

文章目录 websocket介绍特点工作原理 用websocket实现实时推送引入依赖WebSocket 函数定义变量声明初始化 WebSocket 连接WebSocket 连接的初始化和事件处理连接打开事件接收消息处理连接关闭和重连机制心跳机制使用 WebSocket代码完整显示 websocket介绍 WebSocket 是一种网络…
阅读更多...
最新文章

Copyright @ 2022~2023