java8新特性

最新推荐文章于 2024-05-04 22:32:48 发布
最新推荐文章于 2024-05-04 22:32:48 发布
阅读量131 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/renguiriyue/article/details/103644077
版权

java8新特性


java 版本可能早已过了java8了，但是lambda表达式的运用在项目中可能变的越来越多了，所有特地整理一下。

lambda 表达式

lambda是一个匿名内部类，我们可以把lambda 表达式理解成一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁，灵活的代码。作为一种更紧凑的代码风格，使java的语言表达能力得到提升。

基础语法格式

无参，无返回值

Runnable runnable = () -> System.out.println("new Runnable");
runnable.run();

有参，无返回值

Consumer<String> consumer = (x) -> System.out.println(x);
Consumer<String> consumer = x -> System.out.println(x); // 括号 可以不写
consumer.accept("test");

有参，有返回值

Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);
Comparator<Integer> comparator = (Integer x,Integer y) -> Integer.compare(x,y); // 因为类型推断，可以省。
// 当有多行语句时
Comparator<Integer> comparator = (x,y) -> {
System.out.println(x);
     return Integer.compare(x,y);
};

表达式需要“函数式接口”的支持

函数式接口：接口中只有一个抽象方法的接口，可以使用 @FunctionalInterface 检查是否是函数式接口。

// 函数式接口
@FunctionalInterface
public interface MyFun {

    public Integer getValue(Integer num);
}

Integer operation = operation(100, (x) -> x * x);
//等价于
MyFun myFun = new MyFun() {
    @Override
    public Integer getValue(Integer num) {
        return num * num;
    }
};
System.out.println(operation);

四大内置核心函数式接口

上面定义MyFun 函数式接口的时候，深深感受到为了写而写。
其实java8 给我们提供了一些接口，以下是一些用法

/**
 *
 * Consumer<T> : 消费型接口
 *      void accept(T t);
 *
 *  Supplier<T> : 供给型接口
 *      T get();
 *
 *  Function<T,R> : 函数型接口
 *      R apply(T t);
 *
 *  Predicate<T> : 断言型接口
 *      boolean test(T t);
 *
 */
public class Test {

    public static void main(String[] args) {
        // Consumer
        consumer(10000, (m) -> System.out.println("用了"+m + "yuan"));
        // Supplier
        List<Integer> supplier = supplier(10, () -> (int) (Math.random() * 100));
        supplier.stream().forEach(System.out::println);
        // Function
        String function = function("123123123", (x) -> x.substring(0, 5));
        System.out.println(function);
        // Predicate
        List<String> list = Arrays.asList("123", "1234", "12345", "123456", "1234567");
        List<String> predicate = predicate(list, (x) -> x.length() > 4);
        predicate.stream().forEach(System.out::println);

    }

    // Consumer
    public static void consumer(double money , Consumer<Double> son){
        son.accept(money);
    }

    // Supplier
    public static List<Integer> supplier(int num , Supplier<Integer> sup){
        List<Integer> list = new ArrayList<>();
        for(int i = 0 ; i < num ; i++){
            Integer n = sup.get(); // get 方法就是 -> 后面的实现(int) (Math.random() * 100)
            list.add(n);
        }
        return list;
    }

    //Function
    public static String function(String str, Function<String,String> function){
        return function.apply(str);
    }

    // Predicate
    public static List<String> predicate(List<String> strList , Predicate<String> newStr){
        List<String> list = new ArrayList<>();
        for (String str : strList){
            if(newStr.test(str)){
                list.add(str);
            }
        }
        return list;
    }
}

方法引用和构造器引用

参考编码注解。

import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.*;

/**
 * 方法引用 ： 若 Lambda 体中的内容有方法已经实现了，我们可以使用“方法引用”
 *          （可以理解为方法引用是Lambda表达式的另一种表达方式）
 *
 * 主要有三种语法方式：
 *
 *      对象::实例方法名
 *
 *      类::静态方法
 *
 *      类::实例方法名
 *
 * 构造器引用
 *
 *      ClassName::new
 *      注意：需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致
 *      
 * 数组引用：
 *      Type[]::new;
 */

public class TestMethodRef {

    //方法引用
    @Test
    public void test1(){
        // 1
        PrintStream out = System.out;
        Consumer<String> con = (x) -> out.print(x);
        //等价于
        Consumer<String> tConsumer = out::print;

        //2
        Comparator<Integer> con2 = (x, y) -> Integer.compare(x,y);
        //等价于
        Comparator<Integer> compare = Integer::compare;
//        compare.compare(x,y);

        //3
        BiPredicate<String,String> biPredicate = (x,y) -> x.equals(y);
        // 等价于
        BiFunction<String, Object, Boolean> stringObjectBooleanBiFunction = String::equals;

    }

    //构造器引用
    @Test
    public void test2(){
        Supplier<Student> supplier= () -> new Student();
        // 等价于
        Supplier<Student> supplier2 = Student::new;


        Function<String , Student> su = (x) -> new Student(x);
        //等价于
        Function<String , Student> supplier3 = Student::new;
//        Student student = supplier3.apply("123"); // 查看用了哪个构造方法，其实和Function<String , Student> 有关

        //数组引用
        Function<Integer , String[]> fun = (x) -> new String[x];
        //等价于
        Function<Integer, String[]> runnable = String[]::new;
    }

}

Stream 流

流的创建


/**
 * 一：Stream 的三个操作步骤
 *
 *  1，创建Stream
 *
 *  2，执行Stream
 *
 *  3，终止操作（终端操作）
 *
 */
public class TestStreeam {

    // 创建流
    @Test
    public void test(){
        
        // 集合
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();

        // 数组
        Student[] students = new Student[10];
        Stream<Student> stream1 = Arrays.stream(students);

        // 静态方法
        Stream<String> stringStream = Stream.of("", "", "");

        //创建无限流
        Stream<Integer> iterate = Stream.iterate(0, (x) -> x + 2);
        iterate.forEach((x) -> System.out.print(x));// 无限打印
        iterate.limit(20).forEach(System.out::print);// 用limit限制数量
        
    }

流的操作

filter

@Test
public void test2(){
      List<Student> list = new ArrayList<>();
      for (int i =0 ; i < 10 ; i++){
          list.add(new Student(String.valueOf(i)));
      }
      // 过滤 filter
      list.stream().filter((e) -> Integer.valueOf(e.name) > 3).forEach(System.out::print);
      list.stream().filter((e) -> Integer.valueOf(e.name) > 3)
              .distinct()   // 去重，要实现equals 和 hashCode
              .forEach(System.out::print);

    }

map

@Test
public void test3(){
     // map 将元素转换成其他形式或提取信息
     List<Student> list = new ArrayList<>();
     for (int i =0 ; i < 10 ; i++){
         list.add(new Student(String.valueOf(i)));
     }
     list.stream().map((e) -> { e.setAge(21);
             return e;
     }).forEach(System.out::print);

 }

flatMap
对Stream<Stream> 的对象操作时，就用flatMap操作。 最后会把所有的T 取出来。

sorted(Comparator)

@Test
public void test4(){
     List<String> list = Arrays.asList("AAA", "CCC", "BBB", "EEE", "ZZZ");
     list.stream().sorted().forEach(System.out::print); // 排序

     //或者用
     List<Student> list2 = new ArrayList<>();
     for (int i =0 ; i < 10 ; i++){
         list2.add(new Student(String.valueOf(i),i+1));
     }
     list2.stream().sorted((e1,e2) -> {
         if (e1.getAge().equals(e2.getAge())){
             return e1.getName().compareTo(e1.getName());
         }else{
             return e1.getAge().compareTo(e2.getAge());
         }
     }).forEach(System.out::print);

 }

终止操作

//终止操作
@Test
public void test5(){
    List<Student> list = new ArrayList<>();
    for (int i =0 ; i < 10 ; i++){
        list.add(new Student(String.valueOf(i),i+1));
    }

    boolean b1 = list.stream().allMatch((e) -> e.getAge() == 1); // 全匹配

    boolean b2 = list.stream().anyMatch((e) -> e.getAge() == 1);

    boolean b3 = list.stream().noneMatch((e) -> e.getAge() == 1);

    Optional<Student> first = list.stream()
            .sorted((e1, e2) -> e1.getAge().compareTo(e2.getAge()))
            .findFirst();  // 找到第一个
    Student student = first.get();

    Optional<Student> free = list.parallelStream()  // 并行流
            .sorted((e1, e2) -> e1.getAge().compareTo(e2.getAge()))
            .findAny();  // 找到第一个
    Student student2 = first.get();

    long count = list.stream().count();

    Optional<Student> max = list.stream().max((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
    Student student1 = max.get();

    Optional<Integer> min = list.stream().map(Student::getAge).min(Double::compare);
    Integer integer = min.get();
}

reduce 规约

/**
     * 规约
     *  reduce(T identity , BinaryOperator) / reduce(BinaryOperator)
     *  可以将流中元素反复结合起来，得到一个值
     */
    @Test
    public void test6(){

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

        //计算
        Integer reduce = list.stream().reduce(0, (x, y) -> x + y);
        
        //集合map 使用
        list.stream().map(Double::valueOf).reduce(Double::sum);

    }

collect

/**
* 收集
 *  collect
 *  将流转换成其他形式，接收一个Collector 接口的实现，用于给Stream中元素做汇总的方法
 *
 */
@Test
public void test7(){
    List<Student> list = new ArrayList<>();
    for (int i =0 ; i < 10 ; i++){
        list.add(new Student(String.valueOf(i),i+1));
    }

    /**
     * collect(Collector c)
     * 将流转换成其他形式。接收一个Collector接口的实现，用于给Stream 中元素做汇总的方法。
     *
     * Collector 接口中方法的实现决定了如何对流执行收集操作（如收集到List，Set，Map）。 但是Collector
     * 实用类提供了很多静态方法，可以方便地创建常见收集器实例
     */
    // list
    List<Integer> collect = list.stream().map(Student::getAge).collect(Collectors.toList());
    // set
    Set<Integer> collect1 = list.stream().map(Student::getAge).collect(Collectors.toSet());

    HashSet<Integer> collect2 = list.stream().map(Student::getAge).collect(Collectors.toCollection(HashSet::new));

    //总数
    list.stream().collect(Collectors.counting());
    //平均值 / 总和
    Double collect3 = list.stream().collect(Collectors.averagingInt(Student::getAge));
    // 最大值
    Optional<Student> max = list.stream().collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getAge(), e2.getAge())));
    System.out.println(max.get());

    // 分组
    Map<String, List<Student>> map = list.stream().collect(Collectors.groupingBy(Student::getName));
    // 多级分组
    Map<Integer, Map<Integer, String>> collect4 = list.stream().collect(Collectors.groupingBy(Student::getAge, toMap(Student::getAge, Student::getName)));
    // 也可以写成这样
    Map<Integer, Map<Integer, String>> collect5 = list.stream().collect(Collectors.groupingBy(e -> e.getAge(), toMap(Student::getAge, Student::getName)));

    // 分区
    Map<Boolean, List<Student>> collect6 = list.stream().collect(Collectors.partitioningBy(e -> e.getAge() > 2));
    System.out.println(collect6);

    DoubleSummaryStatistics collect7 = list.stream().collect(Collectors.summarizingDouble(Student::getAge));
    collect7.getAverage();
    collect7.getMax();
    // ...

    //连接字符串
    String collect8 = list.stream().map(Student::getName).collect(Collectors.joining(","));
    System.out.println(collect8); // 0,1,2,3,4,5,6,7,8,9  //发现末尾的逗号都给你去掉了
    String collect9 = list.stream().map(Student::getName).collect(Collectors.joining(",", "前缀", "后缀"));
    System.out.println(collect9);

}

并行流和串行流

略 （后面有时间写）

Optional 类

是一个容器类，代表一个值存在或不存在，原来用null表示一个值存在，现在用Optional 可以更好的表达这个概念，并且可以避免空指针。

@Test
public void test(){
    //创建一个Optional实例，如果是空指针异常，则当前行报错
    Optional<Student> op = Optional.of(new Student());
    Student student = op.get();

    // 构建一个空的
    Optional<Student> empty = Optional.empty();

    // 也会报错，因为 ofNullable 的实现就是 return value == null ? empty() : of(value);
    Optional<Student> student1 = Optional.ofNullable(new Student());
    // 如果有值，才获取
    if(student1.isPresent()){
        Student student2 = student1.get();
    }

    // 有值则op中原先的值，没值则用 new Student("zs", 1)
    Student student2 = op.orElse(new Student("zs", 1));

    // 和上面一样，只是内部用函数式接口，更方便处理。
    op.orElseGet(() -> new Student("zs", 1));


    Optional<Student> zs = Optional.ofNullable(new Student("zs", 1));
    // map
    Optional<String> s = zs.map((e) -> e.getName());
    // flatMap
    Optional<String> s1 = zs.flatMap((e) -> Optional.of(e.getName()));

}

//实战中使用,对象初始化必须加上Optional.empty();
private Optional<Student> student = Optional.empty();

接口中可以有默认方法和静态方法

public interface myInterface {

    // 接口中要实现默认方法，需要在方法前添加 default 关键字
    default void test(){
        System.out.println("---");
    }
    
    // 静态方法
    public static void test2(){
        System.out.println("---");
    }
}
人圭日月
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 8的新特性—终极版
飞鸟Blog
03-15 14万+
前言： Java 8 已经发布很久了，很多报道表明Java 8 是一次重大的版本升级。在Java Code Geeks上已经有很多介绍Java 8新特性的文章，例如Playing with Java 8 – Lambdas and Concurrency、Java 8 Date Time API Tutorial : LocalDateTime和Abstract Class Versus
Java8 有什么新特性
最新发布
weixin_44714029的博客
05-23 305
Java8 的新特性
Java8新特性都到碗里来
你听___
04-15 261
对于Java开发者来说，Java8的版本显然是一个具有里程碑意义的版本，蕴含了许多令人激动的新特性，如果能利用好这些新特性，能够大大提升我们的开发效率。Java8的函数式编程能够大大减少代码量和便于维护，同时，还有一些跟并发相关的功能。开发中常用到的新特性如下： 1. 接口的默认方法和静态方法 2. 函数式接口FunctionInterface与lambda表达式 3. 方法引用 4....
Java9都快发布了，Java8的十大新特性你了解多少呢？
weixin_30784141的博客
08-03 283
Java 9预计将于今年9月份发布，这是否会是一次里程碑式的版本，我们拭目以待。今天，我们先来复习一下2014年发布的Java 8的十大新特性。 Java 8可谓是自Java 5以来最具革命性的版本了，她在语言、编译器、类库、开发工具以及Java虚拟机等方面都带来了不少新特性。我们来一一回顾一下这些特性。 一、Lambda表达式 Lambda表达式可以说是Java 8最大的卖点，她将函数...
java 8新特性
qq_35932990的博客
01-20 1876
Java 8 概述 Java 8 是 Java 语言历史上一个非常重要的版本，它引入了多项新特性，大大提高了 Java 语言的现代化程度和生产力。以下是 Java 8 的一些主要新特性介绍。
Java8 新特性
06-17
java8的新特性，包含lambda表达式，stream流以及Optional和日期
JAVA 8 的新特性
qq_36488864的博客
06-02 3011
前段时间面了完美世界，被问到Java8的新特性，在此特地记录一下，虽然现在Java的版本可能已经很高了，但是Java8的新特性依然值得学习一下！
Java 8 再不知道就老了
WSRspirit的专栏
08-11 7419
Java 8 特性介绍1.简介毫无疑问，Java 8是自Java 5（2004年）发布以来Java语言最大的一次版本升级，如果不学习，你会怀疑自己面前的代码是不是Java。Java 8带来了很多的新特性，比如编译器、类库、开发工具和JVM（Java虚拟机），但最最主要的还是函数式编程。接下来将会结合代码去展示Java 8的新特性。下面主要介绍Java 8的最显著特性： 接口增强 La
简单使用lambda表达式
qq_44716544的博客
07-24 810
什么是lambda表达式？ Lambda 是一个 匿名函数，我们可以把 Lambda 表达式理解为是 一段可以传递的代码（将代码像数据一样进行传递）。 使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升 Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或 箭 头操作符。 它将 Lambda 分为两个部分：左侧：指定了 Lambda 表达式需要的参 参
JAVA8新特性
weixin_39917908的博客
11-13 236
Java8
java8的新特性
weixin_45802989的博客
04-09 85
lamda表达式是一个匿名函数，我们可以把lamda表达式理解成一段可以传递的代码（将代码像数据一样传递），可以写出更简洁、灵活的代码 作为一种更紧凑的代码风格，使java的语言表达能力得到了一种提升
java8如何根据属性名这个字符串创建SFunction
m0_59084856的博客
05-04 341
比如我有一个Person类 里面有name属性 我怎么根据name这个字符串和Person这个class 获取SFunction。
JavaScript高级程序设计-引用类型（二）Function、基本包装类型（Number，String，Boolean）
Three_ST的博客
02-07 489
文章目录5.5 Function类型5.5.1 没有重载5.5.2 函数声明与函数表达式5.5.3 作为值的函数5.5.4 函数内部属性5.5.5 函数属性和方法5.6 基本包装类型5.6.1 Boolean 类型5.6.2 Number类型5.6.3 String类型5.7单体内置对象5.7.15.7.2 Math对象5.8 小结 5.5 Function类型 函数实际上是对象。每个函数都是 F...
JDK1.8自学之路-10（lambda表达式实例方法的引用- str::endsWith）
u012045045的博客
05-07 254
练习 1.测试类 package com.citic._11instance_method_lambda; import java.util.function.Function; /** * lambda测试实例方法的引用 * * @Package: com.citic._11instance_method_lambda * @ClassName: Test * @author...
Java8新特性
十二间记，知不足而奋斗，望远山而前行。千里不辞行路远，时光早晚到天涯。
02-20 2953
Java8新特性介绍
java 8 新特性
07-27
Java 8引入了许多令人兴奋的新特性，以下是其中一些： 1. Lambda表达式：Lambda表达式允许以更简洁的方式编写匿名函数，并且可以更方便地使用函数式编程风格。 2. 函数式接口：Java 8引入了函数式接口的概念，这是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值