说明
内容来自《Java 8 In Action》
示例一
Optional可以像流一样优雅处理对象,无需考虑对象是否为空。
public class Insurance {
private String name;
public String getName() {
return name;
}
}
import java.util.Optional;
public class Car {
private Insurance insurance;
private Optional<Insurance> optionalInsurance;
public Insurance getInsurance() {
return insurance;
}
public Optional<Insurance> getOptionalInsurance() {
return optionalInsurance;
}
}
import java.util.Optional;
public class Person {
private Car car;
private Optional<Car> optionalCar;
public Car getCar() {
return car;
}
public Optional<Car> getOptionalCar() {
return optionalCar;
}
}
import java.util.Optional;
public class PersonMain {
private final static String UN_KNOWN = "UNKNOWN";
private String s;
public static void main(String[] args) {
// NullPointerException
// new PersonMain().getCarInsuranceName(new Person());
String name = new PersonMain().optionalGetCarInsuranceName(Optional.empty());
System.out.println(name);
String s = new PersonMain().commonUsage(Optional.empty());
System.out.println(s);
System.out.println(new PersonMain().testString());
}
public String getCarInsuranceName(Person person) {
return person.getCar().getInsurance().getName();
}
public String optionalGetCarInsuranceName(Optional<Person> optionalPerson) {
return optionalPerson.flatMap(Person::getOptionalCar)
.flatMap(Car::getOptionalInsurance)
.map(Insurance::getName)
.orElse(UN_KNOWN);
}
public String commonUsage(Optional<Person> optionalPerson) {
return optionalPerson.map(person -> person.getCar())
.map(car -> car.getInsurance())
.map(insurance -> insurance.getName())
.orElse(UN_KNOWN);
}
public String testString() {
Optional<String> optional = Optional.ofNullable(s);
return optional.orElse(UN_KNOWN);
}
}
示例二
传统策略模式与lambda
public interface ValidationStrategy {
boolean execute(String s);
}
public class IsAllLowerCase implements ValidationStrategy {
@Override
public boolean execute(String s) {
return s.matches("[a-z]+");
}
}
public class IsNumeric implements ValidationStrategy {
@Override
public boolean execute(String s) {
return s.matches("\\d+");
}
}
public class ValidatorMain {
public static void main(String[] args) {
commonValidator();
lambdaValidator();
}
private static void commonValidator() {
Validator numericValidator = new Validator(new IsNumeric());
boolean b1 = numericValidator.validate("aaa");
Validator lowerCaseValidator = new Validator(new IsAllLowerCase());
boolean b2 = lowerCaseValidator.validate("bbb");
System.out.println(b1 + " - " + b2);
}
private static void lambdaValidator() {
Validator numericValidator = new Validator((s) -> s.matches("\\d+"));
boolean b1 = numericValidator.validate("aaa");
Validator lowerCaseValidator = new Validator((s) -> s.matches("[a-z]+"));
boolean b2 = lowerCaseValidator.validate("bbb");
System.out.println(b1 + " - " + b2);
}
}
示例三
andThen组合任务,上一项任务的结果作为下个任务的输入。
public class Letter {
public static String addHeader(String text) {
return "From Raoul, Mario and Alan: " + text;
}
public static String addFooter(String text) {
return text + " Kind regards";
}
public static String checkSpelling(String text) {
return text.replaceAll("labda", "lambda");
}
}
import java.util.function.Function;
public class LetterMain {
public static void main(String[] args) {
Function<String, String> addHeader = Letter::addHeader;
Function<String, String> addFooter = Letter::addFooter;
Function<String, String> checkSpelling = Letter::checkSpelling;
Function<String, String> pipeline = addHeader.andThen(addFooter).andThen(checkSpelling);
String letter = pipeline.apply("labda is good!");
System.out.println(letter);
}
}
示例四
100以内的勾股数
import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class NumberMain {
public static void main(String[] args) {
even();
pythagorean();
pythagorean2();
}
private static void even() {
long count = IntStream.rangeClosed(1, 100)
.filter(i -> i % 2 == 0)
.count();
System.out.println(count);
}
private static void pythagorean() {
IntStream.rangeClosed(1, 100)
.mapToObj(a -> IntStream.rangeClosed(1, 100)
.filter(b -> Math.sqrt(a * a + b * b) % 1 == 0)
.mapToObj(b -> new int[]{a, b}))
.flatMap(s -> s.map(array -> new int[]{array[0], array[1], (int) Math.sqrt(array[0] * array[0] + array[1] * array[1])}))
.forEach(array -> System.out.println(Arrays.toString(array)));
}
private static void pythagorean2() {
IntStream.rangeClosed(1, 100)
.boxed()
.flatMap(a -> IntStream.rangeClosed(a, 100)
.filter(b -> Math.sqrt(a * a + b * b) % 1 == 0)
.mapToObj(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)}))
.forEach(array -> System.out.println(Arrays.toString(array)));
}
}
示例五
规约操作
import java.util.Arrays;
import java.util.List;
public class ReduceMain {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
sum(numbers);
max(numbers);
min(numbers);
count(numbers);
}
public static void sum(List<Integer> numbers) {
int sum = numbers.stream()
.reduce(0, (i, j) -> i + j);
System.out.println(sum);
}
public static void max(List<Integer> numbers) {
numbers.stream()
.reduce((i, j) -> i > j ? i : j)
.ifPresent(System.out::println);
}
public static void min(List<Integer> numbers) {
numbers.stream()
.reduce(Integer::min)
.ifPresent(System.out::println);
}
public static void count(List<Integer> numbers) {
int count = numbers.stream()
.map(n -> 1)
.reduce(0, (i, j) -> i + j);
System.out.println(count);
}
}