JDK8 新特性分析及实践(二)—方法、流式操作、新日期

一、方法(MethodReference)引用

1.1 概述

方法引用是用来直接引用类方法、实例方法或者构造方法的一种新的方式。这里要特别强调一点的是“方法引用”提供的是一种对方法的引用而不是执行方法的方式，简单点理解的话就是可以将方法作为参数进行传递，我们还可以将方法引用理解为lambda的一种深层表达。

1.2 应用场景

方法引用是一种更简洁易懂的Lambda表达式，操作符是双冒号"::"，也可以将方法引用看成是一个更加紧凑，易读的Lambda表达式。

1.3 快速入门分析

定义一个list集合，然后基于Lambda表达式迭代集合中的内容进行输出，关键代码如下：

List<String> list = Arrays.asList("a","b","c");

list.forEach(str -> System.out.println(str));

基于方法引用的方式，输出list集合中的具体内容的，然后与传统Lambda表达式方式，进行对比分析，关键代码如下：

list.forEach(System.out::println);

说明：当你要访问的接口方法与执行的方法引用参数相同，返回值也相同即可直接使用方法引用。

案例展示：

package com.cy.java8.methodref;

import java.io.PrintStream;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class TestObjectInstanceMethodRef01 {
	public static void main(String[] args) {
		List<String> list = Arrays.asList("A","B","C","D");
		//传统方式的写法
		list.forEach(new Consumer<String>() {
			@Override
			public void accept(String t) {//消费型接口，没有返回值
				// TODO Auto-generated method stub
				System.out.println(t);
			}
		});
		
		//lambda表达式的方式
		System.out.println("=========lambda表达式的方式=========");
		list.forEach(t -> System.out.println(t));
		
		//对象实例方法引用方式
		System.out.println("=========方法引用方式=========");
		PrintStream ps = System.out;
		list.forEach(ps::println);
		
		list.forEach(System.out::println);
	}
}

1.4 应用案例增强分析

JDK8方法的引用可分为如下几类：

1.4.1 构造器方法引用

格式：ClassName::new，应用默认构造函数。

package com.cy.java8.methodref;
import java.util.function.Supplier;
public class TestConstructorMethodRef01 {
	public static void main(String[] args) {
	    //1.传统方式
	    Supplier<Object> s1=new Supplier<Object>() {
			@Override
			public Object get() {
				return new Object();
			}
	    };
	    System.out.println(s1.get());
	    //2.Lambda方式
	    Supplier<Object> s2=()->new Object();
	    System.out.println(s2.get());
	    
	    //3.构造方法引用"类名::new"
	    Supplier<Object> obj=Object::new;
	    System.out.println(obj.get());
		
		Supplier<Object> supplier4 = Date::new;
		System.out.println(supplier4.get());
	}
}

1.4.2 类静态方法引用

格式：ClassName::static_method

package com.cy.java8.methodref;
import java.util.function.Function;

public class TestClassMethodRef01 {
	public static void main(String[] args) {
	    //1.传统应用方式
	    Function<String, Integer> f1=new Function<String, Integer>() {
	        @Override
	        public Integer apply(String t) {
		        return Integer.parseInt(t);
	        }
	    };
	    Integer result=f1.apply("100");
	    System.out.println(result);
	    //2.lambda应用方式
	    Function<String, Integer> f2=(t)->Integer.parseInt(t);
	    System.out.println(f2.apply("200"));
	    //3.类方法引用应用方式"类名::方法名"
	    Function<String,Integer> f3=Integer::parseInt;
	    System.out.println(f3.apply("300"));
	}
}

练习：比较两个整数大小（附答案）

Comparator<Integer> com=Integer::compare;
System.out.println(com.compare(39, 20));

package com.cy.java8.methodref;

import java.util.Comparator;

/**
 * 类方法::练习
 * @author lixin
 */
public class TestClassMethodRef02 {
	public static void main(String[] args) {
		//1.传统方式
		Comparator<Integer> c1 = new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return Integer.compare(o1, o2);
			}
		};
		
		//2.lambda表达式方式
		Comparator<Integer> c2 = (o1,o2) -> Integer.compare(o1, o2);
		
		//3.类方法引用
		Comparator<Integer> c3 = Integer::compare;
		System.out.println(c3.compare(10, 20));//-1
	}
}

1.4.3 类实例方法引用

格式：ClassName::method，方法不能带参数。

package com.cy.java8.methodref;
import java.io.File;
import java.util.function.Function;
public class TestClassInstanceMethodRef01 {
	public static void main(String[] args) {
	    //1.传统方式
	    Function<File,String> f1=new Function<File,String>() {
	        @Override
	        public String apply(File f) {
	        	return f.getAbsolutePath();
	        }
	    };
	    System.out.println(f1.apply(new File("pom.xml")));
	    //2.Lambda方式
	    Function<File,String> f2=file->file.getAbsolutePath();
	    System.out.println(f2.apply(new File("pom.xml")));
	    
	    //3.类实例方法引用"类名::实例方法名"
	    Function<File,String> f3=File::getAbsolutePath;
	    System.out.println(f3.apply(new File("pom.xml")));  
	}
}

练习:（附答案）

Arrays.sort(strArray,(s1,s2)->s1.compareToIgnoreCase(s2));
Arrays.sort(strArray, String::compareToIgnoreCase);

package com.cy.java8.methodref;

import java.util.Arrays;
import java.util.Comparator;

/**
 * 类实例方法引用"类名::实例方法名"练习
 * Arrays.sort()排序的方法
 * @author lixin
 */
public class TestClassInstanceMethodRef02 {
	public static void main(String[] args) {
		//对数组内容进行排序
		String[] strArray = {"b","a","c","abc","abcd","bce"};
		//1.传统方式
		Arrays.sort(strArray,new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.compareToIgnoreCase(o2);
			}
		});
		System.out.println(Arrays.toString(strArray));
		
		//2.lambda表达式写法
		Arrays.sort(strArray,(o1,o2)->o1.compareTo(o2));
		
		//3.类实例方法引用
		Arrays.sort(strArray,String::compareToIgnoreCase);
	}
}

1.4.4 对象实例方法引用

格式：对象实例::method，方法不能带参数。

public class TestObjectInstanceMethodRef01 {
	public static void main(String[] args) {
	    List<String> list=Arrays.asList("A","B","C");
	    //传统方式
	    list.forEach(new Consumer<String>() {
	        @Override
	        public void accept(String t) {
	        	System.out.println(t);
	        }
	    });
	    //Lambda表达式方式
	    list.forEach(t->System.out.println(t));
	    //方法引用方式
	    PrintStream ps=System.out;
	    list.forEach(ps::println);
	    list.forEach(System.out::println);
	}
}

练习:

List<Integer> list=Arrays.asList(10,20);
Supplier<Integer> supplier=(list::size);
System.out.println(supplier.get());

二、Stream 式操作应用

2.1 概述

Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作。

2.2 应用场景

在当今这个数据爆炸的时代，数据来源多样化、数据海量化，很多时候不得不脱离 RDBMS，以底层返回的数据为基础进行更上层的数据统计。而原有 Java 的集合 API 中，仅仅有极少量的辅助型方法，更多的时候是程序员需要用 Iterator 来遍历集合，然后完成相关的聚合应用逻辑。这是一种远不够高效而且相对比较笨拙的方法。在JDK8中使用 Stream 对象，不仅丰富了在业务层面对数据处理的方式，还可以让代码更加简洁、易读和高效。

2.3 快速入门分析

我们在使用Stream对象时，一般会按照如下为三个步骤进行操作：

• 第一步：创建Stream流对象；
• 第二步：Stream流中间操作；
• 第三步：Stream流终止操作；

Stream对象的操作过程，可通过下面的图进行进一步分析。

Steam对象简易应用，代码如下：

package com.cy.java8.stream;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/*
 * 流式操作
 */
public class TestStream01 {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(1,2,3,8,7,4,5,9,23);
		//1.传统写法
		long count = list.stream().filter(new Predicate<Integer>() {
			@Override
			public boolean test(Integer t) {
				// TODO Auto-generated method stub
				return t%2==0;
			}
		}).count();
		System.out.println("传统方式："+count);
		
		//2.lambda表达式写法
		long count2 = list.stream()
						  .filter((t)->t%2==0)
						  .count();
		System.out.println("lambda方式："+count2);
	}
}

2.4 应用案例增强分析

2.4.1 Stream对象创建

Stream对象的创建，常见方式有如下几种：

• 借助Collection接口中的stream()或parallelStream（）方法；
• 借助Arrays类中的stream(…)方法；
• 借助Stream类中的of(…)方法；
• 借助Stream类中的iterator和generator方法（无限操作）

Stream对象创建，案例分析如下：

	Collection<Integer> col=new ArrayList<>();

	...
    Stream<Integer> s1=col.stream();
    Stream<Integer> s2=col.parallelStream();
            
    IntStream s3=Arrays.stream(new int[] {1,2,3,4});
    Stream<Integer> s4=Stream.of(10,20,30,40);
            
    Stream<Integer> s5=Stream.iterate(2, (x)->x+2);
    s5.forEach(System.out::println);
            
    Stream<Double> s6=Stream.generate(()->Math.random());
    s6.forEach(System.out::println);

2.4.2 Stream中间操作

Stream 对象创建以后可以基于业务执行一些中间操作，但这些操作的结果需要借助终止操作进行输出，案例分析如下：

初始条件：给定list集合作为Stream操作的对象，代码如下：

List<Integer> list=Arrays.asList(100,101,102,200);

对数据进行过滤：

//输出集合中所有的偶数
//1.创建流
Stream<Integer> s1=list.stream();
//2.中间操作(过滤)
Stream<Integer> s2=s1.filter((n)->n%2==0);
//3.终止操作
s2.forEach(System.out::println);
//也可以将多个操作合在一起
list.stream().filter(n->n%2==0).forEach(System.out::println);

限定操作(limit)

list.stream().filter(n->n%2==0).limit(2).forEach(System.out::println);

跳过操作(skip)

list.stream().filter(n->n%2==0).skip(2).forEach(System.out::println);

去重操作(distinct)

list.stream().distinct().forEach(System.out::println);

排序操作(sorted)：底层基于内部比较器Comparable或外部Comparator比较器进行比对

list.stream().sorted().forEach(System.out::println);
list.stream().sorted((s1,s2)->{//Comparator
            	return s1-s2;
            }).forEach(System.out::println);

映射操作(map)

List<String> list=Arrays.asList("a","bc","def");
list.stream().map((x)->x.toUpperCase()).forEach(System.out::println);
list.stream().map((x)->x.length()).forEach(System.out::println);

2.4.3 Stream终止操作

Stream终止操作是Stream的结束操作，案例分析如下：
初始条件定义，给定一个list集合：

List<Integer> list=Arrays.asList(10,11,12,13,14,15);

match操作

boolean flag=list.stream().allMatch((x)->x%2==0);
System.out.println(flag);
flag=list.stream().anyMatch((x)->x%2==0);
System.out.println(flag);
flag=list.stream().noneMatch((x)->x>20);
System.out.println(flag);

find操作

Optional<Integer> optional=list.stream().sorted().findFirst();
System.out.println(optional.get());
optional=list.parallelStream().filter((x)->x%2!=0).findAny();
System.out.println(optional.get());

count操作

long count=list.stream().count();
System.out.println(count);

求最大，最小值

optional=list.stream().max((x,y)->{return x-y;});
System.out.println(optional.get());
optional=list.stream().min((x,y)->{return x-y;});
System.out.println(optional.get());

forEach迭代操作

list.stream().forEach(System.out::println);

Reduce(规约)操作

//计算集合中所有元素的和，其中第一个参数0为初始值，然后与后面每个值累加

Integer sum=list.stream().reduce(0,(x,y)->{return x+y;});
System.out.println(sum);

Collector(收集)操作

List<Integer> result=list.stream().map(x->x*2).collect(Collectors.toList());
System.out.println(result);

list.stream().map(x->x*2).collect(Collectors.toSet());
System.out.println(result);

double avg=list.stream().collect(Collectors.averagingDouble(x->x));
System.out.println(avg);

Optional<Integer> max=list.stream().collect(Collectors.maxBy((x,y)->{return x-y;}));
System.out.println(max.get());

Map<Object,List<Integer>> map=list.stream().collect(Collectors.groupingBy(x->x%2==0));
System.out.println(map);

2.5 Stream练习

案例1：计算多个整数的和。

static void doTestReduce01() {
             List<Integer> list = Arrays.asList(1,2,3,4,5,6);
             Optional<Integer> count =
         list.stream().reduce((a, b) -> (a + b));
             System.out.println(count.get()); // 21
    }

案例2：计算多个整数乘机，然后再乘以2。

	static void doTestReduce02() {
	    List<Integer> list = Arrays.asList(1,2,3,4,5,6);
	    Integer count = list.stream().reduce(2, (a, b) -> (a * b));
	    System.out.println(count);  // 1440
	}

案例3：计算多个整数的和，假如超出范围，则对其进行类型转换。.
案例1和2的缺点在于返回的数据都只能和 Stream 流中元素类型一致，但假如求和或乘积之后的数值超过了 Integer 能够表示的范围怎么办？例如，需要使用 Long 类型接收，这就用到了我们下面reduce() 方法的应用形式了。

static void doTestReduce03() {
	List<Integer> list =Arrays.asList(Integer.MAX_VALUE, Integer.MAX_VALUE);
	long count =list.stream().reduce(0L, (a, b) -> (a + b), (a,b) -> 0L);
	System.out.println(count);
}

案例4：获取指定目录下所有目录文件的文件名？

List<String> allDirNames =
	Arrays.stream(new File("d:\")
    	.listFiles())
        .filter(File::isDirectory)
        .map(File::getName)
        .collect(Collectors.toList());
	System.out.println(allDirNames);

案例五：并行流的简易应用。
并行流应用的目的主要借助多核处理器优势，提高的操作性能。

public static void main (String[] args) {
	String[] strings =  {"1", "2", "3", "4", "5"};
	doPrint(Arrays.stream(strings).sequential());
	doPrint(Arrays.stream(strings).parallel());
}
public static void doPrint (Stream<String> stream) {
	stream.forEach(s -> {
		System.out.println(
		Thread.currentThread().getName()+"->"+s);
	});
}

三、新日期对象应用

3.1 概述

在Java8之前，日期和时间的管理一直是令Java开发者很痛苦的一个的问题。java.util.Date、java.util.Calendar，SimpleDateFormat都一直没有很好解决这个问题。故此，Java8引入了一套全新的日期时间处理API，新的API基于ISO标准日历系统，解决了以前日期和时间类的很多弊端问题。

3.2 应用场景分析

Java8中的时间处理API定义在java.time包中，这些API具备不可变且线程安全特性,具备准确和灵活特性。所以现在基本可以使用这组API替换所有原有历史版本中时间API的应用。

3.3 快速入门分析

3.3.1 常用API应用分析:

Instant 时间戳，默认是0时区，比北京少8个时区

3.3.2 Instant 基本应用

//获取瞬时对象(当前时间年月日时分秒),Instant是绝对时间，没有时区的概念
Instant instant1 ==Instant.now();//Clock.systemUTC().instant();
System.out.println(instant1);
//通过这种方式获取的时间戳与北京时间相差8个时区，需要修正为北京时间
instant1=instant1.plusMillis(TimeUnit.HOURS.toMillis(8));;
//输出系统可用时区
System.out.println(ZoneId.getAvailableZoneIds());

//输出系统默认时区
System.out.println(ZoneId.systemDefault());

//输出系统默认时区时间
System.out.println(Instant.now().atZone(ZoneId.systemDefault()));

获取时间间隔

 Instant start = Instant.now();
...
Instant end = Instant.now();
Duration timeElapsed = Duration.between(start, end);
System.out.println("Milliseconds: " + timeElapsed.toMillis());  

LocalDate 日期对象，不包含具体时间

LocalDate ld1=LocalDate.now();
System.out.println(ld1);
LocalDate ld2 = LocalDate.of(2019, Month.JANUARY, 8);
System.out.println(ld2);
LocalDate ld3=LocalDate.parse("2019-12-12");
System.out.println(ld3);

LocalTime 时间对象，不包含日期

LocalTime lt1=LocalTime.now();
System.out.println(lt1);
LocalTime lt2=LocalTime.now(ZoneId.systemDefault());
System.out.println(lt2);
long t=ChronoUnit.HOURS.between(lt1, lt2);
System.out.println(t);

LocalDateTime 包含了日期和时间对象，没有时区信息

LocalDateTime ldt02 =
LocalDateTime.of(2019, Month.DECEMBER, 31, 23, 59, 59);
System.out.println(ldt02);//2019-12-31T23:59:59
                
DayOfWeek dayOfWeek = ldt02.getDayOfWeek();
System.out.println(dayOfWeek);      // WEDNESDAY

ZoneDateTime 包含时区的完整日期时间对象，偏移量以UTC时间为基准

ZonedDateTime zdt01=ZonedDateTime.now();
System.out.println(zdt01);
ZoneId zd01=TimeZone.getDefault().toZoneId();
System.out.println(zd01);

3.4 应用案例增强分析

日期类型转换

LocalDateTime ld4 =LocalDateTime.parse("2019/12/12 12:12:12",
DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"));
System.out.println(ld4);

说明：jdk8之前的日期与字符串之间的转换通常会借助SimpleDateFormat对象，但是此对象线程不安全，通常要借助ThreadLocal对象，保证SimpleDateFormat对象每个线程一份;