首页 > 编程学习 > Java各个版本新特性

Java各个版本新特性

发布时间:2022/5/14 15:38:12

Java8新特性:

在这里插入图片描述

Lambada表达式

不使用labmda表达式:

Comparator<Integer> com1 = new Comparator<Integer>(){
    @Override
    public int compare(Interger o1, Integer o2){
        return Integer.compare(o1,o2);
        }
       };
int compare1 = com1.compare(12,21);

使用lambda表达式:


```java
Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);
int compare2 = com2.comprare(32,21);

Lambda表达式的使用:
举例:(o1,o2) -> Integer.compare(o1,o2);
格式:

  • lambda操作符或者箭头操作符
  • 左边:lambda形参列表(接口中的抽象方法的形参列表),如果lambda形参只有一个参数,其一对()也可以省略
  • 右边:lambda体(重写的抽象方法的方法体),lambda体应该使用一对{}包裹;如果labmda体只有一条执行语句(可能是return语句),可以省略这一对{}和return

格式一:无参无返回值

Runnable r1 = () -> System.out.println("我爱北京天安门");
r1.run();

格式二:Lambda需要一个参数,但是没有返回值

Consumer<String> con1 = (String s) -> { System.out.prinln(s);};
con1.accept("谎言是听的人当真了,誓言是说的人当真了”);

格式三:数据类型可以省略,可以由编译器推断得出,称为“类型推断”

ArrayList<String> list = new ArrayList<>(); // 类型推断1
int[] arr = {1,2,3}     // 类型推断2  

格式四:Lambda若只需要一个参数时,选举是的小括号可以省略

 Consumer<String> con2 = s -> {System.out.println(s);};

格式五: Lambada需要两个或两个以上的参数,多条执行语句,并且可以有返回值

 Comparator<Integer> com2 = (o1,o2) -> { 
 sout(o1);
 sout(o2);
 return o1.comparaTo(o2);};
System.out.println(com2.compare(12,6));

语法格式六:当Lambda体只有一条语句时,return与大括号若有,都可以省略

Comparator<Integer> com3 = (o1,o2) -> o2 ;

函数式接口

  • Lambda表达式中只可以利用接口实现,然后要求接口只能有一个抽象方法。
  • Lambda表达式的本质:作为函数式接口的实例
  • 如果一个接口中,只声明了了一个抽象方法,则此接口就称为函数式接口,使用@FunctionInterface进行注解。

在这里插入图片描述
Java中的四大核心函数式接口:
在这里插入图片描述
在这里插入图片描述

消费型接口代码举例:

public void happyTime(double money, Consumer<Double> con){
con.accept(money);
}

// 传统匿名对象方法调用上面函数:
happyTime(300, new Consumer<Double>(){
    @Override
    public void accept(Double mon){
        System.out.println("矿泉水一瓶卖" + mon);
        }
    });

// Lambda函数实现调用上述函数:
happyTime(300, mon -> System.out.println("矿泉水一瓶卖" + mon));

断定型接口的用法:

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

List<String> list = Arrays.asList("北京","南京","天津","东京","西京","普京");
// 传统匿名实现接口
List<String filterStrs = filterString(list, new Predecate<String>(){
    public boolean test(String s){
        return s.contains("京");
    }
}
// Lambda实现接口
List<String> filterStr1 = filterString(list, s -> s.contains("京"));
// 输出结果
Systm.out.prinln(filterStrs1);

方法引用:

Comparator<Integer>  com3 = Integer :: compare;
int compare3 = com3.compare(32,21);

方法引用的使用:

  1. 使用场景:当要传递给Labmda体的操作,已经有实现的方法了,可以使用方法引用!(形参和返回值一样)
  2. 方法引用,本质上就是Lambda表达式,而Lambda表达式作为函数式接口的实例。所以方法引用,也是函数式接口的实例。
  3. 使用格式:类(或对象) :: 方法名

使用条件:

  • 情况一:对象::实例方法

Consumer中的 void accept(T t)
PrintSTream中的void println(T t)

PrintStream ps = System.out;
Consumer<String> con2 = ps::println;
con2.accept("beijying");
  • 情况二:类::静态方法

Comparator中的int compare(T t1,T t2)
Integer中的int compare(T t1, T t2)

Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
Comparator<Integer> com2 = Integer:compare;

Function中的R apply(T t)
Math中的Long round(Double d)

Function<Double,Long> func1 = d -> Math.round(d);
Function<double,Long> func2 = Math::round;
fucn1.apply(12.3);
func2.apply(12.6); 
  • 情况三:类::实例方法(有难度)
    接口函数的第一个参数作为类本身存在了
    在这里插入图片描述
    在这里插入图片描述
    注意Function的第一个参数为Employee
    在这里插入图片描述

构造器引用

和方法引用类似,函数式接口的抽象方法的形参和构造器形参列表一致。
抽象方法的返回值类型即为构造器所属的类。
无参构造器:
在这里插入图片描述

有一个参数构造器:
在这里插入图片描述
两个参数的构造器引用:
在这里插入图片描述
数组引用:
在这里插入图片描述

并行流和串行流

在这里插入图片描述
虽然一些sql类型数据库可以在sql层面来处理,但是还有一些非关系数据库的一些信息需要在java层面来处理

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

如何创建流

方式一:通过集合

List<Emploee> employees = EmployeeData.getEmployees();
Stream<Employee> stream = employees.stream(); // 创建一个顺序流
Stream<Employee> parallelStream = employees.paralelStream(); // 返回一个并行流

方式二:通过数组

int[] arr = new int[]{1,2,3,4,4};
// 调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
IntStream steam = Arrays.stream(arr);

Employee e1 = new Employee(120,"ttom");
Employee e2 = new Employee(34,"jerry");
Employee[] arr1 = new Employee[]{e1,e2};
Stream<Employee> stream1 = Arrays.stream(arr1);

方式三:通过Stream中的of()

Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

方式四:创建无限流
在这里插入图片描述

// 迭代

Stream.iterate(0,t -> t+2).limit(10).forEach(System.out::prinln):

// 生成

Stream.generate(Math::random).limit(10).forEach(System.out::prinln);

筛选与切片

在这里插入图片描述

映射

在这里插入图片描述

排序

在这里插入图片描述

Copyright © 2010-2022 ngui.cc 版权所有 |关于我们| 联系方式| 豫B2-20100000