首页 > 编程语言 >Java8知识梳理

Java8知识梳理

时间：2023-08-29 22:56:02浏览次数：45  
标签：Stream void 知识 System 梳理 public println Java8 out

Java 8 的改进

  • 速度更快
  • 代码更少（Lambda表达式）
  • 引入强大的Stream API
  • 便于并行
  • 最大化减少空指针异常（Optional）
  • Nashorn引擎，允许在JVM上运行js应用
  • 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。

一、Lambda 表达式

  • Lambda表达式的重要特征
  • 可选用类型声明：不需要声明参数类型，编译器可以统一识别参数值。
  • 可选用的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
  • 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
  • 可选的返回关键字：如果主体只有一个表达式，返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。（即return…）
  • Lambda表达式是对象，而不是函数。
  • Lambda表达式基本语法

  1. 举例：

    (o1,o2) -> Integer.compare(o1,o2);

  2. 格式：

  • -> ：lambda 操作符 或 箭头操作符
  • -> 左边：lambda 形参列表 （其实就是接口中的抽象方法的形参列表）
  • -> 右边：lambda 体（其实就是重写的抽象方法的方法体）
  • 举例
public class Java8Tester {
   public static void main(String args[]){
      Java8Tester tester = new Java8Tester();
        
      // 类型声明
      MathOperation addition = (int a, int b) -> a + b;
        
      // 不用类型声明
      MathOperation subtraction = (a, b) -> a - b;
        
      // 大括号中的返回语句
      MathOperation multiplication = (int a, int b) -> { return a * b; };
        
      // 没有大括号及返回语句
      MathOperation division = (int a, int b) -> a / b;
        
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));//10 + 5 = 15
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));//10 - 5 = 5
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));//10 x 5 = 50
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));//10 / 5 = 2
        
      // 不用括号
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
        
      // 用括号
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
        
      greetService1.sayMessage("Runoob");//Hello Runoob
      greetService2.sayMessage("Google");//Hello Google
   }
    
   interface MathOperation {
      int operation(int a, int b);
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }
    
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }
}

  • 变量作用域
  1. lambda 表达式只能引用标记了 final 的外层局部变量，即不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
public class Java8Tester {
    public static void main(String args[]) {
        final int num = 1;
        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));//访问外层的局部变量num
        s.convert(2);  // 输出结果为 3
    }
 
    public interface Converter<T1, T2> {
        void convert(int i);
    }
}
  1. lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）
int num = 1;  
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);
num = 5;  
//报错信息：Local variable num defined in an enclosing scope must be final or effectively final

  1. 在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

    String first = "";  
Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());  //编译会出错
  • Lambda表达式的本质：作为函数式接口的实例（关于函数式接口的概念在下一点）

二、函数式接口

  • 什么是函数式接口

​ 如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。在接口中加上@FunctionalInterface注解可以用于检验该接口是否为一个函数式接口。

  • 四大核心函数式接口

image-20200507110931093

public class LambdaTest3 {
    //消费型接口 Consumer<T>     void accept(T t)
    @Test
    public void test1() {
        //未使用Lambda表达式
        Learn("java", new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("学习什么？ " + s);
            }
        });
        System.out.println("====================");
        //使用Lambda表达
        Learn("html", s -> System.out.println("学习什么？ " + s));

    }

    private void Learn(String s, Consumer<String> stringConsumer) {
        stringConsumer.accept(s);
    }

    //供给型接口 Supplier<T>     T get()
    @Test
    public void test2() {
        //未使用Lambda表达式
        Supplier<String> sp = new Supplier<String>() {
            @Override
            public String get() {
                return new String("我能提供东西");
            }
        };
        System.out.println(sp.get());
        System.out.println("====================");
        //使用Lambda表达
        Supplier<String> sp1 = () -> new String("我能通过lambda提供东西");
        System.out.println(sp1.get());
    }

    //函数型接口 Function<T,R>   R apply(T t)
    @Test
    public void test3() {
        //使用Lambda表达式
        Employee employee = new Employee(1001, "Tom", 45, 10000);

        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));

    }

    //断定型接口 Predicate<T>    boolean test(T t)
    @Test
    public void test4() {
        //使用匿名内部类
        Function<Double, Long> func = new Function<Double, Long>() {
            @Override
            public Long apply(Double aDouble) {
                return Math.round(aDouble);
            }
        };
        System.out.println(func.apply(10.5));
        System.out.println("====================");

        //使用Lambda表达式
        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));

    }
}
  • 其他函数式接口

微信图片_20230729162030


三、方法引用

  • 方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法。（Lambda表达式深层次的表达）

  • 当要传递给Lambda体的操作，已经有实现的方法了，就可以使用方法引用。

  • 4种不同方法的引用

现有一个Car类如下：

@FunctionalInterface
public interface Supplier<T> {
 T get();
}

class Car {
 //Supplier是jdk1.8的接口，这里和lamda一起使用了
 public static Car create(final Supplier<Car> supplier) {  //静态方法
     return supplier.get();
 }

 public static void collide(final Car car) {  //静态方法
     System.out.println("Collided " + car.toString());
 }

 public void follow(final Car another) {  //非静态方法
     System.out.println("Following the " + another.toString());
 }

 public void repair() {  //非静态方法
     System.out.println("Repaired " + this.toString());
 }
}

  1. 构造器引用：Class::new

    final Car car = Car.create( Car::new );
final List< Car > cars = Arrays.asList( car );

  2. 静态方法引用：Class::static_method

    cars.forEach( Car::collide );

  3. 特定类的任意对象的方法引用：Class::method

    cars.forEach( Car::repair );

  4. 特定对象的方法引用：instance::method

    final Car police = Car.create( Car::new );
cars.forEach( police::follow );

  • 数组引用

    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

  • Java8中有两大最为重要的改变。第一个是Lambda 表达式；另外一个则是Stream API。

  • Stream API ( java.util.stream)把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

  • Stream 是Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用SQL 执行的数据库查询。也可以使用Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

  • 为什么要使用Stream API：实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。

  • Stream 和Collection 集合的区别：Collection 是一种静态的内存数据结构，而Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU 实现计算。

  • 注意

    1. Stream自己不会存储元素
    2. Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。
    3. Stream操作是延迟执行的。

  • Stream的操作三个步骤

  1. Stream的实例化：一个数据源（如集合、数组），获取一个流

    //创建Stream的方式一：通过集合
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方式二：通过数组
public void test2(){
    int[] arr = new int[]{1, 2, 3, 4, 5, 6};
    //调用Arrays类的static<T> Stream<T> stream(T[] array)：返回一个流
    IntStream stream = Arrays.stream(arr);//int数组

    Employee e1 = new Employee(1001, "Tom");
    Employee e2 = new Employee(1002, "Jerry");
    Employee[] arr1 = new Employee[]{e1, e2};
    Stream<Employee> stream2 = Arrays.stream(arr1);//Employee类数组
}

//创建Stream方式三：通过Stream的of()函数
public void test3(){
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);//这里的1~6不是int类型数据，而是一个包装类 
}

//创建Stream方式四：创建无限流
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)
    //输出10个随机数
    Stream.generate(Math::random).limit(10).forEach(System.out::println);
}
    • 顺序流与并行流的区别：顺序流的集合元素时按存入顺序储存的，取出时按顺序取出；并行流的集合元素是并行存储的，取出时是随机的。

  1. 一系列的中间操作：一个中间操作链，对数据源的数据进行处理。多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

    2.1 筛选与切片

    2_1

    public void test1(){
    List<Employee> employees = EmployeeData.getEmployees();
    Stream<Employee> employeeStream = employees.stream();

    //filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
    employeeStream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);//查询员工表中薪资大于7000的员工信息
    System.out.println();

    //limit(n)——截断流，使其元素不超过给定数量。
    employees.stream().limit(3).forEach(System.out::println);//因为上一条代码中的Stream已经执行了终止操作，所以不能使用【employeeStream.limit(3).forEach(System.out::println)】，而是要重新创建一个Stream
    System.out.println();

    //skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
    employees.stream().skip(3).forEach(System.out::println);
    System.out.println();

    //distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
    employees.add(new Employee(1010,"刘庆东",56,8000));
    employees.add(new Employee(1010,"刘庆东",56,8000));
    employees.add(new Employee(1010,"刘庆东",56,8000));
    employees.add(new Employee(1010,"刘庆东",56,8000));

    employees.stream().distinct().forEach(System.out::println);
}

    2.2 映射

    image-20200507115738168

    public void test2(){
    List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
    //map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
    list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
    //练习1：获取员工姓名长度大于3的员工的姓名。
    List<Employee> employees = EmployeeData.getEmployees();
    Stream<String> nameStream = employees.stream().map(Employee::getName);
    nameStream.filter(name -> name.length() >3).forEach(System.out::println);
    System.out.println();
    //练习2：使用map()中间操作实现flatMap()中间操作方法
    Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest2::fromStringToStream);
    streamStream.forEach(s ->{
        s.forEach(System.out::println);
    });
    System.out.println();

    //flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
    Stream<Character> characterStream = list.stream().flatMap(StreamAPITest2::fromStringToStream);
    characterStream.forEach(System.out::println);

    //
    
标签：Stream,void,知识,System,梳理,public,println,Java8,out	
    
From： https://www.cnblogs.com/Enid/p/17666044.html

相关文章

  • [java基础知识复习] Java基础知识总结分享一
    写代码：1，明确需求。我要做什么？2，分析思路。我要怎么做？1,2,3。3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。4，代码实现。用具体的java语言代码把思路体现出来。学习新技术的四点：1，该技术是什么？2，该技术有什么特点(使用注意)：3，该技术怎么使用。demo4，该技术什么时候用？test。————......
  • java实现的类似于sql join操作的工具类，通用递归，最低需要java8
    直接上代码，缺包的自行替换为自己项目中存在的importjava.util.ArrayList;importjava.util.Collection;importjava.util.HashMap;importjava.util.HashSet;importjava.util.List;importjava.util.Map;importjava.util.Set;importjava.util.function.BiConsumer;i......
  • python小知识
    Python小知识浮点数注意事项#浮点数精度问题fromdecimalimportDecimalprint(0.1+0.1)#0.2print(0.1+0.2)#0.30000000000000004print(Decimal("0.1")+Decimal("0.2"))#0.3，注意：参数是字符串jsonpath提取数据#pipinstalljsonpathfromjsonpathimp......
  • 王道408---CO---机组输入输出系统必会知识点
    一、SSD固态硬盘基于flash闪存二、通道概念通道是一个具有特殊功能的处理器，它有自己的指令和程序，专门负责数据输入输出的传输控制,通道受CPU的I/O指令启动、停止或改变其工作状态。功能通道的基本功能是按I/O指令要求启动I/O设备，执行通道指令，组织I/O设备或主存进行数据传输，向......
  • SQL的语法知识
     1.全表查询  示例：select*from表名2.选择查询 选择特定的列或者字段示例：selectname,age表名3.查询别名 {原始字段名}as{别名}示例：selectnameas'学生姓名' 表名4.查询常量和运算  加减乘除、取平均值、连接文本等示例：selectname,score,score/2......
  • 王道408---CO---计算机系统概述易混淆易遗忘知识点
    易混淆性能指标机器字⻓计算机进⾏⼀次整数运算所能处理的⼆进制的位数，⼀般与字⻓⻓度有关注意不是浮点数运算数据通路带宽外部数据总线⼀次能并⾏传送信息的位数，⾮CPU内部数据总线宽度MIPSMIPS：每秒执⾏多少百万条指令MFLOPS：每秒执⾏多少百万次浮点运算GFLOPS：每秒执⾏多......
  • Netty 的 ChannelOption.SO_BACKLOG 知识点整理
    Netty的ChannelOption.SO_BACKLOG知识点整理 一个基于Netty的应用，在压力测试时，Socket请求数量一多，就发送失败，监测JVM内存大小比较稳定，猜测可能是ChannelOption.SO_BACKLOG这个配置导致的，设置的值是128。调整为1024后，连接失败的次数确实减少了一些，那么这个配置到......
  • 红黑树的知识点以及源码
    花了几个小时看了B站大佬刘冬煜讲解红黑树源码和性质，对红黑树知识有了一个很清晰的理解。满满的成就感，把大佬有关红黑树的资料借用了一下，做了一点简单的修改。红黑树具有如下的性质：1.红黑树是一颗平衡二叉搜索树，其中序遍历单调不减。2.节点是红色或者黑色。3.根节点是黑色。......
  • 系统开发和运行知识
    软件工程原理与方法是指在软件开发过程中应用的一系列原则和方法论。这些原理和方法旨在提高软件开发的效率和质量，并确保项目的成功完成。在软件工程领域，有许多重要的概念和实践需要掌握，包括需求分析与软件规格说明、软件设计与实现、软件测试与调试、软件维护与配置管理、质量保证......
  • java与es8实战之三：Java API Client有关的知识点串讲
    欢迎访问我的GitHub这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos本篇概览本篇是《java与es8实战》系列的第三篇，将一些重要的知识点在这里梳理清楚，为后面的实践奠定基础一共有七个与JavaAPIClient有关的重要知识点关于namespace：每......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99