java8 新特性集锦和心得

 java8问世已经好几年了，但很多程序猿/媛小伙伴们都还没普遍在项目里去使用起来，更多的可能还是缺少了解，究其根源，我想是因为国内没有能普及到程序员层面的活动或大会去推广，目前每年举办的各类活动或大会大都是针对高级架构师级别的，比如极客邦联合InfoQ举办的ArchSummit等等，却很少有针对程序员层面的沙龙。

好了，废话不多说了，这里分享下收集的java8几个重要特性。

一.全局概览

这里分享一个网上的新特性全集的框图，先对总览有个了解：

https://www.processon.com/view/5abb31abe4b027675e42cebc

综合来看，在日常项目里比较常用的是基于流的Lambda的使用，本文主要围绕这方面来讲解。大家会问了，这个东西怎么来的呢？

其实，Lambda属于函数式编程，而函数式语法很早就在一些编程语言中如Scala,Ruby中有了，其根本还是基于类型推导和闭包的思想，例如在Scala里，我们用.filter(aa=>aa.contains("hello"))来在集合里查找包含"hello"字符串的记录，而在Java8中的Lambda表达式，允许把函数作为一个方法的参数，使用-> 替代=>并且做了很多增强功能（例如单句执行可省略该符号）。

Stream：流式处理，任何集合类都可以变成流之后进行各种操作和处理，和早期java I/O里的InputStream和OutputStream也是先把一个文件File对象或业务数据Object转为byte放入Stream对象变成二进制流在网络上通信类似的道理。

其他本文涉及到的特性：

方法引用、函数式接口、接口默认方法、Optional类、DateTimeAPI、Nashorn和Js引擎、Base64。其中后三种属于工具类直接用即可，就不进行细说了。

二.特性详解

1.Lambda表达式

Lambda表达式是基于新特性包里Stream API的，即位于java 8的java.util.stream包里面，把函数式编程风格引入到java中了。原理是和Callable类似，启动一个新的线程来执行函数体。

基础语法：

expression = (variable) -> action

• variable: 这是一个变量,一个占位符。像x,y,z,可以是多个变量。
• action: 这里我称它为action, 这是我们实现的代码逻辑部分,它可以是一行代码也可以是一个代码片段

可以看到Java中lambda表达式的格式：参数、箭头、以及动作实现，当一个动作实现无法用一行代码完成，可以编写 一段代码用{}包裹起来。

使用->将参数和实现逻辑分离，当运行这个线程的时候执行的是->之后的代码片段，且编译器帮助我们做了类型推导； 这个代码片段可以是用{}包含的一段逻辑。

也可以包含多个参数,例如：

int sum = (x, y) -> x + y;

 

集合用法:

范例：

List<Object> lst = JsonFormatter.toObject(JsonFormatter.toJsonString(responseVo.getData()), List.class);

if (!ListUtil.isEmpty(lst)) {
    list = lst.stream().map(j -> JsonUtil.formatObject(j, clazz)).collect(Collectors.toList());
}


Set<String> numSet = redisUtil.zrangeStr(RedisKey.SA_FMS_MEET_ZSET, startIndx, endIndx - 1);

//Format room number to [6 digits], then sort in [ascending] order
List<String> resList = numSet.stream().map(str -> {
    return String.format("%06d", Integer.valueOf(str));
}).sorted((String s1, String s2) -> {
    return s1.compareTo(s2);
}).collect(Collectors.toList());

//Delete data
redisUtil.delete(RedisKey.SA_ROOM_NO_LIST_ + suffixKey);

//Save data
redisUtil.rightPushAll(RedisKey.SA_ROOM_NO_LIST_ + suffixKey, resList, Constants.CACHE_EXPIRATION_WEEKLY);

 

线程用法:

new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();

Runnable r = () -> System.out.println("do something.");

 

其他用法方式:

(params) -> expression

(params) -> statement

(params) -> { statements }

例如：

() -> System.out.println("Hello Lambda Expressions");

 

条件判断用法：

写了3个Demo参考：

//Demo1-验证条件
import java.util.function.Predicate;

int age = 25;
Predicate<Integer> agePredicate = x -> x >= 18;
return agePredicate.test(age);

//Demo2-封装成专门判断的子方法
//基于Demo1,我们可以封装条件判断到一个子方法里面(尤其是很多条件的时候,可以用List<Predicate<T>>),亦或把要校验的属性都放到一个Map里通过K-V某个规则校验
private void doPredicate(Object value, Predicate<T> predicate){
    if(value == null){
        throw new RuntimeException("No predicate param value";)
    }
};

//调用
boolean isAdult = doPredicate(20, x -> x >= 18);

//Demo3-代入Lambda使用
//可结合业务条件进行动态条件嵌入
Predicate<CouponReduceInfoBo> filterCondition = null;

if (StringUtils.isNotBlank(orderId)) {
    filterCondition = (t) -> null != t && orderId.equals(t.getOrderId());
} else if (StringUtils.isNotBlank(orderItemId)) {
    filterCondition = (t) -> null != t && orderItemId.equals(t.getOrderItemId());
}

Map<TestInfoBo , Map<Long, BigDecimal>> testMap = [此处省略集合构造]...;
final TestInfoBo testInfoBo = testMap.keySet().stream()
                                                    .filter(filterCondition).findFirst().get();

 

Swing:

show.addActionListener((e) -> {

    System.out.println("Light, Camera, Action !! Lambda expressions Rocks");

});

 

List迭代:

List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");

features.forEach(n -> System.out.println(n));

features.forEach(System.out::println); //方法引用

List<String> list = java.util.Arrays.asList("a","b","c");

Stream.iterate(0, i -> i + 1).limit(list.size()).forEach(i -> {

    System.out.println(String.valueOf(i) + list.get(i));

});

 

Stream API条件过滤：

List lst = Arrays.asList("aaeett","bbcc","ccwewff","ddd","ebbbe");

filter(lst, (str) => str.startWith("a"));

filter(languages, (str)->str.endsWith("d"));

filter(languages, (str)->true);

filter(languages, (str)->false);

filter(languages, (str)->str.length() > 4);



public static void filter(List names, Predicate condition){

    for(String name:names){

        if(condition.test(name)){

            System.out.println(name + " ");

        }
    }
}

 

或:

List<String> filtered = strList.stream().filter(x -> x.length()> 2).collect(Collectors.toList());

System.out.printf("Original List : %s, filtered list : %s %n", strList, filtered);

 

条件合并：

//也可以用and()、or()和xor()逻辑函数来合并Predicate，

//比如要找到所有以J开始，长度为四个字母的名字，你可以合并两个Predicate并传入

Predicate<String> startsWithJ = (n) -> n.startsWith("J");

Predicate<String> fourLetterLong = (n) -> n.length() == 4;

names.stream().filter(startsWithJ.and(fourLetterLong))

              .forEach((n) -> System.out.print("nName, which starts with 'J' and four letter"));

Map和Reduce的使用:

map: 将集合类（例如列表）元素进行转换

reduce: 折叠操作，可以将所有值合并成一个

//计算总和
double bill = costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> sum + cost).get();
System.out.println("Total : " + bill);

//连接
List<String> G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy", "U.K.","Canada");
String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));
System.out.println(G7Countries);

//集合去重
List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
List<Integer> distinct = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
System.out.printf("Original List : %s,  Square Without duplicates : %s %n", numbers, distinct);

//集合取值操作
List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("Highest prime number in List : " + stats.getMax());
System.out.println("Lowest prime number in List : " + stats.getMin());
System.out.println("Sum of all prime numbers : " + stats.getSum());
System.out.println("Average of all prime numbers : " + stats.getAverage());

//排序(自然排序)
List<Integer> list = Arrays.asList(2, 7, 3, 1, 8, 6, 4);
list.sort(Comparator.naturalOrder());
System.out.println(list);

Map过滤：

Map<Integer, String> map = weekMap.entrySet().stream().filter(r -> r.getKey() <= 3)
                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Map<Integer, String> map = weekMap.entrySet().stream().filter(r -> r.getValue().startsWith("S"))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
        assertThat(map.values(), contains("Saturday","Sunday"));

Map<Integer, String> map = Maps.filterValues(weekMap, r -> r.startsWith("S"));
        assertThat(map.values(), contains("Saturday","Sunday"));

ListUtil分组的用法：

    if (thresholdsDtos.size() > 0) {
        Map<Integer, List<BookingThresholdDto>> map = ListUtil.groupByProperty(thresholdsDtos, "dayOfWeek",
                Integer.class);
        List<Float> scoreList = new LinkedList<Float>();
        for (String time : times) {
            float scores = 0;
            for (Integer key : map.keySet()) {
                List<BookingThresholdDto> dos = map.get(key);
                dos = dos.stream().filter(d -> d.getSessionTime().equals(time)).collect(Collectors.toList());
                BookingThresholdDto dt = dos.get(0);
                scores += dt.getScore();
            }
            scoreMap.put(time, scores);
            scoreList.add(scores);
        }
        Collections.sort(scoreList);
    }

集合内分组操作:

Map<Long, List<TestInfoBo>> groupCouponMap;
testGroupMap = testInfoList.stream()
                .collect(Collectors.groupingBy(TestInfoBo::getTestId));
for (Map.Entry<Long, List<TestInfoBo>> entry : testGroupMap.entrySet()) {
//...
}

从map中求和：

//金额求和
Map<TestInfoBo, Map<Long, BigDecimal>> testMap = new HashMap(16);
List<BigDecimal> testAmountList = new ArrayList();
if(!testMap.isEmpty()){
Collection<Map<Long, BigDecimal>> testAmtMapList = testMap.values();
testAmtMapList.forEach(r -> {
testAmtMapList.add(r.values().stream().reduce(BigDecimal.ZERO, BigDecimal::add));
});
BigDecimal totalAmount = testAmtMapList.stream().reduce(BigDecimal.ZERO, BigDecimal::add);

//一般数字求和
Long totalRemainQuantity = testList.stream()
                           .filter(c -> c.getCpId().equals(cpId))
                                                           .mapToLong(TestInfoBo::getRemainQuantity).sum();

排序：

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

// 使用lambda表达式
Comparator<Integer> comparator1 = (a, b) -> a - b;

// 使用静态方法引用
Comparator<Integer> comparator2 = Integer::compare;
List<Integer> sorted1 = ids.stream().sorted(comparator1).collect(Collectors.toList());
List<Integer> sorted2 = ids.stream().sorted(comparator2).collect(Collectors.toList());
 
System.out.println(ids);// [1, 2, 5, 4, 3]
System.out.println(sorted1); // [1, 2, 3, 4, 5]
System.out.println(sorted2); // [1, 2, 3, 4, 5]

2.函数式接口

λ表达式的类型，叫做 目标类型（target type）--函数接口（functional interface），只能有一个显式声明的抽象方法，使用@FunctionalInterface标注。

认识心得：lambda其实就是为@FunctionalInterface服务的，基于自动的类型推导机制，能够用一种全新的、简洁的语法创建函数式接口的对象。当然如果一个接口不符合函数式接口的定义，是不能通过lambda表达式来创建其对象的。lambda其实就是定义入参、函数体、返回值，然后可以生成任意一个接口(符合该函数入参和返回值的函数式接口)的对象。

 

常用的系统自带的函数接口（也可以自定义）：

@FunctionalInterface
public interface Runnable { void run(); }
public interface Callable<V> { V call() throws Exception; }
public interface ActionListener { void actionPerformed(ActionEvent e); }
public interface Comparator<T> { int compare(T o1, T o2); boolean equals(Object obj); }

//Demo
@FunctionalInterface
public interface CatInterface {
    void sayHello();
}

//调用
CatInterface cat = () -> {System.out.println("cat");}
cat.sayHello();

//其他
void add(int left, int right);
TwoArgsInterface twoArgs1 = (int a, int b) -> System.out.println("no argument");
TwoArgsInterface twoArgs2 = (a, b) -> System.out.println("no argument");

//当参数个数只有一个，可以省略小括号：
OneArgsInterface oneArgs3 = a -> System.out.println("arguments=" + a);

//当lambda表达式只包含一条语句时，可以省略大括号、return和语句结尾的分号：
DemoInterface way2 = a -> a * 10;

3.方法引用

 JDK8中的方法引用分成4类：静态方法引用、实例方法引用、构造方法引用、以静态方式引用实例方法：

静态方法引用
ClassName::staticMethodName：
String::valueOf   等价于lambda表达式 (s)  -> String.valueOf(s)
Math::pow          等价于lambda表达式 (x, y) -> Math.pow(x, y)

//静态方法引用pow
MyInterface ins1 = Math::pow;
System.out.println(ins1.calculate(2, 4) == 16);
 
//静态方法引用max
MyInterface ins2 = Math::max;
System.out.println(ins2.calculate(2, 4) == 4);

实例方法引用
instanceReference::methodName
str::toString  等价于lambda表达式 ()  ->  str.toString()
str::concat    等价于lambda表达式 (another)  ->  str.concat(another)

//例：
//比较操作:不用自己实现Comparator
//方式3
Collections.sort(persons, Comparator.comparing(Person::getName));
System.out.println(persons);

//按照默认顺序的相反顺序排序
		List<Student> descList = students.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
		System.out.println(descList);


//使用lambda表达式创建Function对象
		Function<Student, Integer> extractIdWay1 = (student) -> student.getId();
		
		// 使用方法引用简化lambda
		Function<Student, Integer> extractIdWay2 = Student::getId;
		
		// Comparator.comparing(Function keyExtractor)
		Comparator<Student> byId = Comparator.comparing(extractIdWay2);
		
		// 升序
		List<Student> ascList = students.stream().sorted(byId).collect(Collectors.toList());
		System.out.println(ascList);
		
		// 降序
		List<Student> descList = students.stream().sorted(byId.reversed()).collect(Collectors.toList());
		System.out.println(descList);