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

妖狐艹你老母 2022-10-24 13:19 17阅读 0赞

### 文章目录 ###

*   *  一、方法(MethodReference)引用
     *   *  1.1 概述
         *  1.2 应用场景
         *  1.3 快速入门分析
         *  1.4 应用案例增强分析
         *   *  1.4.1 构造器方法引用
             *  1.4.2 类静态方法引用
             *  1.4.3 类实例方法引用
             *  1.4.4 对象实例方法引用
     *  二、Stream 式操作应用
     *   *  2.1 概述
         *  2.2 应用场景
         *  2.3 快速入门分析
         *  2.4 应用案例增强分析
         *   *  2.4.1 Stream对象创建
             *  2.4.2 Stream中间操作
             *  2.4.3 Stream终止操作
         *  2.5 Stream练习
     *  三、新日期对象应用
     *   *  3.1 概述
         *  3.2 应用场景分析
         *  3.3 快速入门分析
         *   *  3.3.1 常用API应用分析:
             *  3.3.2 Instant 基本应用
         *  3.4 应用案例增强分析

## 一、方法(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);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]

#### 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对象的操作过程，可通过下面的图进行进一步分析。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 1]  
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);

完整案例代码：

package com.cy.java8.stream;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.UUID;
    import java.util.stream.IntStream;
    import java.util.stream.Stream;
    
    public class TestStream02 { 
    	public static void main(String[] args) { 
    		List<Integer> list = Arrays.asList(10,20,30);
    		//创建流对象
    		//1、方式1:
    // list.stream().forEach(t->System.out.println(t));//10 20 30
    		//顺序流
    // list.stream().forEach(System.out::println);//10 20 30
    		//并行流
    		list.parallelStream().forEach(System.out::println);//20 30 10 
    		
    		//2、方式2:
    		IntStream is = Arrays.stream(new int[] { 1,2,3,4});
    		is.forEach(System.out::println);
    		
    		//3、方式3:
    		Stream.of(4,5,6).forEach(System.out::println);
    // Stream.iterate(2, t -> t+2).forEach(System.out::println);//无限操作，不断叠加
    // Stream.generate(()->Math.random()).forEach(System.out::println);
    		Stream.generate(()->UUID.randomUUID().toString()).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);

完整案例展示：

package com.cy.java8.stream;
    
    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.List;
    
    public class TestStream03 { 
    	public static void main(String[] args) { 
    		List<Integer> list = Arrays.asList(10,20,31,30,21,30);
    		list.stream()	//创建流
    			.filter(t->t%2==0)	//中间操作
    			.forEach(System.out::println);	//终止操作
    		System.out.println("=============");
    		list.stream()	//创建流
    			.filter(s->s%2==0)	//中间操作
    			.limit(2)	//限定操作，前两条
    			.forEach(System.out::println);	//终止操作
    		System.out.println("=============");
    		list.stream()	//创建流
    		.filter(s->s%2==0)	//中间操作
    		.skip(1)	//跳过操作，跳过几个
    		.limit(2)	//限定操作，前两条
    		.distinct()	//去重操作
    		.forEach(System.out::println);	//终止操作
    		
    		System.out.println("*************");
    // list.stream().sorted().forEach(System.out::println);
    		//排序操作
    		list.stream().sorted((o1,o2)->o1-o2).forEach(System.out::println);
    		
    		//映射操作
    		List<String> listStr = Arrays.asList("a","bc","def","cD","bc");
    		//map映射
    		listStr.stream().map((t)->t.toUpperCase()).forEach(System.out::println);//转换成大写
    		listStr.stream().map(t->t.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);

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

package com.cy.java8.stream;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class TestStream07 { 
    	/** * 顺序流和并行流的应用 */
    	public static void main(String[] args) { 
    		List<Integer> list = Arrays.asList(10,20,30,40,50,60);
    		
    		//顺序流应用
    // list.stream().forEach(n->{ 
    // //输出线程名
    // System.out.println(Thread.currentThread().getName() + "->" +n);
    // });
    		
    		//并行流应用(多处理器或多核处理器下有一定优势)
    		list.parallelStream().forEach(n->{ 
    			//输出线程名
    			System.out.println(Thread.currentThread().getName() + "->" +n);
    		});
    	}
    }

## 三、新日期对象应用 ##

### 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对象每个线程一份;

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]: /images/20221024/f82dec84851e455288ba3bf077a3b00e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 1]: /images/20221024/9541c3504bab46a4998583d102f1f8ef.png