JDK8 新特性分析及实践(二)---方法、流式操作、新日期
文章目录
-
- 一、方法(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 未完待续。。。。
一、方法(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);
}
}