Java SE 8 新增特性
作者：Grey
原文地址：
源码
镜像仓库: GitCode：java_new_features
Lambda 表达式
Java 8里面最大的更新莫过于支持Lambda表达式，Oracle官网给了一个很好的示例说明，见：Lambda Expressions，以下来自这个官方示例说明。
假设我们定义一个Person类，属性如下
public class Person {
public static List<Person> createRoster() {
// 获取Person列表
}
public enum Sex {
MALE, FEMALE
}
String name;
LocalDate birthday;
Sex gender;
String emailAddress;
// 省略get/set方法
public void printPerson() {
// 打印Person信息
}
}
如果我们要获取某个年龄段的所有Person信息，我们可能会写出如下代码
// 查询大于age的所有人员信息
public static void printPersonsOlderThan(List<Person> roster, int age) {
for (Person p : roster) {
if (p.getAge() >= age) {
p.printPerson();
}
}
}
// 查询年龄在[low, high)区间内的所有人员信息
public static void printPersonsWithinAgeRange(
List<Person> roster, int low, int high) {
for (Person p : roster) {
if (low <= p.getAge() && p.getAge() < high) {
p.printPerson();
}
}
}
这样写的缺点是扩展性不好，如果有新的规则，我们需要增加多个同样类型的方法。此时，我们可以定义一个Local Class，将规则分离出来，这样一来，规则无论如何变化，主流程的代码是不需要调整的，以上述例子来说明。我们定义如下接口
interface CheckPerson {
boolean test(Person p);
}
用于抽象出规则的接口定义，主流程中，我们把这个接口传入到参数中
public static void printPersons(List<Person> roster, CheckPerson tester) {
for (Person p : roster) {
if (tester.test(p)) {
p.printPerson();
}
}
}
这样我们就做到了规则和主流程分离，比如我们要定义一个规则，只需要实现CheckPerson接口
class CheckPersonEligibleForSelectiveService implements CheckPerson {
public boolean test(Person p) {
return p.gender == Person.Sex.MALE &&
p.getAge() >= 18 &&
p.getAge() <= 25;
}
}
在调用的时候，只需要把这个规则作为参数传入即可
printPersons(roster, new CheckPersonEligibleForSelectiveService());
还可以转换成Anonymous Class的写法
printPersons(roster,new CheckPerson() {
public boolean test(Person p) {
return p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25;
}
}
);
接下来，这种方式就可以转换成Lambda表达式的写法
printPersons(
roster,
(Person p) -> p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25
);
由于CheckPerson这个接口只有一个方法，所以这又是一个函数式接口（Fuctional Interface)，在我们这个例子的场景下，我们可以用Predicate<T>来替换CheckPerson接口。因为Predicate<T>接口就是
interface Predicate<T> {
boolean test(T t);
}
public static void printPersonsWithPredicate(
List<Person> roster, Predicate<Person> tester) {
for (Person p : roster) {
if (tester.test(p)) {
p.printPerson();
}
}
}
这样，我们调用又可以简化成
printPersonsWithPredicate(
roster,
p -> p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25
);
printPersonsWithPredicate重构成如下形式：
public static void printPersonsWithPredicate(
List<Person> roster, Predicate<Person> tester) {
for (Person p : roster) {
if (tester.test(p)) {
p.printPerson();
}
}
}
还可以做进一步的优化，我们可以指定一个不同的动作来执行那些满足条件的Person实例，而不是直接调用printPerson方法。你可以用一个lambda表达式来指定这个动作。这里引入了Consumer接口。
public static void processPersons(
List<Person> roster,
Predicate<Person> tester,
Consumer<Person> block) {
for (Person p : roster) {
if (tester.test(p)) {
block.accept(p);
}
}
}
这样，我们就把打印行为也给分离出来了，主流程调用的代码可以进一步简化成
processPersons(
roster,
p -> p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25,
p -> p.printPerson()
);
经过上述重构和优化，我们可以定义不同条件下的不同行为
例如：
public static void processPersonsWithFunction(
List<Person> roster,
Predicate<Person> tester,
Function<Person, String> mapper,
Consumer<String> block) {
for (Person p : roster) {
if (tester.test(p)) {
String data = mapper.apply(p);
block.accept(data);
}
}
}
再如：
processPersonsWithFunction(
roster,
p -> p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25,
p -> p.getEmailAddress(),
email -> System.out.println(email)
);
可以做进一步的泛化:
public static <X, Y> void processElements(
Iterable<X> source,
Predicate<X> tester,
Function <X, Y> mapper,
Consumer<Y> block) {
for (X p : source) {
if (tester.test(p)) {
Y data = mapper.apply(p);
block.accept(data);
}
}
}
针对的场景就是一个集合，经过某些过滤，取出满足条件的数据，然后把这个数据进行加工，例如：
processElements(
roster,
p -> p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25,
p -> p.getEmailAddress(),
email -> System.out.println(email)
);
最后，使用stream，让整个代码变的简洁优雅
roster
.stream()
.filter(
p -> p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25)
.map(p -> p.getEmailAddress())
.forEach(email -> System.out.println(email));
除了可以使用 lambda 表达式创建匿名方法，我们还可以使用方法引用来替代 lambda 表达式，这样可读性会好一些，例如：
public class Person {
// ...
public static int compareByAge(Person a, Person b) {
return a.birthday.compareTo(b.birthday);
}
// ...
}
按年龄排序，我们既可以这样写：
// 定义比较器
class PersonAgeComparator implements Comparator<Person> {
public int compare(Person a, Person b) {
return a.getBirthday().compareTo(b.getBirthday());
}
}
Arrays.sort(rosterAsArray, new PersonAgeComparator());
也可以使用 lambda 表达式
Arrays.sort(rosterAsArray,
(Person a, Person b) -> {
return a.getBirthday().compareTo(b.getBirthday());
}
);
由于Person类中已经存在一个比较方法，我们可以通过方法引用来替代 lambda 表达式
Arrays.sort(rosterAsArray,
(a, b) -> Person.compareByAge(a, b)
);
这个compareByAge的参数列表和Comparator<Person>.compare方法的参数一致，可以简写成：
Arrays.sort(rosterAsArray, Person::compareByAge);
方法引用有如下几种类型
| 类型 | 语法 | 示例 |
|---|---|---|
| 静态方法 | *ContainingClass*::*staticMethodName* |
Person::compareByAge MethodReferencesExamples::appendStrings |
| 实例方法 | *containingObject*::*instanceMethodName* |
myComparisonProvider::compareByName myApp::appendStrings2 |
| 对一个特定类型的任意对象的实例方法的引用 | *ContainingType*::*methodName* |
String::compareToIgnoreCase String::concat |
| 构造方法 | *ClassName*::new |
HashSet::new |
以下是示例
import java.util.function.BiFunction;
/**
* @since 1.8
*/
public class MethodReferencesExamples {
public static <T> T mergeThings(T a, T b, BiFunction<T, T, T> merger) {
return merger.apply(a, b);
}
public static String appendStrings(String a, String b) {
return a + b;
}
public String appendStrings2(String a, String b) {
return a + b;
}
public static void main(String[] args) {
MethodReferencesExamples myApp = new MethodReferencesExamples();
// 使用 lambda 表达式
System.out.println(MethodReferencesExamples.mergeThings("Hello ", "World!", (a, b) -> a + b));
// 静态方法
System.out.println(MethodReferencesExamples.mergeThings("Hello ", "World!", MethodReferencesExamples::appendStrings));
// 实例方法
System.out.println(MethodReferencesExamples.mergeThings("Hello ", "World!", myApp::appendStrings2));
// 对一个特定类型的任意对象的实例方法的引用
System.out.println(MethodReferencesExamples.mergeThings("Hello ", "World!", String::concat));
}
}
接口支持默认方法和静态方法
直接看示例：
import java.time.*;
public interface TimeClient {
void setTime(int hour, int minute, int second);
void setDate(int day, int month, int year);
void setDateAndTime(int day, int month, int year,
int hour, int minute, int second);
LocalDateTime getLocalDateTime();
}
package defaultmethods;
import java.time.*;
import java.lang.*;
import java.util.*;
public class SimpleTimeClient implements TimeClient {
private LocalDateTime dateAndTime;
public SimpleTimeClient() {
dateAndTime = LocalDateTime.now();
}
public void setTime(int hour, int minute, int second) {
LocalDate currentDate = LocalDate.from(dateAndTime);
LocalTime timeToSet = LocalTime.of(hour, minute, second);
dateAndTime = LocalDateTime.of(currentDate, timeToSet);
}
public void setDate(int day, int month, int year) {
LocalDate dateToSet = LocalDate.of(day, month, year);
LocalTime currentTime = LocalTime.from(dateAndTime);
dateAndTime = LocalDateTime.of(dateToSet, currentTime);
}
public void setDateAndTime(int day, int month, int year,
int hour, int minute, int second) {
LocalDate dateToSet = LocalDate.of(day, month, year);
LocalTime timeToSet = LocalTime.of(hour, minute, second);
dateAndTime = LocalDateTime.of(dateToSet, timeToSet);
}
public LocalDateTime getLocalDateTime() {
return dateAndTime;
}
public String toString() {
return dateAndTime.toString();
}
public static void main(String... args) {
TimeClient myTimeClient = new SimpleTimeClient();
System.out.println(myTimeClient.toString());
}
}
上述代码中，如果要在接口中添加一个方法，那么所有实现这个接口的客户端都要重新实现这个方法，非常麻烦。
public interface TimeClient {
void setTime(int hour, int minute, int second);
void setDate(int day, int month, int year);
void setDateAndTime(int day, int month, int year,
int hour, int minute, int second);
LocalDateTime getLocalDateTime();
// 新增一个方法，所有的子类都要实现这个方法
ZonedDateTime getZonedDateTime(String zoneString);
}
默认方法可以解决这个问题，Java SE 8中接口可以支持默认方法，即：我们可以指定接口的某个方法的默认实现，这样的话，子类就不需要重写这个方法，可以使用接口的默认实现，同时，Java SE 8中，接口也支持静态方法。
package defaultmethods;
import java.time.*;
public interface TimeClient {
void setTime(int hour, int minute, int second);
void setDate(int day, int month, int year);
void setDateAndTime(int day, int month, int year,
int hour, int minute, int second);
LocalDateTime getLocalDateTime();
// 接口也支持静态方法实现
static ZoneId getZoneId (String zoneString) {
try {
return ZoneId.of(zoneString);
} catch (DateTimeException e) {
System.err.println("Invalid time zone: " + zoneString +
"; using default time zone instead.");
return ZoneId.systemDefault();
}
}
// 默认实现，子类无须重写
default ZonedDateTime getZonedDateTime(String zoneString) {
return ZonedDateTime.of(getLocalDateTime(), getZoneId(zoneString));
}
}
通过上述改造，所有子类都具备了接口默认方法的能力，子类可以直接调用接口的默认实现。
package defaultmethods;
import java.time.*;
import java.lang.*;
import java.util.*;
public class TestSimpleTimeClient {
public static void main(String... args) {
// NOTE：SimpleTimeClient无须做任何改动
TimeClient myTimeClient = new SimpleTimeClient();
System.out.println("Current time: " + myTimeClient.toString());
// 调用默认实现
System.out.println("Time in California: " +
myTimeClient.getZonedDateTime("Blah blah").toString());
}
}
当然，默认实现也可以修改，子类重写默认实现就可以了。
此外，接口支持静态方法实现，上述接口中的静态方法，可以直接使用
TimeClient.getZoneId("zoneID");
接口可以支持静态方法这一特性扩展了接口的功能，但是对于实现这个接口的子类没有影响，比如Comparator类中的comparing方法，示例
myDeck.sort(
Comparator
.comparing(Card::getRank)
.thenComparing(Comparator.comparing(Card::getSuit)));
一些增强的 API
新增的包
java.util.function
java.util.stream
调整的包
| 包 | 新增类 | 有调整的类 |
|---|---|---|
java.io |
UncheckedIOException |
BufferedReader |
java.lang |
not applicable | AutoCloseable ThreadLocal String Iterable CharSequence Boolean Integer Long Float Double |
java.nio.file |
not applicable | Files |
java.util |
PrimitiveIterator Spliterator DoubleSummaryStatistics IntSummaryStatistics LongSummaryStatistics Optional OptionalDouble OptionalInt OptionalLong Spliterators SplittableRandom StringJoiner |
Arrays BitSet Collection Comparator Iterator List Map Map.Entry LinkedHashMap Random TreeMap |
java.util.concurrent |
not applicable | ThreadLocalRandom |
java.util.jar |
not applicable | JarFile |
java.util.zip |
not applicable | ZipFile |
java.util.logging |
not applicable | Logger |
java.util.regex |
not applicable | Pattern |
具体可参考：New and Enhanced APIs That Take Advantage of Lambda Expressions and Streams in Java SE 8
List 转 Map
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
// list转map
public class List2Map {
/**
* key name, value number
*/
static void sample1() {
List<Car> list = new ArrayList<>();
list.add(new Car("A", 1));
list.add(new Car("B", 2));
list.add(new Car("C", 3));
// to map,key car name,value ,car number
Map<String, Integer> carMap = list.stream().collect(Collectors.toMap(Car::getName, Car::getNum));
System.out.println(carMap);
}
/**
* key name value object
*/
static void sample2() {
List<Car> list = new ArrayList<>();
list.add(new Car("A", 1));
list.add(new Car("B", 2));
list.add(new Car("C", 3));
Map<String, Car> carMap = list.stream().collect(Collectors.toMap(Car::getName, car -> car));
System.out.println(carMap);
}
/**
* 处理重复数据 包含重复数据的时候，只保留最新的一条
*/
static void sample3() {
List<Car> list = new ArrayList<>(4);
list.add(new Car("A", 1));
list.add(new Car("A", 2));
list.add(new Car("B", 2));
list.add(new Car("C", 3));
Map<String, Integer> carMap = list.stream().collect(Collectors.toMap(Car::getName, Car::getNum, (oldData, newData) -> newData));
System.out.println(carMap);
}
/**
* 重复数据,包含重复数据的时候，只保留最新的一条,并把结果保存到ConcurrentHashMap
*/
static void sample4() {
List<Car> list = new ArrayList<>();
list.add(new Car("A", 1));
list.add(new Car("A", 2));
list.add(new Car("B", 2));
list.add(new Car("C", 3));
Map<String, Integer> carMap = list.stream().collect(Collectors.toMap(Car::getName, Car::getNum, (oldData, newData) -> newData, ConcurrentHashMap::new));
System.out.println(carMap.getClass());
}
}
class Car {
private String name;
private Integer num;
// 省略get/set和构造方法
}
forEach 遍历
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.stream.Stream;
/**
* for each遍历方式
* @since 1.8
*/
public class ForEachTest {
// jdk8之前常规遍历操作
static void normForEach() {
List<String> list = Arrays.asList("a", "b", "c");
for (String item : list) {
System.out.println(item);
}
}
static void newForEach() {
List<String> list = Arrays.asList("a", "b", "c");
list.forEach(System.out::println);
list.forEach(s -> {
System.out.println("新的遍历方式");
System.out.println(s);
});
}
// Map的遍历 jdk1.8之前
static void mapNormForEach() {
Map<Integer, String> map = new HashMap<>(3);
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
for (Map.Entry<Integer, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + ":/t" + entry.getValue());
}
}
//jdk1.8新的Map遍历方法
static void mapNewForEach() {
Map<Integer, String> map = new HashMap<>(3);
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
map.forEach((k, v) -> {
System.out.println(k);
System.out.println(v);
});
}
// jdk1.8新增数组的遍历方法
static void arrayForEach() {
String[] array = {"a", "b", "c"};
Arrays.stream(array).forEach(System.out::println);
}
//不保证有序
static void parallelForEach() {
Stream<String> stream = Stream.of("ab", "bc", "cd");
stream.parallel().forEach(System.out::println);
}
// 可以保证有序
static void parallelForEachOrder() {
Stream<String> stream = Stream.of("ab", "bc", "cd");
stream.parallel().forEachOrdered(System.out::println);
}
// 使用consumer
static void forEachUseConsumer() {
Stream<String> s = Stream.of("ab", "bc");
List<String> l = Arrays.asList("ab", "cd");
Consumer<String> consumer = s1 -> {
System.out.println(s1.toUpperCase());
};
s.forEach(consumer);
l.forEach(consumer);
}
}
Optional
用于优雅判断空和
null。
import java.util.Optional;
/**
* Optional用法
* @since 1.8
*/
public class OptionalTest {
static void handleNull() {
//String s = null;
//Optional<String> s1 = Optional.of(s);
// System.out.println(s1.isPresent());
Optional<String> hello = Optional.of("hello");
Optional<Object> empty = Optional.empty();
Optional<Object> nullObj = Optional.ofNullable(null);
System.out.println(hello.isPresent());
System.out.println(empty.isPresent());
System.out.println(nullObj.isPresent());
}
static void emptyGetException() {
try {
Optional<String> hello = Optional.of("hello");
System.out.println(hello.get());
Optional<Object> empty = Optional.empty();
System.out.println(empty.get());
} catch (Exception e) {
e.printStackTrace();
}
}
static void orElseException() {
try {
Optional<String> emptyOptional = Optional.empty();
String value = emptyOptional.orElseThrow(() -> new Exception("发现空值"));
System.out.println(value);
} catch (Exception e) {
e.printStackTrace();
}
}
static void orElseGet() {
Optional<Object> empty = Optional.empty();
Object o = empty.orElseGet(() -> "default");
System.out.println(o);
Object aDefault = empty.orElse("default");
System.out.println(aDefault);
}
static void funcOptional() {
Optional<Integer> optional123 = Optional.of(123);
optional123.filter(num -> num == 123).ifPresent(num -> System.out.println(num));
Optional<Integer> optional456 = Optional.of(456);
optional456.filter(num -> num == 123).ifPresent(num -> System.out.println(num));
// map 转换
Optional<Integer> optional789 = Optional.of(789);
optional789.map(String::valueOf).map(String::length).ifPresent(length -> System.out.println(length));
}
}
新的时间处理类
package git.snippets.jdk8;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import static java.time.temporal.ChronoUnit.DAYS;
/**
* @since 1.8
*/
//参考 https://www.wdbyte.com/2019/10/jdk/jdk8-time/
public class LocalDateTest {
static void errorDate() {
// 不合法的日期
LocalDate invalidDate = LocalDate.of(2021, 2, 29);
invalidDate.minusYears(1);
System.out.println(invalidDate.minusYears(1));
}
static void until() {
LocalDate birthday = LocalDate.of(1989, 9, 27);
System.out.println(birthday.until(LocalDate.now(), DAYS));
}
// 有时区的精确时间
static void zone() {
ZonedDateTime nowZone = LocalDateTime.now().atZone(ZoneId.systemDefault());
System.out.println("当前精确时间（有时区）：" + nowZone);
System.out.println("当前精确时间（有时区）：" + nowZone.getYear() + "-" + nowZone.getMonthValue() + "-" + nowZone.getDayOfMonth() + " " + nowZone.getHour() + "-" + nowZone.getMinute() + "-" + nowZone.getSecond());
}
static void createTime() {
LocalDateTime ofTime = LocalDateTime.of(2019, 10, 1, 8, 8, 8);
System.out.println("当前精确时间：" + ofTime);
LocalDate localDate = LocalDate.of(2019, 10, 01);
System.out.println("当前日期：" + localDate);
LocalTime localTime = LocalTime.of(12, 01, 01);
System.out.println("当天时间：" + localTime);
}
}
stream
| 数据源获取方法 | 数据处理方法 | 结果处理方法 |
|---|---|---|
Collection.stream ()：从集合获取流 Collection.parallelStream ()：从集合获取并行流。Arrays.stream (T array) or Stream.of ()：从数组获取流。BufferedReader.lines ()：从输入流中获取流。IntStream.of ()：从静态方法中获取流。Stream.generate ()：自己生成流 |
map (mapToInt, flatMap等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered |
forEach、forEachOrdered、toArray、reduce、collect、min、max、count、anyMatch、allMatch、noneMatch、findFirst、findAny、iterator |
先看一个最简单的示例
private static void generateHandle() {
// 不使用流操作
List<String> names = Arrays.asList("A", "BBBB", "CCCC", "D");
// 筛选出长度为4的名字
List<String> subList = new ArrayList<>();
for (String name : names) {
if (name.length() == 4) {
subList.add(name);
}
}
// 把值用逗号分隔
StringBuilder sbNames = new StringBuilder();
for (int i = 0; i < subList.size() - 1; i++) {
sbNames.append(subList.get(i));
sbNames.append(", ");
}
// 去掉最后一个逗号
if (subList.size() > 1) {
sbNames.append(subList.get(subList.size() - 1));
}
System.out.println(sbNames);
}
用stream来做，就简洁很多
private static void useStream() {
List<String> names = Arrays.asList("A", "BBBB", "CCCC", "D");
String nameString = names.stream()
.filter(num -> num.length() == 4)
.collect(Collectors.joining(", "));
System.out.println(nameString);
}
package git.snippets.jdk8;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* stream使用
* 数据源（source） -> 数据处理 / 转换（intermedia） -> 结果处理（terminal ）
* @author <a href="mailto:[email protected]">Grey</a>
* @date 2021/11/21
* @since 1.8
*/
public class StreamTest {
static void demo1() {
List<String> nameList = Arrays.asList("A", "B", "AASDSD", "ABCD");
nameList.stream()
.filter(name -> name.length() == 4)
.map(name -> "This is " + name)
.forEach(System.out::println);
}
static void mathTest() {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
IntSummaryStatistics stats = list.stream().mapToInt(x -> x).summaryStatistics();
System.out.println("最小值：" + stats.getMin());
System.out.println("最大值：" + stats.getMax());
System.out.println("个数：" + stats.getCount());
System.out.println("和：" + stats.getSum());
System.out.println("平均数：" + stats.getAverage());
}
static void groupByTest() {
List<Integer> ageList = Arrays.asList(11, 22, 13, 14, 25, 26);
Map<String, List<Integer>> groupMap = ageList.stream()
.collect(Collectors.groupingBy(age -> String.valueOf(age / 10)));
groupMap.forEach((k, v) -> {
System.out.println("年龄" + k + "0多岁的有：" + v);
});
}
static void partitioningByTest() {
List<Integer> ageList = Arrays.asList(11, 22, 13, 14, 25, 26);
Map<Boolean, List<Integer>> ageMap = ageList.stream()
.collect(Collectors.partitioningBy(age -> age > 18));
System.out.println("未成年人：" + ageMap.get(false));
System.out.println("成年人：" + ageMap.get(true));
}
static void generateTest() {
// 生成自己的随机数流
Random random = new Random();
Stream<Integer> generateRandom = Stream.generate(random::nextInt);
generateRandom.limit(5).forEach(System.out::println);
// 生成自己的 UUID 流
Stream<UUID> generate = Stream.generate(UUID::randomUUID);
generate.limit(5).forEach(System.out::println);
}
}
函数式接口
有且仅有一个抽象方法的接口就是函数式接口。可以通过
@FunctionalInterface标识
最简单的一个函数式接口示例：
@FunctionalInterface
public interface FunctionDemo {
void say(String name, int age);
default void hi(String name, int age) {
say(name, age);
}
}
package git.snippets.jdk8;
public class FunctionInterfaceDemo {
public static void main(String[] args) {
function0();
}
// 最简单的函数式接口
static void function0() {
FunctionDemo demo = (name, age) -> System.out.println("我叫" + name + "我今年" + age + "岁");
demo.say("zhangsan", 20);
demo.hi("zhanshang", 20);
}
}
Predicate
可以过滤出满足条件的特定元素
示例：
package git.snippets.jdk8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
/**
* @author <a href="mailto:[email protected]">Grey</a>
* @date 2021/11/24
* @since 1.8
*/
public class PredicateTest {
public static void main(String[] args) {
List<Integer> numberList = Arrays.asList(3, 4, 5, 6, 7, 8, 9, 10);
Predicate<Integer> lessThan5 = number -> number <= 5;
Predicate<Integer> greaterThan9 = number -> number >= 9;
// 小于等于 5
System.out.println(filter(numberList, lessThan5));
// 大于 5
System.out.println(filter(numberList, lessThan5.negate()));
// 小于等于 5 或者大于等于 9
System.out.println(filter(numberList, lessThan5.or(greaterThan9)));
// ! (小于等于 5 AND 大于等于 9)
System.out.println(filter(numberList, lessThan5.and(greaterThan9).negate()));
}
// 过滤出满足条件（条件可以自定义）的特定集合元素
private static <T> List<T> filter(List<T> numberList, Predicate<T> p) {
List<T> result = new ArrayList<>();
for (T t : numberList) {
if (p.test(t)) {
result.add(t);
}
}
return result;
}
}
Consumer
Consumer有如下类型
| 类型 | 作用 |
|---|---|
BiConsumer |
传入两个任意类型参数，无返回值 |
DoubleConsumer |
传入一个 double 参数，无返回值 |
IntConsumer |
传入一个 int 参数，无返回值 |
LongConsumer |
传入一个 long 参数，无返回值 |
ObjDoubleConsumer |
传入一个任意类型参数，一个 double 参数，无返回值 |
ObjIntConsumer |
传入一个任意类型参数，一个 int 参数，无返回值 |
ObjLongConsumer |
传入一个任意类型参数，一个 long 参数，无返回值 |
示例代码
package git.snippets.jdk8;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.ObjIntConsumer;
/**
* Consumer测试
* <p>
* BiConsumer 传入两个任意类型参数，无返回值
* <p>
* DoubleConsumer 传入一个 double 参数，无返回值
* <p>
* IntConsumer 传入一个 int 参数，无返回值
* <p>
* LongConsumer 传入一个 long 参数，无返回值
* <p>
* ObjDoubleConsumer 传入一个任意类型参数，一个 double 参数，无返回值
* <p>
* ObjIntConsumer 传入一个任意类型参数，一个 int 参数，无返回值
* <p>
* ObjLongConsumer 传入一个任意类型参数，一个 long 参数，无返回值
*
* @author <a href="mailto:[email protected]">Grey</a>
* @date 2021/11/26
* @since 1.8
*/
public class ConsumerTest {
public static void main(String[] args) {
t1();
t2();
t3();
t4();
}
// 多个Consumer结合使用
static void t1() {
Consumer<String> c = System.out::println;
Consumer<String> len = s -> System.out.print(s.length());
len.andThen(c).accept("hello");
}
private static void t4() {
List<String> list = Arrays.asList("ab", "abcd");
// 某个字符串串的长度大于给定的value值，就打印
list.forEach(s -> {
if (s.length() > 3) {
System.out.println(s);
}
});
}
// 打印map中的value满足条件的key值
private static void t3() {
Map<String, Integer> map = new HashMap<>();
map.put("zhangshang", 17);
map.put("list", 21);
map.put("wangwu", 18);
BiConsumer<String, Integer> consumer = (s, i) -> {
// value大于18的记录，打印其value值
if (i > 18) {
System.out.println(s);
}
};
map.forEach(consumer);
}
private static void t2() {
List<String> list = Arrays.asList("ab", "cd");
// 打印字符串
list.forEach(System.out::println);
// 打印每个字符串的长度
list.forEach(s -> System.out.println(s.length()));
}
}
Supplier
Supplier是一个功能接口，代表结果的提供者。Supplier的功能方法是get()。一个Supplier可以通过lambda表达式、方法引用或默认构造函数来实例化。
示例代码如下
private static void s1() throws InterruptedException {
// 定义一个Supplier，可以生成区间为[0,10)的随机数
Supplier<Integer> supplier = () -> new Random().nextInt(10);
System.out.println(supplier.get());
System.out.println(supplier.get());
// 获取当前时间
Supplier<LocalDateTime> s2 = LocalDateTime::now;
System.out.println(s2.get());
Thread.sleep(1000);
System.out.println(s2.get());
}
此外，使用Supplier，还可以优雅实现工厂模式，见
package git.snippets.jdk8;
import java.time.LocalDateTime;
import java.util.Random;
import java.util.UUID;
import java.util.function.Supplier;
/**
* Supplier使用
*
* @author <a href="mailto:[email protected]">Grey</a>
* @date 2021/11/27
* @since
*/
public class SupplierTest {
public static void main(String[] args) throws InterruptedException {
System.out.println(factory(() -> new Sharp("abc")));
}
// supplier实现工厂模式
static Sharp factory(Supplier<? extends Sharp> supplier) {
Sharp sharp = supplier.get();
sharp.name = sharp.name + UUID.randomUUID();
return sharp;
}
}
class Sharp {
String name;
Sharp(String name) {
this.name = name;
}
@Override
public String toString() {
return "Sharp{" + "name='" + name + '/'' + '}';
}
}
UnaryOperator
UnaryOperator接受一个参数并返回与其输入参数相同类型的结果。
示例代码
package git.snippets.jdk8;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;
/**
* UnaryOperator使用
*
* @author <a href="mailto:[email protected]">Grey</a>
* @date 2021/11/28
* @see UnaryOperator
* @since 1.8
*/
public class UnaryOperatorTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("abcddd", "12233243");
// 将List元素先转大写，然后截取前3位，最后打印出来
mapAndConsumer(list, System.out::println, String::toUpperCase, s -> s.substring(0, 3));
unaryOperator2();
}
// 接收多个`UnaryOperator`对List元素进行处理，得到的结果执行传入consumer中
public static <T> void mapAndConsumer(List<T> list, Consumer<T> consumer, UnaryOperator<T>... unaryOperator) {
for (T t : list) {
for (UnaryOperator<T> operator : unaryOperator) {
t = operator.apply(t);
}
consumer.accept(t);
}
}
static void unaryOperator2() {
Function<String, String> upperFun1 = String::toUpperCase;
UnaryOperator<String> upperFun2 = String::toUpperCase;
List<String> list = Arrays.asList("abc", "efg");
// Function.identity() 和 UnaryOperator.identity()都不对结果进行任何操作
Map<String, String> map1 = list.stream().collect(Collectors.toMap(upperFun1, Function.identity()));
Map<String, String> map2 = list.stream().collect(Collectors.toMap(upperFun2, UnaryOperator.identity()));
Map<String, String> map3 = list.stream().collect(Collectors.toMap(upperFun2, t -> t));
System.out.println(map1);
System.out.println(map2);
System.out.println(map3);
}
}
惰性计算
package git.snippets.jdk8;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* 惰性计算
*
* @author <a href="mailto:[email protected]">Grey</a>
* @date 2021/11/23
* @since 1.8
*/
public class LazyTest {
public static void main(String[] args) {
lazyTest();
}
private static void lazyTest() {
List<Integer> numberLIst = Arrays.asList(1, 2, 3, 4, 5, 6);
// 找出偶数
Stream<Integer> integerStream = numberLIst.stream()
.filter(number -> {
int temp = number % 2;
if (temp == 0) {
System.out.println(number);
}
return temp == 0;
});
System.out.println("分割线");
// 到这里才调用
List<Integer> collect = integerStream.collect(Collectors.toList());
}
}
如上代码，打印的结果是：
分割线
2
4
6
说明调用filter的过程是在integerStream.collect(Collectors.toList());执行才触发，这就是惰性计算。
JUC 包中的 CompletableFuture
其中的
anyOf()可以实现“任意个CompletableFuture只要一个成功”，allOf()可以实现“所有CompletableFuture都必须成功”，这些组合操作可以实现非常复杂的异步流程控制。
用法参考如下代码
package git.snippets.juc;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
/**
* 假设你能够提供一个服务
* 这个服务查询各大电商网站同一类产品的价格并汇总展示
*/
public class CompletableFutureUsage {
public static void main(String[] args) throws ExecutionException, InterruptedException {
way1();
way2();
}
public static void way1() {
long start = System.currentTimeMillis();
System.out.println("p1 " + priceOfJD());
System.out.println("p2 " + priceOfTB());
System.out.println("p3 " + priceOfTM());
long end = System.currentTimeMillis();
System.out.println("串行执行，耗时(ms):" + (end - start));
}
public static void way2() throws ExecutionException, InterruptedException {
long start = System.currentTimeMillis();
CompletableFuture<Double> p1 = CompletableFuture.supplyAsync(() -> priceOfJD());
CompletableFuture<Double> p2 = CompletableFuture.supplyAsync(() -> priceOfTB());
CompletableFuture<Double> p3 = CompletableFuture.supplyAsync(() -> priceOfTM());
CompletableFuture.allOf(p1, p2, p3).join();
System.out.println("p1 " + p1.get());
System.out.println("p2 " + p2.get());
System.out.println("p3 " + p3.get());
long end = System.currentTimeMillis();
System.out.println("使用CompletableFuture并行执行，耗时(ms): " + (end - start));
}
private static double priceOfTM() {
delay();
return 1.00;
}
private static double priceOfTB() {
delay();
return 2.00;
}
private static double priceOfJD() {
delay();
return 3.00;
}
/*private static double priceOfAmazon() {
delay();
throw new RuntimeException("product not exist!");
}*/
private static void delay() {
int time = new Random().nextInt(500);
try {
TimeUnit.MILLISECONDS.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
// System.out.printf("After %s sleep!/n", time);
}
}
JUC 包中的 WorkStealingPool
每个线程都有单独的队列，每个线程队列执行完毕后，就会去其他的线程队列里面拿过来执行, 底层是：ForkJoinPool，会自动启动cpu核数个线程去执行任务
示例代码
package git.snippets.juc;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class WorkStealingPoolUsage {
public static void main(String[] args) throws IOException {
int core = Runtime.getRuntime().availableProcessors();
// 会自动启动cpu核数个线程去执行任务 ,其中第一个是1s执行完毕,其余都是2s执行完毕,
// 有一个任务会进行等待,当第一个执行完毕后,会再次偷取最后一个任务执行
ExecutorService service = Executors.newWorkStealingPool();
service.execute(new R(1000));
for (int i = 0; i < core; i++) {
service.execute(new R(2000));
}
//由于产生的是精灵线程（守护线程、后台线程），主线程不阻塞的话，看不到输出
System.in.read();
}
static class R implements Runnable {
int time;
R(int t) {
this.time = t;
}
@Override
public void run() {
try {
TimeUnit.MILLISECONDS.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(time + " " + Thread.currentThread().getName());
}
}
}
更多
参考资料
New and Enhanced APIs That Take Advantage of Lambda Expressions and Streams in Java SE 8
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/280329.html