Java8特性整理

1. Lambda表达式

可以简化代码，如果某个接口中只一个方法或使用注解`@FuncationInterface`标识可以使用lambda表达式来进行实例化.其格式如下：

()->{}

():可以理解为方法参数列表，多个使用逗号相隔，不需要定义类型   

->:固定写法   

{}:可以理解为方法体，具体执行的语句 

Runnable runnable = ()->{
System.out.println("lambda");
};
//如果{}中只有一条语句时，可以省略{}

2.forEach

其接收一个`Consumer`接口对象

List<Integer> list = new ArrayList();
for(int i=0; i<10; i++){
list.add(i);
}
list.forEach(new Consumer<Integer>(){
Systemc.out.print("forEach anonymous class vaule:"+ele);
});

//使用lambda表达改写
list.forEach((ele)->{
Systemc.out.print("lambda forEach anonymous class vaule:"+ele);
});

3.接口中的默认方法(default)

public interface DefaultInterface {

/**
* 不能使用default来重写Object的方法
*/
default void say(String info){
System.out.println("print say info--->" + info);
}

}

4.新的日期时间API

为什么要使用新的API?

* 分类清晰。类分为：日期类，时间类，日期时间类，时区类等

* 基本操作不需要借助其它类来实现，比如加，减，格式化，解析等

* 新的日期时间类都是安全的。

新日期时间类的包说明：
1）java.time：新的基本日期时间包，包含类有：LocalDate LocalTime, LocalDateTime, Instant(瞬时), Period(期),Duration(持续时间）, ZoneId(时间)等

 2）java.time.chrono：该软件包为非ISO日历系统定义了通用API。我们可以扩展AbstractChronology类来创建我们自己的日历系统。

3）java.time.format：该软件包包含用于格式化和解析日期时间对象的类。大多数时候，我们不会直接使用它们，因为java.time包中的主体类提供了格式化和解析方法。

4）java.time.temporal：查找特定的日期或时间。比如某月第一天或最后一天

 5）java.time.zone：该程序包包含用于支持不同时区及其规则的类。

//常用类与方法
LocalDateTime:日期时间类
LocalDateTime.now()：当前时间,系统默认时区
LocalDateTime.now(ZoneId.of("GMT+2")):当前时间，指定时区
//转换
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); 格式化日期 (LocalDateTime -> String)
LocalDateTime.parse("2019-01-12", DateTimeFormatter):将指定的日期字符串以指定的格式就行转换（String -> LocalDateTime）
LocalDateTime.of(int year, Month month, int dayOfMonth, int hour, int minute):转换为LocalDateTime对象很多重载方法
//获取
LocalDateTime.now().getXXXX():获取日期时间中的某一部分比如获取年则为getYear()获取月则为getMonthValue()则会返回1-12的月份值
//设置
LocalDateTIme.now().withXXX():设置字段的值，比如设置月份LocalDateTime.now().withMonth(1)设置月份为1，其此方法取值范围为1-12
//比较
LocalDateTime.now().isAfter(LocalDateTime):当前时间是否大于传入的时间
LocalDateTime.now().isBefore(LocalDateTime): 当前时间是否小于传入的时间
LocalDateTime.now().isEqual(LocalDateTime):当前时间是否等于传入时间
//基本操作
LocalDateTime.now().plusXXXX(long):对日期时间进行加操作,传入正值则为加传入负值则为减，比如当前日期时间加一个月LocalDateTime.now().plusMonth(1)
LocalDateTime.now().minusXXX(long):对日期时间进行减操作，传入正传则为减传入负值则为加，比如给当前日期时间减去一个月LocalDateTime.now().minusMonth(1)

LocalDate:只操作日期 
LocalDate.now():当前日期
LocalTime:只操作时间
LocalTime.now()：当前时间
//LocalDate,LocalTime相关操作的api与LocalDateTime大致相同

5.Stream API
为什么使用Stream API?

* 配合Lambda表达式代码更简

* 可以延迟实施，过滤，映射，重复删除，从而实现更高的性能和优化

* JavaStream 不存储数据，而是对原数据结构进行操作，并生成可以使用并执行特定的操作数据

* 支持并行处理，提供大型集合的处理性能

注：无法重复使用同一数据流，数据是按需提供

按操作大致可以划分为四类：

//1)流的获取
Stream.of,Stream.generate, Stream.iterator
List.stream()/parallelStream()
//2)流的相互转换
String.chars()
Arrays.stream()
stream.collect(List)：流转换成集合
stream.toArray():流转换成数组
//3)流的中间操作
stream.filter()
stream.map()
stream.sort()
stream.flatMap() : 从列表中的流合并成一个流
//4)流的终端操作
stream.reduce()
stream.count()
stream.forEach()
stream.match()/ anyMatch allMatch noneMatch
stream.findFist()

代码事例-流的创建

Stream<String> strStream = Stream.of("a","b","c");
strStream = Stream.generate(()->return "abc");
strStream = Stream.iterate("abcd", (i)->i);

代码事例-流的转换

IntStream intStream = Arrays.stream(new int[]{1,2,3,4}); //数组转换成流
IntStream stream = "abc".chars(); //字符串转换成流

Stream<Integer> inStream = Stream.of(1,3,2);
List<Integer> list = inStream.collect(Collectors.toList()); //流转换成List集合
Map<Integer, Integer> map = inStrea.collect(Collectors.toMap(i->i, i->i+10); //流转换成Map集合
Integer[] arr = inStream.toArray(Integer[]::new);

代码事例-流的中间操作

List list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
list.add(i);
}
Stream stream = list.stream();

//filter
Stream filterStream = stream.filter(p -> p > 90);
System.out.println("High Nums greater than 90=");
filterStream.forEach(x-> System.out.print(x+" "));

//map
Stream stringStream = Stream.of("abc", "d", "e");
Stream result = stringStream.map(x->{
return x.toUpperCase();
});
result.forEach(x-> System.out.print(x));
System.out.println("=========================>");
//sort
Stream sortStream = Stream.of("b", "d", "aa", "123");
List sortResult = sortStream.sorted().collect(Collectors.toList());
System.out.println(sortResult);
sortStream = Stream.of("b", "d", "aa", "123");
sortResult = sortStream.sorted(Comparator.reverseOrder()).collect(Collectors.toList());
System.out.println(sortResult);
System.out.println("=========================>");

//flatMap
Stream> nameStream = Stream.of(
Arrays.asList("Pankaj "),
Arrays.asList("ZhangSan "),
Arrays.asList("LiSi ", "WangWu ")
);
Stream flatStream = nameStream.flatMap(strList->strList.stream());
flatStream.forEach(System.out::print);

代码事例-流的终端操作

//reduce
Stream integerStream = Stream.of(1,2,3,4,5);
Optional optionalInteger = integerStream.reduce((i, j)->{return i*j;});
if(optionalInteger.isPresent()){
System.out.println("multiplication = " + optionalInteger.get());
}

//count
integerStream = Stream.of(1,2,3,4,5);
System.out.println("Number of elements in stream=" + integerStream.count());

//forEach
integerStream = Stream.of(1,2,3,4,5);
integerStream.forEach(System.out::print);
System.out.println();

//match
integerStream = Stream.of(1,2,3,4,5);
System.out.println("Stream contains 4 ? " + integerStream.anyMatch(x->x==4));
integerStream = Stream.of(1,2,3,4,5);
System.out.println("Stream contains all elements less than 10?" + integerStream.allMatch(x-> x<10));
integerStream = Stream.of(1,2,3,4,5);
System.out.println("Stream doesn't contain 10? " + integerStream.noneMatch(x->x==10));

//findFirst
Stream nameStream = Stream.of("ZhangSan", "LiSi", "WangWu");
Optional result = nameStream.filter(x -> x.startsWith("W")).findFirst();
if(result.isPresent()){
System.out.println("First Name staring with W = " + result.get());
};