java8新特性
java8发布修改了很多的，比如HashMap、ConcurrentHashMap的实现都有了修改；ConcurrentHashMap在JDK8的实现已经抛弃了Segment分段锁机制，利用CAS+Synchronized来保证并发更新的安全，底层依然采用数组+链表+红黑树的存储结构。
说一下java8的有点有哪些：
1 速度更快
2 代码更少（增加了新的语法 Lambda 表达式）
3 强大的 Stream API
4 便于并行
5 最大化减少空指针异常 Optional
下面我们就来说有哪些变化：
1、lamada
2、stream
3、新时间日期 API
4、其他新特性
详情如下：
Lamada：
为什么使用 Lambda 表达式？
Lambda 是一个匿名函数，我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
什么是函数式接口？
只包含一个抽象方法的接口，称为函数式接口。
你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
一、Lambda 表达式的基础语法：
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);
上联：左右遇一括号省
下联：左侧推断类型省
横批：能省则省
二、Lambda 表达式需要“函数式接口”的支持
函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。 可以使用注解 @FunctionalInterface 修饰
可以检查是否是函数式接口
三、Java8 内置的四大核心函数式接口
Consumer<T> : 消费型接口
void accept(T t);
Supplier<T> : 供给型接口
T get();
Function<T, R> : 函数型接口
R apply(T t);
Predicate<T> : 断言型接口
boolean test(T t);
四、引用
当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！ ）
方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。
如下三种主要使用情况：
一、方法引用：若 Lambda 体中的功能，已经有方法提供了实现，可以使用方法引用（可以将方法引用理解为 Lambda 表达式的另外一种表现形式）
1. 对象的引用 :: 实例方法名
2. 类名 :: 静态方法名
Comparator<Integer> com=(x,y)->Integer.compare(x, y);
int compare = com.compare(10, 20);
System.out.println(compare);
Comparator<Integer> com1=Integer::compare;
int i = com1.compare(20, 23);
System.out.println(i);
3. 类名 :: 实例方法名
Function<Employee, String> fun=Employee::getName;//这个地方需要注意，并不要()
String string = fun.apply(new Employee("wangbin"));
System.out.println(string);
Function<Employee,String> fun1=x->x.getName();
String str2 = fun1.apply(new Employee("wangbin"));
System.out.println(str2);
注意：
①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！
②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName
二、构造器引用 :构造器的参数列表，需要与函数式接口中参数列表保持一致！
与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！
1. 类名 :: new
Function<String, Employee> fun=(x)->new Employee(x);
Employee employee = fun.apply("wangbin");
System.out.println(employee);
//这是构造器的引用
Function<String ,Employee> fun1=Employee::new;
Employee employee2 = fun1.apply("wangtianyan");
System.out.println(employee2);
三、数组引用
类型[] :: new;
Function<Integer,String[]> fun2=String[]::new;
String[] strings = fun2.apply(10);
System.out.println(strings.length);
Function<Integer,String[]> fun4=x->new String[x];
String[] str = fun4.apply(20);
System.out.println(str.length);
stream：
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
什么是 Stream
流(Stream) 到底是什么呢？
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
“集合讲的是数据，流讲的是计算！ ”
注意：
①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
Stream 的操作三个步骤
创建 Stream
一个数据源（如： 集合、数组）， 获取一个流
中间操作
一个中间操作链，对数据源的数据进行处理
终止操作(终端操作)
一个终止操作，执行中间操作链，并产生结果
创建 Stream
Java8 中的 Collection 接口被扩展，提供了
两个获取流的方法：
default Stream<E> stream() : 返回一个顺序流
default Stream<E> parallelStream() : 返回一个并行流
由数组创建流
Java8 中的 Arrays 的静态方法 stream() 可
以获取数组流：
static <T> Stream<T> stream(T[] array): 返回一个流
重载形式，能够处理对应基本类型的数组：
1、public static IntStream stream(int[] array)
2、public static LongStream stream(long[] array)
3、public static DoubleStream stream(double[] array)
由值创建流
可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。
1、public static<T> Stream<T> of(T... values) : 返回一个流
由函数创建流：创建无限流
可以使用静态方法 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) :
下面是所有创建流的方式：
//下面是通过Collection集合来创建流
List<String> list=new ArrayList<>();
//这是创建一个流
Stream<String> stream = list.stream();
//这是创建并行流
Stream<String> parallelStream = list.parallelStream();
//用数组来创建流
Integer[] u=new Integer[10];
Stream<Integer> stream2 = Arrays.stream(u);
//使用Stream的of方法来创建流
Stream<String> of = Stream.of("12");
//创建无限流
Stream.iterate(0, (x)->x+2).limit(10).forEach(System.out::println);
Stream.generate(Math::random).limit(10).forEach(System.out::println);
Stream 的中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值” 。
筛选与切片：
filter——接收 Lambda ， 从流中排除某些元素。
limit——截断流，使其元素不超过给定数量。
skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
distinct——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
映射：
map——接收 Lambda ， 将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
排序：
Stream的终止操作
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如： List、 Integer，甚至是 void 。
查找与匹配
allMatch——检查是否匹配所有元素
anyMatch——检查是否至少匹配一个元素
noneMatch——检查是否没有匹配的元素
findFirst——返回第一个元素
findAny——返回当前流中的任意元素
count——返回流中元素的总个数
max——返回流中最大值
min——返回流中最小值
归约
/**
* 归约
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);
Optional<Integer> reduce = list.stream().reduce((x,y)->{return x+y;});
System.out.println(reduce);
Optional<Double> reduce2 = emps.stream().map(Employee::getSalary).reduce((x,y)->{return x+y;});
System.out.println(reduce2);
Double reduce3 = emps.stream().map(Employee::getSalary)
.reduce(0.0, Double::sum);
System.out.println(reduce3);
}
收集
Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、 Set、 Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例， 具体方法与实例如下表：
并行流与串行流
并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。
下面是一些例子：
|
List<Employee> emps = Arrays.asList(
new Employee(101, "张三", 18, 9999.99),
new Employee(102, "李四", 59, 6666.66),
new Employee(103, "王五", 28, 3333.33),
new Employee(104, "赵六", 8, 7777.77),
new Employee(105, "田七", 38, 5555.55)
);
@Test
public void test3(){
emps.stream().filter((m)->m.getAge()>50).forEach(System.out::println);
emps.stream().map(Employee::getName).forEach(System.out::println);
emps.stream()
.filter((m)->m.getSalary()>5000)
.limit(2)
.forEach(System.out::println);
}
|
|
|
结果：
Employee [id=102, name=李四, age=59, salary=6666.66]
张三
李四
王五
赵六
田七
Employee [id=101, name=张三, age=18, salary=9999.99]
Employee [id=102, name=李四, age=59, salary=6666.66]
|
新时间日期 API ：
5-新时间日期 API
使用 LocalDate、 LocalTime、 LocalDateTime
LocalDateTime是LocalDate和LocalTime的集合体，
2018-07-13T17:03:55.663(LocalDateTime now = LocalDateTime.now())
LocalTime只有时间：17:01:55.959（LocalTime now = LocalTime.now()）
LocalDate只有日期：2018-07-13（LocalDate now = LocalDate.now()）
LocalDate、 LocalTime、 LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。
Instant 时间戳
用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算。
2018-07-13T09:09:00.180Z(Instant now = Instant.now())
Instant now = Instant.now();
//下面是带偏移量8小时
OffsetDateTime atOffset = now.atOffset(ZoneOffset.ofHours(8));
System.out.println(now);
System.out.println(atOffset);
//now.getNano()这个是转化为秒
System.out.println(now.toEpochMilli());
Instant milli = Instant.ofEpochMilli(10);
System.out.println(milli);
打印的结果：
2018-07-13T09:39:01.064Z
2018-07-13T17:39:01.064+08:00
1531474741064
1970-01-01T00:00:00.010Z
Duration 和 Period
Duration:用于计算两个“时间”间隔
LocalTime t1=LocalTime.now();
LocalTime of = LocalTime.of(23, 0, 0);
System.out.println(Duration.between(t1, of).getSeconds());
LocalDateTime start = LocalDateTime.now();
LocalDateTime of2 = LocalDateTime.of(2018, 7, 13, 23, 23,0);
System.out.println(Duration.between(start, of2).getSeconds());
Period:用于计算两个“日期”间隔
LocalDate start=LocalDate.now();
Thread.sleep(100);
LocalDate end=LocalDate.of(2018, 7, 30);
System.out.println(Period.between(start, end).getDays());
日期的操纵
TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。
TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。
例如获取下个周日：
解析与格式化
java.time.format.DateTimeFormatter 类：该类提供了三种
格式化方法：
预定义的标准格式
语言环境相关的格式
自定义的格式
LocalDateTime now = LocalDateTime.now();
DateTimeFormatter date=DateTimeFormatter.ofPattern("yyyy年MM月dd HH-mm-ss");
、、这是日期格式化：2018-07-13T17:23:48.638-》2018年07月13 17-23-48
String format = now.format(date);
System.out.println(format);
System.out.println(now);
、、这是日期转化回来：2018年07月13 17-23-48-》2018-07-13T17:23:48
LocalDateTime parse = LocalDateTime.parse(format, date);
System.out.println(parse);
下面是打印的结果：
2018年07月13 17-23-48
2018-07-13T17:23:48.638
2018-07-13T17:23:48
时区的处理
Java8 中加入了对时区的支持，带时区的时间为分别为：
ZonedDate、 ZonedTime、 ZonedDateTime、ZoneId
获得所有的时区：
Set<String> set = ZoneId.getAvailableZoneIds();
set.forEach(System.out::println);
其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式例如 ： Asia/Shanghai 等
ZoneId：该类中包含了所有的时区信息
getAvailableZoneIds() : 可以获取所有时区时区信息
of(id) : 用指定的时区信息获取 ZoneId 对象
与传统日期处理的转换
其他新特性：
1、接口的改变：
Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default 关键字修饰。
接口中的默认方法
接口默认方法的” 类优先” 原则若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时
1、选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
2、接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法）， 那么必须覆盖该方法来解决冲突。
2、注解
重复注解与类型注解
Java 8对注解处理提供了两点改进：可重复的注解及可用于类型的注解。
下面是定义重复注解的实例：
@Repeatable(MyAnnocations.class)
@Target({ TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE })
@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnocation {
String value() default "jrj";
}
@Target({ TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE })
@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnocations {
MyAnnocation[] value();
}
@Repeatable这个注解一定要添加的
3、Optional 容器类
Optional<T> 类(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): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
flatMap(Function mapper):与 map 类似，要求返回值必须Optional
也可以参考：https://segmentfault.com/a/1190000006985405