Java8新特性

• Lambda表达式
• 函数式接口
• 方法引用与构造器引用
• Stream API
• 接口中的默认方法与静态方法
• 新时间日期API
• 其他新特性

新加入了红黑树、CAS、元空间等等
其中最为核心的为Lambda表达式与Stream API

Lambda表达式

Lambda概述

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

基础语法

Java8中引入了一个新的操作符"->"，该操作符称为箭头操作符或Lambda操作符
箭头操作符将Lambda表达式拆分成两部分:
左侧: Lambda表达式的参数列表
右侧: Lambda表达式中所需执行的功能，即Lambda体

语法格式一:无参数，无返回值

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

语法格式二:有一个参数，并且无返回值

(x) -> System.out.println(x)；

语法格式三:若只有一个参数，小括号可以省略不写

x -> System.out.println(x)

语法格式四:有两个以上的参数，有返回值，并且Lambda体中有多条语句

Comparator<Integer> com = (x, y) -> {
	System. out.println("函数式接口");
	return Integer.compare(x, y);
};

语法格式五:若Lambda体中只有一条语句，return 和大括号都可以省略不写

Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

语法格式六: Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”

(Integer X, Integer y) -> Integer.compare(x, y);
(X, y) -> Integer.compare(x, y);

总结
上联:左右遇一括号省
下联:左侧推断类型省
横批:能省则省
Lambda表达式需要函数式接口的支持

函数式接口

函数式接口:接口中只有一个抽象方法的接口，称为函数式接口。可以使用注解@FunctionalInterface修饰。

四大函数式接口：Function、Predicate、Consumer、Supplier

Function 函数式接口

/**
 * Function 函数型接口, 有一个输入参数，有一个输出 
 */ 
public class Demo01 { 
    public static void main(String[] args) { 
        Function<String,String> function = (str)->{return str;};
        System.out.println(function.apply("Function 函数型接口")); 
    } 
}

Predicate 断定型接口

/**
 * 断定型接口：有一个输入参数，返回值只能是 布尔值！ 
 */ 
public class Demo02 { 
    public static void main(String[] args) { 
        Predicate<String> predicate = (str)->{return str.isEmpty();}; 
        System.out.println(predicate.test("")); 
    } 
}

Consumer 消费型接口

/**
 * Consumer 消费型接口: 只有输入，没有返回值 
 */ 
public class Demo03 { 
    public static void main(String[] args) { 
        Consumer<String> consumer = (str)->{System.out.println(str);}; 
        consumer.accept("Consumer 消费型接口"); 
    } 
}

Supplier 供给型接口

/**
 * Supplier 供给型接口 没有参数，只有返回值 
 */ 
public class Demo04 { 
    public static void main(String[] args) { 
        Supplier supplier = ()->{ return 1024; }; 
        System.out.println(supplier.get()); 
    } 
}

方法引用

方法引用:若Lambda体中的内容有方法已经实现了，我们可以使用"方法引用"(可以理解为方法引用是Lambda表达式的另外一种表现形式)，其实就是Lambda方法体去引用已经实现的方法。

主要有三种语法格式:
对象: :实例方法名
类: :静态方法名
类::实例方法名

注意：

• Lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致!
• 若Lambda参数列表中的第一参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用类::实例方法名

//对象::实例方法名
@Test
public void test1(){
	PrintStream ps = System.out;
	Consumer<String> con = (x) -> ps.println(x);
	
	//Consumer<String> con2 = System.out::println;
	Consumer<String> con1 = ps::println;
	con1.accept("abcdef");
}

//对象::实例方法名
@Test
public void test2(){
	Employee emp = new Employee( ) ;
	Supplier<String> sup = () -> emp.getName();
	System.out.println(sup.get());
	
	Supplier<Integer> sup2 = emp::getAge;
	System.out.println(sup2.get()) ;
}

//类::静态方法名
@Test
public void test3(){
	Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
	Comparator<Integer> com1 = Integer::compare ;
}

//类::实例方法名
//若Lambda参数列表中的第一参数是实例方法的调用者，
//而第二个参数是实例方法的参数时，可以使用类::实例方法名
@Test
public void test4(){
	BiPredicate<String, String> bp = (x, y) -> x.equals(y);
	BiPredicate<String, String> bp2 = String::equals;
}

构造器引用

格式:ClassName: : new
注意:需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致!

//构造器引用
@Test
public void test5(){
	Supplier<Emp1oyee> sup = () -> new Employee();
	
	//构造器引用方式
	//无参构造
	Supplier<Employee> sup2 = Employee::new;
	Employee emp = sup2.get();
	System.out.println(emp) ;
}

@Test
public void test6( ){
	Function<Integer, Employee> fun = (x) -> new Employee(x);
	//一个参数的构造器
	Function<Integer, Employee> fun2 = Employee::new;
	Employee emp = fun2.apply(101);
	System.out.println(emp);
	//两个参数的构造器
	BiFunction<Integer, Integer, Employee> bf = Employee::new;
}

数组引用

//数组引用:
@Test
public void test7(){
	Function<Integer, String[]> fun (x) -> new String[x] ;
	String[] strs = fun.apply(10);
	System.out.println(strs.length);
	
	Function<Integer, String[]> fun2 = String[]::new;
	String[] strs2 = fun2.app1y(20);
	System.out.println(strs2.length);
}

Stream API

Stream概述

Java8中有两大最为重要的改变。第一个是Lambda 表达式;另外一个则是Stream API(java. util. stream. *)。
Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL 执行的数据库查询。也可以使用Stream API来并行执行操作。
简而言之，StreamAPI提供了一种高效且易于使用的处理数据的方式。

流是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。
“集合讲的是数据，流讲的是计算!”
注意:

• Stream自己不会存储元素。
• Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream
• Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
  
  
  
  

Stream 操作使用

Stream 三个操作步骤

• 创建操作
• 中间操作
• 终止操作

创建操作

//创建Stream
@Test
public void test1() {
    //1、可以通过 Collection 系列集合提供的 stream() 或 parallelStream()
    List<String> list = new ArrayList<>();
    Stream<String> stream1 = list.stream(); //串行流
    Stream<String> stream2 = list.parallelStream(); //并行流

    //2、通过 Arrays 中的静态方法 stream() 获取数组流
    Employee[] emp = new Employee[10];
    Stream<Employee> stream3 = Arrays.stream(emp);

    //3、通过 Stream 类中的静态方法 of()
    Stream<String> stream4 = Stream.of("a", "b", "c");

    //4、创建无限流
    //迭代 无限执行函数，seed种子(初始值),UnaryOperator(函数)
    Stream<Integer> stream5 = Stream.iterate(0, (x) -> x + 2);
    //生成 无限生成随机数() -> Math.random()
    Stream<Double> stream6 = Stream.generate(() -> Math.random());
}

中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理!而在终止操作时一次性全部处理，称为惰性求值。

 /**
 * 筛选与切片
 * filter-接收Lambda，从流中排除某些元素。
 * limit-截断流, 使其元素不超过给定数量。
 * skip(n) -跳过元素, 返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补
 * distinct-筛选, 通过流所生成元素的hashCode()和equals()去除重复元素
 */
@Test
public void test2(){
    //中间操作
    Stream<Employee> stream = emp1oyees.stream()
            .filter(e -> e.getAge() > 12)
            .limit(3)
            //.skip(2)
            .distinct();
    //终止操作
    //迭代操作由 Stream API 完成，称为内部迭代
    stream.forEach(System.out::println);
}

/**
 * 映射
 * map-接收 Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上,并将其映射成一个新的元素。
 * flatMap-接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
 */
@Test
public void test3(){
    List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
    list.stream()
            .map( str -> str.toUpperCase())
            .forEach(System.out::println);

    System.out.println("------------------------------");

    list.stream()
            .flatMap(Java8Test::filterCharacter)
            .forEach(System.out::println);
}

public static Stream<Character> filterCharacter(String str){
    List<Character> list = new ArrayList<>();
    for (Character ch : str.toCharArray()) {
        list.add(ch);
    }
    return list.stream();
}

/**
 * 排序
 * sorted()-自然排序(Comparable)
 * sorted(Comparator com)-定制排序(Comparator)
 */
@Test
public void test4(){
    List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
    list.stream()
            .sorted()
            .forEach(System.out::println);

    System.out.println("------------------------------");

    emp1oyees.stream()
            .sorted((e1, e2) -> {
                if (e1.getAge() == e2.getAge()){
                    return e1.getName().compareTo(e2.getName());
                }else {
                    return e1.getAge()-e2.getAge(); //升序
                }
            }).forEach(System.out::println);
}

终止操作

/**
 * 查找与匹配
 * allMatch-检查是否匹配所有元素
 * anyMatch-检查是否至少匹配一个元素
 * noneMatch-检查是否没有匹配所有元素
 * findFirst-返回第一个元素
 * findAny-返回当前流中的任意元素
 * count-返回流中元素的总个数
 * max-返回流中最大值
 * min-返回流中最小值
 */
@Test
public void test5(){
    //allMatch-检查是否匹配所有元素
    boolean allMatch = emp1oyees.stream()
            .allMatch(e -> e.getAge() > 11);
    System.out.println(allMatch);

    //anyMatch-检查是否至少匹配一个元素
    boolean anyMatch = emp1oyees.stream()
            .anyMatch(e -> e.getAge() > 25);
    System.out.println(anyMatch);

    //noneMatch-检查是否 全部不匹配
    boolean noneMatch = emp1oyees.stream()
            .noneMatch(e -> e.getAge() > 59);
    System.out.println(noneMatch);

    //findFirst-返回第一个元素
    Optional<Employee> first = emp1oyees.stream()
            .sorted((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()))
            .findFirst();
    System.out.println(first.get());

    //findAny-返回当前流中的任意元素
    Optional<Employee> any = emp1oyees.stream()
            .filter(employee -> employee.getAge() > 25)
            .findAny();
    System.out.println(any.get());

    //count-返回流中元素的总个数
    long count = emp1oyees.stream()
            .count();
    System.out.println(count);

    //max-返回流中最大值
    Optional<Employee> max = emp1oyees.stream()
            .max((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
    System.out.println(max.get());

    //min-返回流中最小值
    Optional<Integer> min = emp1oyees.stream()
            .map(Employee::getAge)
            .min(Integer::compareTo);
    System.out.println(min.get());
}

/**
 * 归约
 * reduce(T identity, BinaryOperator) / reduce(BinaryOperator) - 可以将流中元素反复结合起来，得到一个值。
 */
@Test
public void test6(){
    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    Integer reduce1 = list.stream()
            //0+1+2+3...
            .reduce(0, (x, y) -> x + y);
    System.out.println(reduce1);

    System.out.println("------------------------------");

    Optional<Integer> reduce2 = emp1oyees.stream()
            .map(Employee::getAge)
            //年龄总和
            .reduce(Integer::sum);
    System.out.println(reduce2.get());
}

 /**
 * 收集
 * collect-将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
 */
@Test
public void test7(){
    List<String> list = emp1oyees.stream()
            .map(Employee::getName)
            .collect(Collectors.toList());
    list.forEach(System.out::println);

    System.out.println("------------------------------");

    Set<String> set = emp1oyees.stream()
            .map(Employee::getName)
            .collect(Collectors.toSet());
    set.forEach(System.out::println);

    System.out.println("------------------------------");

    HashSet<String> hashSet = emp1oyees.stream()
            .map(Employee::getName)
            .collect(Collectors.toCollection(HashSet::new));
    hashSet.forEach(System.out::println);

    System.out.println("------------------------------");

    //总数
    Long collect = emp1oyees.stream()
            .collect(Collectors.counting());
    System.out.println(collect);

    System.out.println("------------------------------");

    //平均值
    Double avg = emp1oyees.stream()
            .collect(Collectors.averagingInt(Employee::getAge));
    System.out.println(avg);

    System.out.println("------------------------------");

    //总和
    Integer sum = emp1oyees.stream()
            .collect(Collectors.summingInt(Employee::getAge));
    System.out.println(sum);

    System.out.println("------------------------------");

    //最大值
    Optional<Employee> max = emp1oyees.stream()
            .collect(Collectors.maxBy((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge())));
    System.out.println(max.get());

    System.out.println("------------------------------");

    //最小值
    Optional<Integer> min = emp1oyees.stream()
            .map(Employee::getAge)
            .collect(Collectors.minBy(Integer::compareTo));
    System.out.println(min.get());

    System.out.println("------------------------------");

    //分组
    Map<String, List<Employee>> listMap = emp1oyees.stream()
            .collect(Collectors.groupingBy(Employee::getName));
    System.out.println(listMap);

    System.out.println("------------------------------");

    //多级分组(先根据名字分，在跟根据年龄段分)
    Map<String, Map<String, List<Employee>>> mapMap = emp1oyees.stream()
            .collect(Collectors.groupingBy(Employee::getName, Collectors.groupingBy(e -> {
                if (e.getAge() <= 35) {
                    return "青年";
                } else if (e.getAge() <= 50) {
                    return "中年";
                } else {
                    return "老年";
                }
            })));
    System.out.println(mapMap);

    System.out.println("------------------------------");

    //分区(满足条件一个区，不满足一个区)
    Map<Boolean, List<Employee>> booleanListMap = emp1oyees.stream()
            .collect(Collectors.partitioningBy(e -> e.getAge() > 30));
    System.out.println(booleanListMap);

    System.out.println("------------------------------");

    IntSummaryStatistics statistics = emp1oyees.stream()
            .collect(Collectors.summarizingInt(Employee::getAge));
    System.out.println(statistics.getMax());
    System.out.println(statistics.getAverage());
    System.out.println(statistics.getCount());
    System.out.println(statistics.getMin());
    System.out.println(statistics.getSum());

    System.out.println("------------------------------");

    //连接字符串 三个参数(分隔符，开头，结尾)
    String str = emp1oyees.stream()
            .map(Employee::getName)
            .collect(Collectors.joining(",", "==", "=="));
    System.out.println(str);
}

备注: map和reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名。
Collector接口中方法的实现决定了如何对流执行收集操作(如收集到List、 Set、Map)。 但是Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。

Optional类

Optional类(java.util.Optional)是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在Optional 可以更好的表达这个概念。并且可以避免空指针异常。

常用方法:
Optional.of(T t) :创建一个Optional实例
Optional.empty() :创建一个空的Optional 实例
Optional.ofNullable(T t):若t不为null, 创建Optional实例，否则创建空实例
isPresent() :判断是否包含值
orElse(T t) :如果调用对象包含值，返回该值，否则返回t
orElseGet (Supplier s) :如果调用对象包含值，返回该值，否则返回s获取的值
map(Function f):如果有值对其处理，并返回处理后的0ptional，否则返回Optional.empty()
flatMap (Function mapper):与map类似，要求返回值必须是Optional

接口中的默认方法

接口默认方法的”类优先”原则
若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时

• 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
• 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法(不管方法是否是默认方法)，那么必须覆盖该方法来解决冲突