<sup id="6oea2"></sup>
<acronym id="6oea2"><center id="6oea2"></center></acronym>
<acronym id="6oea2"><small id="6oea2"></small></acronym>
<rt id="6oea2"><small id="6oea2"></small></rt><rt id="6oea2"><small id="6oea2"></small></rt><rt id="6oea2"><small id="6oea2"></small></rt>
<acronym id="6oea2"><center id="6oea2"></center></acronym>
<acronym id="6oea2"><div id="6oea2"></div></acronym>
<rt id="6oea2"><optgroup id="6oea2"></optgroup></rt>

【进阶】Java8新特性的理解与应用

【进阶】Java8新特性的理解与应用

前言

Java 8是Java的一个重大版本,是目前企业中使用最广泛的一个版本。

它支持函数式编程,新的Stream API 、新的日期 API等一系列新特性。

掌握Java8的新特性已经是java程序员的标配,掌握了它,就可以看懂公司里的代码、高效率地处理大量集合数据以及消灭“嵌套地狱”等等。

一、Lambda表达式

Lambda表达式是java8最重要的新特性之一,与Stream API一起成为JDK1.8最主要的更新内容。

Lambda是一个匿名函数(表达式),可以将Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。

这样可以写出更简洁、更灵活的代码。同时作为一种更紧凑的代码风格,使java的语言表达能力得到了提升。

9.1基础概念

  • 首先,lambda表达式需要函数式接口的支持,lambda表达式的实现是基于函数式接口的。

  • lambda表达式的底层思维还是执行方法(函数),但lambda表达式会使得代码更简洁,利于程序员编写。

  • Java8中引入了一个新的操作符“->”,该操作符成为箭头操作符或者lambda操作符。该操作符将lambda表达式分为了左侧和右侧两部分。

  • 操作符左侧:lambda表达式所需的参数列表,具体就是lambda表达式中接口抽象方法的参数列表;

  • 操作符右侧:lambda表达式所需执行的功能,即lambda体,也就是接口中抽象方法具体要实现的功能。

9.2语法格式

9.2.1格式一:抽象方法无参数、无返回值
 /**
     *语法格式一:抽象方法无参数、无返回值
     * */
    @Test
    public void test_1(){
        //Runnable接口无参数、无返回值,无参数直接使用() 
        Runnable  r = () -> System.out.println("Hello,Lambda!");
        r.run();
    }
9.2.2格式二:抽象方法有1个参数,无返回值
  /**
     *语法格式二:抽象方法有1个参数,且无返回值
     * */
    @Test
    public void test_2(){
        //Consumer接口是JDK中一个有参、无返回的接口,作用是消费接口传进来的泛型参数
        Consumer<String> con = (t) -> System.out.println(t);
        //accept()是该接口的抽象方法
        con.accept("Hello Lambda!");
    }

注:如该抽象方法的参数只有1个,则"->"的左侧可以省略()不写。

9.2.3格式三:抽象方法中有多个参数、有返回值,且lambda体中有多条语句
    /**
     * 语法格式三:抽象方法中有多个参数、有返回值,且lambda体中有多条语句
     * */
    @Test
    public void test_3(){
        //如果lambda体中有多条语句,则必须将语句写在{};中
        Comparator<Integer> com = (x,y) -> {
            System.out.println("函数式接口");
            return Integer.compare(x,y);
        };
    }

注:如该lambda体中只有一条语句,则{};和return都可以省略不写。

9.2.4lambda表达式中参数列表的数据类型可以省略
    /**
     *语法格式四:lambda表达式中参数列表的数据类型可以省略,JVM可以根绝上下文进行推断,这个过程称为”类型推断“。
     *          本质上来说,由于lambda表达式基于函数式接口来实现,函数式接口中的抽象方法(T t)已经指定了泛型的数据类型。
     **/
    @Test
    public void test_4(){
        //参数列表中的Integer可以省略不写
        Comparator<Integer> c = (Integer x,Integer y) -> Integer.compare(x,y);
    }

9.3lambda表达式的应用

9.3.1需求1
调用Collections.sort()方法,定制化排序比较两个员工对象信息(第一比较年龄,年龄相同比较姓名),参数传递方式使用lambda表达式的形式。
    //定义员工信息list
    List<User> user_list = Arrays.asList(
            new User("张三",21,"xbzhu@163.com"),
            new User("李四",35,"ewrtrv@163.com")
    );    
    @Test
    public void test_1(){
        //Collections接口,使用lambda表达式
        Collections.sort(user_list,(u1,u2) -> {
            //lambda体中有多条语句
            if (u1.getAge() == u2.getAge()){
                return u1.getName().compareTo(u2.getName());
            }else {
                return -Integer.compare(u1.getAge(), u2.getAge());
            }
        });
        for (User u : user_list){
            System.out.println(u);
        }
    }
9.3.2需求2
 a.声明一个函数式接口,同时在该接口中声明一个抽象方法 String getValue(String str);
 b.声明一个类TestLambda_3,类中编写成员方法test_2,使用a中定义的接口作为该方法的参数,将一个字符串"lambda"转换为大写,并作为方法的返回值;
 c.再将该字符串的第2和第4个索引位置的的字符进行字串截取。
 /**
     * 该成员方法的形参1表示的是需要被操作的字符串,形参2表示的是接口中的操作实现。
     * */
    public String transform(String str, MyPractice mp){
        return mp.getValue(str);
    }

    @Test
    public void test_2(){
        String s = transform("lambda",(str) -> str.toUpperCase());
        System.out.println(s);
        //subString()方法截取规则:从数组下标的方式进行计算,含头不含尾。
        String ss = transform("lambda",(str -> str.substring(2,5)));
        System.out.println(ss);
    }
9.3.3需求3
a.声明一个带2个泛型的函数式接口,其中泛型类型为<T,R>且T为参数,R为返回值,同时在该接口中声明对应的抽象方法;
b.在类TestLambda_3中声明一个成员方法calculate()并使用a中的接口作为参数,输出员工信息。
    /**
     * 该成员方法中形参1表示的是需要被操作的字符串,形参2表示的是接口中的操作实现。
     * */
    public  List<User> calculate(MyPractice_2<List<User>> mp){
        mp.calculateValues();
        return user_list;
    }

    @Test
    public List<User> test_3(){
        List<User> list = calculate(() -> {
            System.out.println(user_list);
            return null;
        });
        return list;
    }

二、函数式编程

在java中(尤其从java8开始),函数式接口的应用是函数式编程的一个典型实现。

基于以上对lambda表达式的认识,我们可以清楚地知道:lambda表达式的实现需要函数式接口的支持。

2.1函数式接口

函数式接口指的是:接口中只有一个抽象方法的接口,称之为函数式接口。并且可以使用@FunctionnalInterface注解修饰,以此来判断该接口是否是函数式接口。

在Java8以后,函数式接口中允许存在普通方法(即非抽象方法),使用default进行修饰。

2.2内置4大核心函数式接口

  1. Cosumer消费型接口;

    //抽象方法
    void accept(T t);
    
  2. Supploer< T> 供给型接口;

    //抽象方法
    T get();
    
  3. Function< T> 函数型接口;

    //抽象方法
    R apply(T t);
    
  4. Predicate< T>断言式接口;

    //抽象方法
    boolean test(T t);
    

三、Stream流 API

Java8最为主要的更新内容是lambda表达式和Stream流API,关于lambda表达式在上面已经介绍过了,下面就来看看今天的主角——Stream流 API(java.util.stream.*)。

3.1基本概念

  • Stream API是java8中处理集合的关键抽象概念,它可以对指定的集合进行操作,如执行非常复杂的查找、过滤和映射数据等操作;
  • 使用Stream API对集合数据进行操作,类似于使用SQL执行数据库查询的操作;
  • Stream API在对数据源(集合或数组)进行一系列流水线式的操作后,最终会产生一个新的流。

注意

  1. Stream本身不会存储元素;
  2. Stream不会改变源对象,相反,Stream流执行完后会返回一个有结果的新Stream;
  3. Stream流的执行具有延迟性,只有当执行流的终止操作时(或者需要某些结果时),Stream才会执行。

简而言之,Stream API提供了一种高效且易于使用的处理数据的方式。

3.2实现步骤

Stream流的操作可分为3个步骤:创建Stream、中间操作以及终止操作(结果)。

3.2.1步骤一:创建Stream
 //可以通过Collection系列集合提供的stream(),或者parallelStream()
         List<String> list_1 = new ArrayList<>();
         Stream<String> stream_1 = list_1.stream();
//可以通过of()创建Stream的
         Stream<String> stream_2 = Stream.of("aa","bb","cc");
//创建无限流
         Stream<Integer> stream_3 = Stream.iterate(3,(x) -> x+2);
         stream_3.limit(10).forEach(System.out::println);
3.2.2步骤二:中间操作

中间操作主要包括:筛选与切片、映射,查找和排序等。

  1. 筛选与切片、映射
 /**
     * 筛选与切片
     * filter:接收Lambda,从流中排除某些元素;
     * map:接收Lambda,将元素转换为其它形式或者提取数据源的具体信息;(接收一个函数作为参数,该函数会应用到每个元素上,并将其映射成一个新的元素)
     * limit(n):截断流,使其元素不超过指定数量,即只取前n个元素;
     * skip(n):跳过元素,返回n个后的元素;
     * distinct:通过流生成元素的hashCode()和equals()去除重复元素。
     * */
    @Test
    public void test_1(){
         List<Integer> a = Arrays.asList(1,2,3,4,5,6,7,8,9,9,9);
                //创建Stream
                a.stream()
                //中间操作
                .filter(i -> i%2 ==0 || i%3 ==0)
                .limit(7)
                .map(i -> i * i)
                .distinct()
                //终止操作
                .forEach(System.out::println);
    }

打开IDEA的调试模式,并点击横排图标最右侧的“Trace Current Stream Chain”就可追踪到Stream流的一些中间操作,具体如图3-1所示:

图3-1
  1. 查找
 /**
     * 查找
     * findFirst:查找流中的第一个元素
     * findAny:查找流中的任意一个元素
     * count:返回流中元素的总个数
     * */
    @Test
    public void testMatch(){


        //比较过后获取流中第一个元素,并放入Optional容器中
        Optional<User> op = user_list.stream()
                .sorted((e1,e2) -> -Double.compare(e1.getAge(), e2.getAge()))
                .findFirst();
        System.out.println(op.get());

        //从流中取出任意一个符合条件的元素,并放入Optional容器中
        Optional<User> op_2 = user_list.parallelStream()
                .filter((e) -> e.getStatus().equals(User.Status.STATUS_0))
                .findAny();
        System.out.println(op_2.get());

        //获取流中元素的个数
        Long count = user_list.stream()
                //filter加以条件限制
                .filter((e) -> e.getAge() > 30)
                .count();
        System.out.println(count);
        
        //获取最小的年龄(而不是最小年龄员工的信息)
        Optional<Integer> op_3 = user_list.stream()
                .map(User::getAge)
                .min(Integer::compare);
        System.out.println(op_3.get());
    }

对于获取源数据(如集合)中的具体某个元素,可以使用map()将所需信息提取出来,然后再进行比较操作。过程分析如下图3-2所示:

图3-2
  1. 排序
  /**
     * 排序
     * 1、sorted:自然排序(Comparable);
     * 2、sorted(Comparator com):定制排序。
     * */
    @Test
    public void test_1(){
        List<Integer> list = Arrays.asList(564,457,54,43,1,4,65);
        list.stream()
                .sorted()
                .forEach(System.out::println);

        user_list.stream()
                 .sorted((e1,e2) -> {
                     //年龄是否相同
                     if (e1.getAge().equals(e2.getAge())){
                         //年龄相同按照姓名比
                         return e1.getName().compareTo(e2.getName());
                     }else
                         return e1.getAge().compareTo(e2.getAge());
                 })
                 .forEach(System.out::println);
    }

四、时间日期 API

Java8中更新了时间日期相关的API,主要包括时间日期转换、时间校正器等。

4.1时间日期转换

在实际开发中的时间日期转换主要包括Date类型与String的互相转换、Long类型时间转换为String、Long类型时间转换为Date。

4.1.1Date与String的互转
  • DateTimeFormatter类
 /**
     * 时间格式转化:
     * 1、获取当前Date类型时间;
     * 2、将该时间转化为String类型;
     * 3、返回(输出)String类型的时间。
     * */
    @Test
    public void test_1(){
        //获取当前时间
        LocalDateTime ldt = LocalDateTime.now();
        //指定需要转化的格式
        DateTimeFormatter simpleDateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //将当前时间按照指定格式,转化为String类型输出
        String time = simpleDateFormat.format(ldt);
        System.out.println(time);
    }
  • @JsonFormat注解
  /**
     * 该注解将String类型的数据按照指定格式返回,但其数据类型仍然还是String
     * */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private String activityStartTime;
4.1.2Long转换为String(Date)
  • getTime()方法、Calendar类、SimpleDateFormat类
 /**
     * 时间格式转化:
     * 1、获取long类型的时间数(毫秒数);
     * 2、将该时间转化为String类型;
     * 3、返回(输出)String类型的时间。
     * */
    @Test
    public void test_2(){
        DateTest dateTest = new DateTest();
        //getTime()方法获取long类型时间数
        Long ssTime = dateTest.getTestTime().getTime();
        //声明一个Calendar类的通用对象
        Calendar calendar = Calendar.getInstance();
        //将long类型时间Set为Date类型
        calendar.setTimeInMillis(ssTime);
        System.out.println(calendar);
        //指定需要转化的格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = simpleDateFormat.format(calendar.getTime());
        System.out.println(time);
    }
posted @ 2022-06-08 11:15  Apluemxa  阅读(66)  评论(0编辑  收藏  举报
亚洲性爱无码区