java 基础&一些常用API - java8新特性 - 《Java 进阶》

Lambda表达式
Stream流
默认方法

Lambda表达式

面向对象思想：做一件事，找一个能解决这个事情的对象，调用对象的方法，完成事情。
函数式编程思想：只要能获取结果，谁去做的，怎么做的都不重要，重要的是结果，不重视过程

//匿名内部类写法
new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("lambda表达式1");
                System.out.println("lambda表达式2");
                System.out.println("lambda表达式3");
                System.out.println("lambda表达式4");
            }
        }).start();
//lambda表达式写法
new Thread(() -> {
            System.out.println("lambda表达式1");
            System.out.println("lambda表达式2");
            System.out.println("lambda表达式3");
            System.out.println("lambda表达式4");
        }).start();
//当只输出一句代码时,方法体的大括号可以省略
new Thread(() -> System.out.println("lambda表达式1")).start();

语法： ()->System.out.println(“多线程任务执行！”)
中间的一对小括号即run方法的参数(无)，代表不需要任何条件；
中间的一个箭头代表将前面的参数传递给后面的代码；
后面的输出语句即业务逻辑代码。

Stream流

map:提取对象里面的值
filter:筛选
collect:相当于返回一个集合
distinct:去重
sorted:可以通过比较器接口比较相应的值
limit:获取最后几条数据,并返回前两条数据
skip:去除前n个元素
count()获取条数，一般用于过滤之后的数据
allMatch:必须全部都满足才会返回true
anyMatch:只要有一个条件满足即返回true
noneMatch:全都不满足才会返回true
findFirst(:找到第一个元素
findAny:找到

List list = Arrays.asList(
new User(“李星云”, 18, 0, “渝州”, new BigDecimal(1000)),
new User(“陆林轩”, 16, 1, “渝州”, new BigDecimal(500)),
new User(“姬如雪”, 17, 1, “幻音坊”, new BigDecimal(800)),
new User(“袁天罡”, 99, 0, “藏兵谷”, new BigDecimal(100000)),
new User(“张子凡”, 19, 0, “天师府”, new BigDecimal(900)),
new User(“陆佑劫”, 45, 0, “不良人”, new BigDecimal(600)),
new User(“张天师”, 48, 0, “天师府”, new BigDecimal(1100)),
new User(“张天师”, 48, 0, “天师府”, new BigDecimal(1100)),
new User(“蚩梦”, 18, 1, “万毒窟”, new BigDecimal(800))
);
list.stream().filter(user -> user.getAge() > 18).forEach(System.out::println);//筛选年龄大于18的数据

List newList = list.stream().map(User::getAge).collect(Collectors.toList());//把年龄单独提取出来一个集合

List newList1 = list.stream().filter(user -> user.getAge() > 18).collect(Collectors.toList());//把年龄大于18的对象单独提取出来一个集合

List newList2 = list.stream().filter(user -> user.getAge() > 18).map(User::getAge).collect(Collectors.toList());//把年龄大于18年龄单独提出来一个集合

list.stream().distinct().forEach(System.out::println);//去掉重复的对象

List newList3 = list.stream().filter(user -> user.getAge() > 18).map(User::getAge).distinct().collect(Collectors.toList());//过滤18大于18岁的对象,并且根据年龄去重,然后返回年龄的集合

list.stream().map(User::getAge).sorted().forEach(System.out::println);//根据年龄排序并且返回年龄集合

list.stream().sorted(Comparator.comparingInt(User::getAge)).forEach(System.out::println);//通过比较器根据年龄排序

list.stream().sorted(Comparator.comparingInt(User::getAge)).limit(2).forEach(System.out::println);//通过比较器根据年龄排序，并返回前两条数据

list.stream().sorted(Comparator.comparingInt(User::getAge)).skip(2).forEach(System.out::println);//通过比较器根据年龄排序，去掉前两条数据

long count = list.stream().filter(user -> user.getAge() > 18).count();//获取年龄大于18岁的条数

/**
* 这里原集合中的数据由逗号分割，使用split进行拆分后，得到的是Stream，
* 字符串数组组成的流，要使用flatMap的Arrays::stream
* 将Stream转为Stream,然后把流相连接
*/
_List flatmap = new ArrayList<>();
flatmap.add(“常宣灵,常昊灵”);
flatmap.add(“孟婆,判官红,判官蓝”);
flatmap = flatmap.stream()
.map(s -> s.split(“,”))
.flatMap(Arrays::_stream)
.collect(Collectors.toList());
for (String name : flatmap) {
System.out.println(name);
}
System.out.println(list.stream().anyMatch(i -> i.getAge() == 18));//匹配是否含有年龄为18的数据,只要有一个条件满足即返回true

System.out.println(list.stream().allMatch(i -> i.getAge() == 18));//匹配是否含有年龄为18的数据,必须全部都满足才会返回true

System.out.println(list.stream().noneMatch(i -> i.getAge() == 18));//匹配是否含有年龄为18的数据,全都不满足才会返回true

Optional first = list.stream().sorted(Comparator.comparingInt(User::getAge)).findFirst();//返回第一条数据

Optional any = list.stream().findAny();//查找任意一个值

Optional max = list.stream().max(Comparator.comparing(User::getAge));//获取最大年龄的值

Optional min = list.stream().min(Comparator.comparing(User::getAge));//获取最小年龄的值

int sum = list.stream().mapToInt(User::getAge).sum();//求和

double avgAge = list.stream().collect(Collectors.averagingInt(User::getAge));//求平均值

IntSummaryStatistics statistics = list.stream().collect(Collectors.summarizingInt(User::getAge));//一次性得到元素的个数、总和、最大值、最小值

String names = list.stream().map(User::getName).collect(Collectors.joining(“, “));//拼接

Map> collect = list.stream().collect(Collectors.groupingBy(User::getAge));//根据年龄分组,并且返回map集合

Map>> collect = list.stream().collect(Collectors.groupingBy(User::getSex, Collectors.groupingBy(User::getAge)));//根据年龄和性别分组,返回的是嵌套的map

Map collect = list.stream().collect(Collectors.groupingBy(User::getSex, Collectors.counting()));//聚合求和

Map collect1 = list.stream().filter(user -> user.getAge() >= 18).collect(Collectors.groupingBy(User::getSex, Collectors.counting()));

Map> collect = list.stream().collect(Collectors.partitioningBy(user -> user.getAge() <= 30));//根据年龄小于等于30分区

默认方法

默认方法语法格式如下：

public interface vehicle {
    default void print() {
        System.out.println("我是一辆车!");
    }
}

多个默认方法
一个接口有默认方法，考虑这样的情况，一个类实现了多个接口，且这些接口有相同的默认方法，以下实例说明了这种情况的解决方法

public interface vehicle {
    default void print() {
        System.out.println("我是一辆车!");
    }
}

public interface fourWheeler {
    default void print() {
        System.out.println("我是一辆四轮车!");
    }
}

第一个解决方案是创建自己的默认方法，来覆盖重写接口的默认方法：

public class Car implements vehicle, fourWheeler {
    @Override
    public void print() {
        System.out.println("我是一辆四轮汽车!");
    }
}

第二种解决方案可以使用 super 来调用指定接口的默认方法：

public class Car implements vehicle, fourWheeler {
    @Override
    public void print() {
        vehicle.super.print();
    }
}

静态默认方法
Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法。例如：

public interface vehicle {
    default void print() {
        System.out.println("我是一辆车!");
    }
    // 静态方法
    static void blowHorn() {
        System.out.println("按喇叭!!!");
    }
}