java各版本的新特性

最新推荐文章于 2024-04-14 23:47:42 发布

置顶

VIP文章 codingdong

最新推荐文章于 2024-04-14 23:47:42 发布

阅读量2.1k

点赞数 4

分类专栏： Java11 文章标签： java

本文链接：https://blog.csdn.net/ahutdbx/article/details/120437852

版权

java各版本的新特性

Java8 新特性

Java 8(又称为jdk 1.8) 是Java语言开发的一个主要版本。Java 8是oracle公司于2014年3月发布，可以看成是自Java5以来最具革命性的版本。Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量新特性。

1. Lambda表达式

为什么使用Lambda表达式
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

在Java 8中， Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型：函数式接口。

语法格式一：无参，无返回值

@Test
public void test() {
   
    Runnable r1 = new Runnable() {
   
        @Override
        public void run() {
   
      	   System.out.println("lalalalalalala");
        }
    };
    r1.run();
    
    Runnable r2=()->System.out.println("lalalalalalala");
    r2.run();
}

语法格式二：Lambda需要一个参数，但是没有返回值

@Test
public void test() {
   
    Consumer<String> con = new Consumer<String>() {
   
        @Override
        public void accept(String s) {
   
        	System.out.println(s);
        }
    );
    con.accept(t:"lalalalalalal");
  
    Consumer<String> con1 = (String s) ->{
   
    	System.out.println(s);
    };
    con1.accept(t:"lalalalalalalala");
}

语法格式三：类型推断

数据类型可以省略，因为可由编译器推断得出，称为“类型推断”。

@Test
public void test() {
   
    Consumer<String> con1 = (String s) ->{
   
   	 	System.out.println(s);
    };
    con1.accept(t:"lalalalalalaala");        
 
    Consumer<String> con2 = (s) ->{
   
    	System.out.println(s);
    };
    con2.accept(t:"lalalalalalaaaala");
}

语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略

@Test
public void test() {
   
    Consumer<String> con1 = (s) ->{
   
    	System.out.println(s);
    };
    con1.accept(t:"lalalallalala");
   
    Consumer<String> con2 = s->{
   
   	 	System.out. println(s);
    };
    con2.accept(t:"lalalalalalalalala");
}

语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值

@Test
public void test() {
   
    Comparator<Integer> com1 = new Comparator<Integer>() {
   
        @override
        public int compare(Integer o1,Integer o2) {
   
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }
    };
    System.out.println(com1.compare(12,21));

    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 test() {
   
    Comparator<Integer> com1 = (o1,o2) ->{
   
    	return o1.compareTo(o2);
    };
    System.out.println(com1.compare(12,6));
  
    Comparator<Integer> com2 = (o1,o2) ->o1.compareTo(o2);
    System.out.println(com2.compare(12,21));
}

2. 函数式(Functional) 接口

什么是函数式接口

只包含一个抽象方法的接口，称为函数式接口。
你可以通过Lambda表达式来创建该接口的对象。(若Lambda表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明)。
我们可以在一个接口上使用@Functionallnterface注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。
在java.util.function包下定义了Java 8的丰富的函数式接口。

如何理解函数式接口

Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战， Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还可以支持O OF(面向函数编程)。
在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中， Lambda表达式的类型是函数。但是在Java 8中，有所不同。在Java 8中， Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。
简单的说，在Java 8中， Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。
所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

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

函数式接口	参数类型	返回类型	用途
Consumer 消费型接口	T	void	对类型为T的对象应用操作，包含方法： void accept(T t)
Supplier 供给型接口	无	T	返回类型为T的对象，包含方法：T get()
Function<T,R> 函数型接口	T	R	对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t)
Predicate 断定型接口	T	boolean	确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t)

3. 方法引用与构造器引用

方法引用(Method References)

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用!
方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。
要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致!
格式：使用操作符“：：”将类(或对象)与方法名分隔开来。
如下三种主要使用情况：

对象：：实例方法名
类：：静态方法名
类：：实例方法名

构造器引用(Constructor References)

SuppLier中的 T get()
EmpLoyee的空参构造器：EmpLoyee()

@Test
public void test() {
   
    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());
}

4. 强大的Stream API

什么是Stream

Stream到底是什么呢？是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。“集合讲的是数据， Stream讲的是计算！”
注意
①Stream自己不会存储元素。
②Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream API说明

Java 8中有两大最为重要的改变。第一个是Lambda表达式；另外一个则是Stream API。
Stream API(java.util stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
Stream是Java 8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简言之， Stream API提供了一种高效且易于使用的处理数据的方式。
Java 8可以透明地把输入的不相关部分拿到几个CPU内核上去分别执行你的Stream操作流水线。
Stream支持许多处理数据的并行操作，其思路和在数据库查询语言中的思路类似。

为什么要使用Stream API

实际开发中，项目中多数数据源都来自于Mysql， Oracle等。但现在数据源可以更多了，有Mon gDB， Red is 等，而这些No SQL的数据就需要Java层面去处理。
Stream和Collection集合的区别：Collection是一种静态的内存数据结构，而Stream是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU实现计算。
例如你一个接口如果里面不仅要返回全部数据，还要返回满足某个条件的数据，用stream处理结果集就可以少操作一次数据库了，这样反而可能提高了性能，同时代码也简洁了。

并行流与串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。Java 8中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过parallel() 与sequential() 在并行流与顺序流之间进行切换。

Stream的操作三个步骤

创建Stream

一个数据源(如：集合、数组)，获取一个流。

创建Stream方式一：通过集合

Java 8中的Collection接口被扩展，提供了两个获取流的方法：

default Stream stream() ：返回一个顺序流
default Stream parallelStream() ：返回一个并行流

@Test
public void test() {
    
 List<Employee> employees = EmployeeData.getEmpLoyees();
 //defauLt Stream<E> stream() ：返回一个顺序流
 Stream<Employee> stream = employees.stream();

 //default Stream<E>paralLel Stream() ：返回一个并行流
 Stream<Employee> parallelStream = employees.parallelStream();
}

创建Stream方式二：通过数组
Java 8中的Arrays的静态方法stream() 可以获取数组流：

static Stream stream(T[] array) ：返回一个流

重载形式，能够处理对应基本类型的数组：

public static Int Stream stream(int[] array)
public static Long Stream stream(long[] array)
public static Double Stream stream(double[] array)

@Test
public void test() {
    
 int[] arr=new int[] {
    1,2,3,4,5,6};
 IntStream stream = Arrays.stream(arr);
 
 Employee e1 = new Employee (id: 1001, name:"Tom");
 Employee e2 = new Employee (id: 1002, name:"Jerry");    
 Employee[] arr1 = new Employee[]{
    e1, e2};
 
 Stream<Employee> stream1 = Arrays.stream(arr1);
}

创建Stream方式三：通过Stream的of()

可以调用Stream类静态方法of() ，通过显示值创建一个流。它可以接收任意数量的参数。
public static Stream of(T…values) ：返回一个流

@Test
public void test() {
   
	Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
}

创建Stream方式四：创建无限流

最低0.47元/天解锁文章

codingdong

关注

4
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
java各版本的新特性

java各版本的新特性Java8 新特性Java 8(又称为jdk 1.8) 是Java语言开发的一个主要版本。Java 8是oracle公司于2014年3月发布，可以看成是自Java5以来最具革命性的版本。Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量新特性。1. Lambda表达式为什么使用Lambda表达式Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑
复制链接

扫一扫