JDK8的新特性

这两天开始看jdk8的新特性,先看了Lembda表达式和Stream,就一个感觉,优雅。
赶紧将这两天的成果总结一下

目录

Lembda表达式

lembda表达式是一个简洁、可传递的匿名函数,实现了把代码块赋值给一个变量的功能

是我认为jdk1.8中最让人眼前一亮的特性（我没用过其他函数式的语言）

在了解表达式之前，我们先看两个概念

函数式接口

含有且仅含有一个抽象方法，Lembda表达式需要借助函数式接口实现。

通常来说我们在这个接口定义上加上@FunctionInterface注解,语义化地标注它是一个函数式接口,起到的作用和@Override相同,只起到检查作用。

允许对接口进行默认实现

这次更新中新增了一个default关键字,用来在接口中添加非抽象的方法实现。这个特性也被成为扩展方法。

在实际使用Lembda表达式的时候，我们通过表达式实现相应的接口得到接口的实现对象。我们可以直接通过这些对象调用接口中的默认实现。

Lembda表达式格式

Lembda表达式通过左侧的参数，右侧的表达式和中间的右箭头组成：

(parameter1,parameter12,...) -> {
	expression;
	...
	return xxx;
}

可以理解为方法的另一种表现形式;
比如说这个接收a和b两个int参数,返回两数之和的方法

int addNum(int a,int b){
	return a + b;
}

可以写成下面这个形式

(int a,int b) -> {
	return a + b
}

需要注意的是:

  1. 参数可以为空 ()->xxx 这代表了无参方法
  2. 参数为一个值得时候,可以省略参数的括号 x->xxx
  3. 参数类型可以省略,Jdk会自动在接口中匹配相应的类型
  4. 表达式只有一行的时候不需要;,有多行的时候需要加上;
  5. 表达式可以是一个数字(直接返回这个数字),一个算式;可以是普通的一个语句(无返回,相当于void)
  6. 当表达式只有一行且最终为返回值时,return可以省略
  7. 参数的名不能和局部变量相同
  8. 表达式中直接调用的变量(不是传入的),必须是显示声明为final或事实上的final类型

自定义函数式接口并调用

我们定义一个入参是两个int类型,返回值也是int类型的方法;

然后添加一个将一个数加1并返回的扩展方法,使用default关键字;

@FunctionalInterface
interface Append {
    int append(int a, int b);

    default int addOne(int num) {
        return ++num;
    }
}

现在,我们使用Lambda表达式对这个接口进行实现:

Append append = (int a, int b) -> {
    return a + b;
};

然后我们调用这个方法,也调用接口的扩展方法

int num = append.append(1, 2);
int numAddOne = append.addOne(num);
System.out.println(num);//3
System.out.println(numAddOne);//4

根据上面总结的表达式格式注意事项,我们可以对表达式进行简化

当代码只有一行地时候可以不加分号

Append append = (int a, int b) -> { return a + b };

去掉参数类型,并且进一步简化右侧

Append append = (a, b) -> a + b;

方法调用

如果你使用的是IDEA较新版本,它会提示将它简化成另一种形式;

Append append = Integer::sum;

这是方法引用,在表达式中,我们可以通过类::方法的格式,直接将这个方法作为表达式的内容;

因此使用这种形式的时候无需指定参数,返回值等,因为这些已经确定了;

如果方法重载,jdk会根据传入的方法找到合适的方法

我们进入这个方法,发现它和我们的表达式相同

public static int sum(int a, int b) {
    return a + b;
}

我们还可以通过这种形式获得构造方法的调用

类::new

返回值就是通过合适构造方法(同样根据入参选择)创建的这个类的对象

Lambda表达式中变量的访问范围

  • 外部final变量
  • 成员变量
  • 静态变量

需要注意,在表达式中无法访问接口的扩展方法

JDK自带的常用函数式接口

  1. Predicate 判断,
    boolean test(T t); 对单一参数进行判断,拓展方法可以对Predicate进行or,and的逻辑拼接,进行更复杂的逻辑判断

    利用我们在外部设定的条件对于传入的参数进行校验并返回验证通过与否

  2. Consumer 消费者
    void accept(T t); 消费掉参数,啥也不返回,拓展方法可以拼接消费者链,按次序依次执行

    接收参数并依据传递的行为应用传递的参数值

  3. Function<T, R> 方法
    R apoly(T t); ,该接口中有很多拓展方法,可以将多个Function拼接在一起,进行复杂的逻辑运算
    执行转换操作，输入类型 T 的数据，返回 R 类型的结果

这三个是最重要的接口,Stream也用到这些接口,下面我强行使用这三个接口

    /*Predicate<T> 判断*/
    Predicate<String> stringPredicate = str -> StringUtils.isBlank(str) || "error".equalsIgnoreCase(str);
    
    /*Consumer<T>*/
    Consumer<String> stringConsumer = str -> {
        if (StringUtils.isBlank(str) || "error".equalsIgnoreCase(str)) {
            System.out.println("Consumer失败");
        }
    };
    /*Function<T,R>*/
    Function<String, String> stringStringFunction = str -> {
        if (StringUtils.isBlank(str) || "error".equalsIgnoreCase(str)) {
            return "Function失败";
        } else {
            return "Function成功";
        }
    };
    String in = "error";
    if (stringPredicate.test(in)) {
        System.out.println("Predicate失败");
    }
    stringConsumer.accept(in);
    System.out.println(stringStringFunction.apply(in));

二.Stream流

Stream使用上面说的JDK自带的函数式接口

Stream是一种函数式编程对集合，数组，I/O channel， 产生器generator等数据的操作方式,它有以下特点:

  1. 无储存,Stream本身不会储存数据
  2. 不会修改传入的数据源
  3. 惰性执行:Stream上的操作不会立即执行,而是会在真正需要的时候进行
  4. 可消费性:Stream只能被消费一次,类似迭代器,想要再次遍历,必须生成新的Stream.

在学习过程中,我发现Stream某些操作之后返回的仍然是流,而有些操作返回的确实真实的被处理之后数据,Stream的操作可以据此分为两种

  1. 中间操作 总是会惰式执行，调用中间操作只会生成一个标记了该操作的新stream。
  2. 结束操作 会触发实际计算，计算发生时会把所有中间操作积攒的操作以pipeline的方式执行，这样可以减少迭代次数。计算完成之后stream就会失效。

总之,把Stream看做一根水管就好啦,一开始把一根根水管拼接起来(中间操作),安装一个水龙头(结束操作),确认有水龙头之后水就依次通过水管,最后通过水龙头进入下水道(不能重复使用);

Collection.stream() 或者 Collection.parallelStream() 来创建一个串行Stream或者并行Stream。

常用的Stream方法

中间操作

sorted排序

Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);

这是一个有状态的操作

用法 作用
sorted() 自然排序
sorted(Comparator.reverseOrder()) 自然逆向排序
sorted(Comparator.comparing(Student::getAge)) 通过某些元素排序
sorted(Comparator.comparing(Student::getAge).reversed()) 通过某些元素逆向排序

Comparator是比较器

map元素操作

<R> Stream<R> map(Function<? super T, ? extends R> mapper);
用于对每个元素进行操作,并且将处理后的Stream返回
例如map(i->i*2)将所有数据进行平方操作

filter过滤

Stream<T> filter(Predicate<? super T> predicate);
入参为Predicate,lembda表达式返回值是boolean;
如果表达式为flase,则剔除数据,只留符合条件的
过滤是中间操作:Stream<Integer> integerStream = intList.stream().filter(i -> i > 4);

limit限制

Stream<T> limit(long maxSize);
限制数据的数量,这是一个有状态的短路的操作。

distinct去重

Stream<T> distinct();
去除重复的操作,这是一个有状态的操作

结束操作

forEach迭代

void forEach(Consumer<? super T> action);
入参是Consumer,表达式不需要返回值,方法本身返回值void,所以是结束操作
常用的方法是forEach(System.out::println);

collect存入容器

<R, A> R collect(Collector<? super T, A, R> collector);
将数据存入一个Collection或Map

toArray存入数组

Object[] toArray();
将结果存入一个数组中

count计数

long count();
计算流中元素的数量

max 和 min

Optional<T> min(Comparator<? super T> comparator);
Optional<T> max(Comparator<? super T> comparator);
根据一个比较器找到最大或最小元素

anyMatch allMatch noneMatch 匹配

boolean anyMatch(Predicate<? super T> predicate);三个都一样
是否至少有一个元素匹配
是否每一个元素都匹配
是否没有元素匹配

findFirst findAny 查找

Optional<T> findFirst();
查找第一个元素
查找随机的一个元素

Stream常用代码

List转Map

Map<Integer, A> aMap = aList.stream().collect(Collectors.toMap(A::getId, a -> a,(k1,k2)->k1));

Map转List

    List<AObject> list = map.entrySet().stream()//转化成流
            .sorted(Comparator.comparing(Map.Entry::getKey)) //根据key排序
            .map(entry -> new AObject(entry.getKey(), entry.getValue()))
            .collect(Collectors.toList()); //map转化成AObject对象集合

一个获取随机数的方法

random.ints().limit(10).forEach(System.out::println);

3.Map新方法

4.时间日期新API

5.多重注解

参考资料:

  1. https://blog.csdn.net/chenhao_c_h/article/details/80691284
  2. https://www.cnblogs.com/pikachu-zhaof/p/9724826.html
  3. www.importnew.com/10360.html
posted @ 2018-12-24 11:54  XmCui  阅读(419)  评论(0)  编辑  收藏  举报