JAVA的新特性

比眉伴天荒 2021-09-27 19:48 342阅读 0赞

> **JDK1.8的新特性**  
> 匿名类  
> 接口新特性  
> Lambda(λ)表达式;  
> 数据流:深入到JDK源码中写代码;Spark增强版的数据流  
> 时间的新特性  
> **1.匿名类**  
> 多线程:Runnable接口  
> 1 先写一个类,实现runnable接口,重写run方法  
> 2 在main方法中new Thread(runnable).start();  
> 标准:  
> 1 得有接口,接口里面的方法比较少;  
> 2 大括号就是类体,木有类的名字,所以叫做匿名类  
> \*\* 用在哪里面:\*\*  
> 1 确定类体只能使用一次代码;run方法不能重复使用  
> 2 好处:省去了一个MyRunnable的类

**2.接口**  
属性:public static final ;写不写都一样;接口.属性就可以使用;  
方法:全部是抽象的:public abstract void  
需求:标准  
所有实现类的方法都是一样的(得new对象;在方法上面加上default  
接口里面的方法也可是静态的;(得类名.方法名);  
**3.lambda表达式**  
语法超级简单:—python,scala;  
相当于匿名函数(方法);方法的参数居然可是一个方法;js的类型就有Function;特殊像匿名类  
写法  
(参数,参数2,参数3…) ->  
\{  
方法体;  
\}

所有的参数类型可以省略,会推算出变量的类型  
如果参数只有一个,小括号可以省略  
如果方法体只有一行,大括号可以省略;  
**E(变量名) -> 方法体只有一行**

哪些地方可以写Lambda表达式  
必须接口中有只有一个抽象的方法  
某个方法的参数是此接口;  
参数列表和方法体,返回值如何对应(参照的是接口中抽象方法)  
接口的注解:@override,@Test;如果接口的注解是@FunctionalInterface,优先级最高,肯定可以写lambda表达式;  
![在这里插入图片描述][20181115100959962.png]

**4 方法引用**

OverrideImp::new = new OverrideImp()

: 表示调用方法;左边是类名或者对象;右边是方法名;木有参数  
只能调用无参的

**5.数据流**  
**Stream:**  
1 返回值是最终的结果;所有的操作马上执行;action  
2 返回值还是流(他自己),链式编程;所有的操作都不会执行;(懒执行);transformation  
**主要方法:**  
1 Parallel:平行;单线程,调用此方法会变成多线程;利用CPU硬件的核数全部计算  
2 Filter:不是最终的;(transformation);算子(方法);过滤数据使用的  
3 Map:transformation算子,从一个值变成另外一个值;  
4 flatMap:transformation算子,  
5 Distinct:transformation去掉;  
6 Sorted:排序;transformation  
7 Limit:transformation取前几条记录;每页多少条  
8 Skip:transformation跳过;从第几条开始,跳过前面的第N条;  
9 forEach:action;循环  
10 toArray:action;数组  
11 Reduce:减少;(合并);action  
12 Collect:action;把每一个线程算完的结果汇总一下  
13 min和max(action)  
14 Count:action;总条数  
15 findFirst,findAny;  
16 Of:把一个参数放到数据流里面  
**方法的测试代码**

package com.carlinfo.news.stream;

import java.util.Arrays;  
import java.util.List;  
import java.util.Optional;  
import java.util.function.Consumer;  
import java.util.function.Function;  
import java.util.function.Predicate;  
import java.util.stream.Collectors;  
import java.util.stream.Stream;

import org.junit.Test;

/\*\*

*  流式的操作
 *  
 *  流式操作和Spark的关系特别像:
 *  
 *  javase中的容器;[http://commons.apache.org/proper/commons-collections/][http_commons.apache.org_proper_commons-collections]
 *  
 *  @author WangshMac  
    \*/  
    public class StreamMain  
    \{  
    private List alList = Arrays.asList(“test”, “text”, “b”,“b”, “c”, “d”);
    
    /\*\*
    
     *  filter
     *  
     *  检查一个,公布一个结果;并不是将所有的全部检查完以后,再公布结果
     *  action类算子,一旦执行,stream自己关闭
     *  如果你觉得效率特别低
     *  paralel:一定要写到最前面;  
        */  
        @Test  
        public void filter()  
        \{  
        /* 流:Stream */  
        Stream stream = alList.stream() ;  
        /*\----Java原生的编程----*/  
        /* transformation算子:
        
         *  懒执行:
         *  transformation要想执行,后面紧跟一个action算子;链式编程
         *  */  
            stream = stream.parallel().filter(new Predicate()  
            \{  
            @Override  
            public boolean test(String t)  
            \{  
            System.out.println(t + “Predicate”);  
            return true;  
            \}  
            \});  
            /* 循环:匿名类
         *  
         *  Action类算子
         *  方法是一个接口
         *  */  
            stream.forEach(new Consumer()  
            \{  
            @Override  
            public void accept(String t)  
            \{  
            System.out.println(t + “java接口”);  
            \}  
            \});  
            /* 关闭 \*/  
            stream.close();
        
        /\*----Lambda的编程----
        
         *  ~先看方法的参数是哪个接口
         *  ~再看接口中的抽象方法(只有一个)
         *  ~对着接口中抽象的方法:只关心,形参和返回值
         *  
         *  链式编程
         *  \*/  
            stream = alList.stream() ;  
            stream.filter( e ->  
            \{  
            System.out.println("=lambda=检查==" + e);  
            /\*return true ; \*/  
            boolean flag = e.indexOf(“te”) != -1 ;  
            return flag ;  
            \}).forEach((String c) ->  
            \{  
            System.out.println(“lambda=循环” + c);  
            \});  
            \}
    
    /\*\*
    
     *  map的相关方法  
        */  
        @Test  
        public void map()  
        \{  
        /* 获取一个流 */  
        Stream stream = this.alList.stream() ;  
        /*\----java版本----*/  
        /*
        
         *  T:输入参数
         *  $:输出结果
         *  */  
            Stream streamInt = stream.map(new Function<String, Integer>()  
            \{  
            @Override  
            public Integer apply(String t)  
            \{  
            System.out.println(t + “map=”);  
            /* 写死了 */  
            return 1;  
            \}  
            \}).distinct();  
            /* 去重 \*/
        
        /\* 循环 \*/  
        streamInt.forEach(new Consumer()  
        \{  
        @Override  
        public void accept(Integer t)  
        \{  
        System.out.println(t + “foreach=”);  
        \}  
        \});
        
        //System.out.println(streamInt.count() + “=count”);  
        /*----lambda表达式–入-----*/  
        /\*\*
        
         *  lambda大部分情况下会自动判断类型,有些判断不了;  
            */  
            stream = alList.stream() ;  
            /* map操作 */  
            streamInt = stream.map( e ->  
            \{  
            System.out.println(e + “maplambda=”);  
            return 1 ;  
            \}).distinct();  
            /streamInt.forEach(e ->  
            \{  
            System.out.println(e + “foreach=lambda”);  
            \});/  
            /* 计算总条数 \*/  
            System.out.println(streamInt.count() + “=count”);  
            \}
    
    /\*\*
    
     *  压平;平板
     *  和map特别像  
        */  
        @Test  
        public void flatMap()  
        \{  
        Stream stream = this.alList.stream() ;  
        /* flatmap
        
         *  返回值再也不是Stream了,而是Stream
         *  */  
            List resultList = stream.flatMap(new Function<String, Stream>()  
            \{  
            @Override  
            public Stream apply(String t)  
            \{  
            System.out.println(“flatmap java” + t);  
            /* map的返回值是Integer,  
            \* flatMap的返回值是Stream */  
            return Stream.of(t);  
            \}  
            \}).distinct().collect(Collectors.toList());  
            /* :distinct:去重
         *  collect:收集;参数的类型,看API文档 \*/  
            System.out.println(“结果>” + resultList);
        
        /\* lambda表达式, \*/  
        \}
    
    /\*\*
    
     *  其它的方法  
        */  
        @Test  
        public void others()  
        \{  
        Stream stream = this.alList.stream() ;  
        /* action算子 */  
        //stream  
        /* 排序
        
         *  默认升序,
         *  可以指定比较器,倒序 */  
            //.sorted((e1,e2) -> -e1.compareTo(e2))  
            /* 跳过 */  
            //.skip(3)  
            /* 每页多少条 \*/  
            //.limit(2)  
            //.forEach(e -> System.out.println("====" + e));  
            /\* 取第一个 */  
            Optional optional = stream  
            /* 取第一个 */  
            //.findFirst();  
            /* 取任何一个 */  
            //.findAny();  
            /* 取最小的 \*/  
            .min((e1,e2) -> e1.compareTo(e2));  
            System.out.println("–findFirst-----" + optional.get()) ;  
            \}  
            \}

[20181115100959962.png]: /images/20210923/cc574e60ebe74369a57b55baafa6ae9b.png
[http_commons.apache.org_proper_commons-collections]: http://commons.apache.org/proper/commons-collections/