java8的特性你学废了吗

java8已经出来了n久了，竟然还有那么多人对java8的这些新功能还是停留在了解的阶段，这么多的提升效率的功能特性，你值得拥有！！！

1. Lambda 表达式

• Lambda 是一个匿名函数，我们可以把Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
• Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分：

1. 左侧：指定了 Lambda 表达式需要的所有参数
2. 右侧：指定了 Lambda 体，即 Lambda 表达式要执行
   的功能。
   eg1:

        //匿名内部类
        Runnable r1 = new Runnable(){
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        };

        // lambda 表达式
        Runnable r2 = () -> System.out.println("lambda表达式");

eg2:

        //原来使用匿名内部类作为参数传递
        TreeSet treeSet1 = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(),o2.length());
            }
        });

        // Lambda 表达式作为参数传递
        TreeSet<String> treeSet2 = new TreeSet<>(
                (o1,o2) -> Integer.compare(o1.length(),o2.length())
        );

1.1 无参，无返回值

Lambda 体只需一条语句,eg:

Runnable r2 = () -> System.out.println("lambda表达式");

1.2 只需要一个参数，无返回值

Consumer<String> c = (args) -> System.out.println(args);
//括号可以省略
Consumer<String> c = args -> System.out.println(args);

1.3 需要有两个参数，有返回值

TreeSet<String> treeSet2 = new TreeSet<>(
                (o1,o2) -> {
                	// 可以有其他的逻辑
					return Integer.compare(o1.length(),o2.length());
				}
        );

// 当只有一句的逻辑可以省略大括号和return
TreeSet<String> treeSet2 = new TreeSet<>(
                (o1,o2) -> Integer.compare(o1.length(),o2.length())
        );

// 参数数据类型一般是可以省略的（下面是加上参数类型的写法），编译器编译的时候可以进行类型推断
        TreeSet<String> treeSet2 = new TreeSet<>(
                (String o1,String o2) -> Integer.compare(o1.length(),o2.length())
        );

Lambda并不是java独有的语法，相反有些语言早已经有这些语法，例如scala语言就对这种语法支持更友好（scala也是一个跑在jvm上的语言）

2. 函数式接口

• 只包含一个抽象方法的接口，称为函数式接口。
• 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
• 我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
  注：简单的来说函数式接口就是要应用到Lambda表达式上，这个接口只能有一个抽象方法。

2.1 自定义函数式接口

//加上这个注解，编译器就会检查这个接口是否符合函数式接口
@FunctionalInterface
public interface MyNumber {
	// 只能有一个抽象方法
    public double getValue();
}

2.2 函数式接口中使用泛型

@FunctionalInterface
public interface MyFunction<T> {
    public T getValue(T t);
}

2.3 函数式接口作为参数使用

参数中使用函数式接口

    public String toUpperString(MyFunction<String> mf , String str){
        return mf.getValue(str);
    }

调用带有函数式接口的方法（上面lambda的使用方式相同）

String upperString = toUpperString((str) -> str.toUpperCase(), "hdhusd");

3. Stream API

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。（对于有过scala语言的经验，或者使用过spark或者flink的就很舒服，可以说是无缝衔接了，可以类比下）

3.1 stream三步走

1. 创建Stream
   一个数据源（如：集合，数组），获取一个流
2. 中间操作
   一个中间操作链，对数据进行处理，这个操作是惰性的，不对直接触发真正的操作
3. 终止操作
   一个终止操作，执行中间操作链，并产生结果，这个操作才能触发中间的具体操作（套用spark里面的概念就是这个是action操作，这个才真正去执行动作）
   

3.2 创建stream

3.2.1 通过集合创建stream

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法:

default Stream<E> stream() : 返回一个顺序流
default Stream<E> parallelStream() : 返回一个并行流

3.2.2 通过数组创建stream

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

static <T> Stream<T> stream(T[] array): 返回一个流

3.2.3 由值创建stream

可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。

public static<T> Stream<T> of(T... values) : 返回一个流

3.2.4 通过函数创建无限流

可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。

// 迭代
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) 
// 生成
public static<T> Stream<T> generate(Supplier<T> s) :

3.3 stream的中间操作

3.3.1 筛选相关

方 法	描 述
filter(Predicate p)	接收 Lambda ， 从流中排除某些元素。
distinct()	筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定数量。
skip(long n)	跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补

3.3.2 映射

方 法	描 述
map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。
mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

3.3.3 排序

方 法	描 述
sorted()	产生一个新流，其中按自然顺序排序
sorted(Comparator comp)	产生一个新流，其中按比较器顺序排序

3.4 Stream 的终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

3.4.1 查找与匹配

方 法	描 述
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配所有元素
findFirst()	返回第一个元素
findAny()	返回当前流中的任意元素
count()	返回流中元素总数
max(Comparator c)	返回流中最大值
min(Comparator c)	返回流中最小值
forEach(Consumer c)	内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)

eg:使用流进行一个单词统计

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("hello tom");
        list.add("hello java");
        list.add("how are you");
        list.add("you are so nice");
        //先把集合转换为流，然后再对流进行操作，最后一个一定要是一个action操作
        Map<String, Long> ws = list.parallelStream()
                .flatMap(line -> Arrays.stream(line.split(" ")))
                .collect(Collectors.groupingBy(w -> w, Collectors.counting()));
        System.out.println(ws);
    }

3.4.2 规约

方 法	描 述
reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 T
reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回Optional

3.4.3 收集操作

方 法	描 述
collect(Collector c)	将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

方法	返回类型	作用
toList	List	把流中元素收集到List
-	示例	List emps= list.stream().collect(Collectors.toList());
toSet	Set	把流中元素收集到Set
-	示例	Set emps= list.stream().collect(Collectors.toSet());
toCollection	Collection	把流中元素收集到创建的集合
	-	Collectionemps=list.stream().collect(Collectors.toCollection(ArrayList::new));
counting	Long	计算流中元素的个数
		long count = list.stream().collect(Collectors.counting());
summingInt	Integer	对流中元素的整数属性求和
		inttotal=list.stream().collect(Collectors.summingInt(Employee::getSalary));
averagingInt	Double	计算流中元素Integer属性的平均值
		doubleavg=list.stream().collect(Collectors.averagingInt(Employee::getSalary));
summarizingInt	IntSummaryStatistics	收集流中Integer属性的统计值。
		如：平均值IntSummaryStatisticsiss=list.stream().collect(Collectors.summarizingInt(Employee::getSalary));
joining	String	连接流中每个字符串
maxBy	Optional	根据比较器选择最大值
minBy	Optional	根据比较器选择最小值
collectingAndThen		转换函数返回的类型 包裹另一个收集器，对其结果转换函数
groupingBy	Map<K, List>	根据某属性值对流分组，属性为K，结果为V
partitioningBy	Map<Boolean, List>	根据true或false进行分区

3.5 并行流与串行流的区别

• 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
• Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。

4. 接口中的默认方法与静态方法

4.1 接口中的默认方法

• Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default 关键字修饰。

public interface TestDefault   {
    void test();
    default  String getUpperCase(String str){
        return str.toUpperCase();
    }
}

4.2 类优先原则

• 若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时：

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

4.3 接口中的静态方法

Java8 中，接口中允许添加静态方法。

public interface Test {
    void test();
    // 接口中的默认方法
    default  String getUpperCase(String str){
        return str.toUpperCase();
    }

    //接口中的静态方法
    static String getLower(String str){
       return str.toLowerCase();
    }
}

5. 其它

5.1 Optional类

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

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

5.2 HashMap的调整

由原来的数组加链表的形式改成了数组加红黑数的形式实现（后面可能会单独的写下）

5.3 还有什么是关心的

还有其他的关注的没聊到的可以留言哦，看到会加上的。

本文由·小韩童鞋·出品

更多文章请访问韩利鹏的博客