• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

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

互联网 diligentman 1个月前 (01-31) 19次浏览

文章目录

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

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

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对象的操作过程,可通过下面的图进行进一步分析。
JDK8 新特性分析及实践(二)---方法、流式操作、新日期
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.Datejava.util.CalendarSimpleDateFormat都一直没有很好解决这个问题。故此,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对象每个线程一份;


喜欢 (0)