java8实战

@FunctionalInterface
public interface Predicate<T>{
	boolean test(T t);
}

public static <T> List<T> filter(List<T> list, Predicate<T> p) {
  List<T> results = new ArrayList<>();
  for(T s: list){
    if(p.test(s)){
    	results.add(s);
    }
  }
  return results;
}

Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);

@FunctionalInterface
public interface Consumer<T>{
	void accept(T t);
}

public static <T> void forEach(List<T> list, Consumer<T> c){
  for(T i: list){
  	c.accept(i);
  }
}

forEach(Arrays.asList(1,2,3,4,5),(Integer i) -> System.out.println(i));

@FunctionalInterface
public interface Function<T, R>{
	R apply(T t);
}

public static <T, R> List<R> map(List<T> list,Function<T, R> f) {
  List<R> result = new ArrayList<>();
  for(T s: list){
  	result.add(f.apply(s));
  }
  return result;
}

// [7, 2, 6]
List<Integer> l = map(
Arrays.asList("lambdas","in","action"),
(String s) -> s.length()
);

//参数a没有显式类型
Comparator<Apple> c = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
//有类型推断
Comparator<Apple> c = (a1, a2) -> a1.getWeight().compareTo(a2.getWeight());

int portNumber = 1337;
Runnable r = () -> System.out.println(portNumber);
portNumber = 31337;
//错误：Lambda表达式引用的局部变量必须是最终的（final）或事实上最终的

Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = f.compose(g);//数学上会写作f(g(x))
int result = h.apply(1);//3

public class SortedDemo {

    public static void main(String[] args) {
        // 打印 13，15，20，23，50
        Arrays.asList(20, 15, 13, 23, 50).stream().sorted().forEach(System.out::println);
        
        // 如果自定义对象可以传入一个比较器
        Arrays.asList(21, 16, 14, 24, 51).stream().sorted(Integer::compareTo).forEach(System.out::println);
        
        // 不可以比较的可以传入一个Comparator接口
        Arrays.asList("22", "17", "15", "25", "52").stream().sorted((x, y) -> {
            return Integer.parseInt(x) - Integer.parseInt(y);
        }).forEach(System.out::println);
        
        // 不使用lambda表达式可以这样写，其它对象也可以参考下面的写法
        Arrays.asList("22", "17", "15", "25", "52").stream().sorted(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.parseInt(o1) - Integer.parseInt(o2);
            }
        }).forEach(System.out::println);

    }
}
————————————————
版权声明：本文为CSDN博主「诗水人间」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41813208/article/details/120384948

List<Dish> vegetarianMenu = menu.stream()
.filter(Dish::isVegetarian)
.collect(toList());

List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.stream()
.filter(i -> i % 2 == 0)
.distinct()
.forEach(System.out::println);

List<Dish> dishes = menu.stream()
.filter(d -> d.getCalories() > 300)
.limit(3)
.collect(toList());

List<Dish> dishes = menu.stream()
.filter(d -> d.getCalories() > 300)
.skip(2)
.collect(toList());

List<Integer> dishNameLengths = menu.stream()
.map(Dish::getName)
.map(String::length)
.collect(toList());

List<String> uniqueCharacters =
words.stream()
.map(w -> w.split(""))//将每个单词转换为由其字母构成的数组
.flatMap(Arrays::stream)//将各个生成流扁平化为单个流
.distinct()
.collect(Collectors.toList());

/*
使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所
有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流
相当于把一个箱子拆开，让里面的物品称为单个个体
*/

if(menu.stream().anyMatch(Dish::isVegetarian)){
	System.out.println("The menu is (somewhat) vegetarian friendly!!");
}

boolean isHealthy = menu.stream()
.allMatch(d -> d.getCalories() < 1000);

boolean isHealthy = menu.stream()
.noneMatch(d -> d.getCalories() >= 1000);

Optional<Dish> dish = menu.stream().filter(Dish::isVegetarian).findAny();

List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> firstSquareDivisibleByThree =someNumbers.stream()
.map(x -> x * x)
.filter(x -> x % 3 == 0)
.findFirst(); // 9

int sum = 0;
for (int x : numbers) {
sum += x;
}

List<Integer> numbers = Arrays.asList(4, 5, 3, 9);
int sum = numbers.stream().reduce(0, (a, b) -> a + b);

/*
首先，0作为Lambda（a）的第一个参数，从流中获得4作为第二个参数（b）。0 + 4得到4
然后再用累积值和流中下一个元素5调用Lambda，产生新的累积值9。
再用累积值和下一个元素3调用Lambda，得到12。
用12和流中最后一个元素9调用Lambda，得到最终结果21。
*/

int calories = menu.stream()
.mapToInt(Dish::getCalories)//返回一个IntStream
.sum();

IntStream intStream = menu.stream().mapToInt(Dish::getCalories);//将Stream 转换为数值流
Stream<Integer> stream = intStream.boxed();//将数值流转换为Stream

OptionalInt maxCalories = menu.stream()
.mapToInt(Dish::getCalories)
.max();
//如果没有最大值的话，显式提供一个默认最大值
int max = maxCalories.orElse(1);

//表示范围[1, 100],一个从1到100的偶数流
IntStream evenNumbers = IntStream.rangeClosed(1, 100).filter(n -> n % 2 == 0);

//从1 到100 有50个偶数
System.out.println(evenNumbers.count());

Stream<String> stream = Stream.of("Java 8 ", "Lambdas ", "In ", "Action");
stream.map(String::toUpperCase).forEach(System.out::println);

int[] numbers = {2, 3, 5, 7, 11, 13};
int sum = Arrays.stream(numbers).sum();

long uniqueWords = 0;
//流会自动关闭
try(Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())){
  uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" ")))//生成单词流
  .distinct()//删除重复项
  .count();//数一数有多少个不同的单词
}
catch(IOException e){
}

Stream.iterate(0, n -> n + 2)
  .limit(10)
  .forEach(System.out::println);
/*
iterate方法接受一个初始值（在这里是0），还有一个依次应用在每个产生的新值上的
Lambda（UnaryOperator<t>类型）。这里，我们使用Lambda n -> n + 2，返回的是前一个元
素加上2。因此，iterate方法生成了一个所有正偶数的流：流的第一个元素是初始值0。然后加
上2来生成新的值2，再加上2来得到新的值4，以此类推。这种iterate操作基本上是顺序的，
因为结果取决于前一次应用。请注意，此操作将生成一个无限流——这个流没有结尾，因为值是
按需计算的，可以永远计算下去。我们说这个流是无界的。正如我们前面所讨论的，这是流和集
合之间的一个关键区别。我们使用limit方法来显式限制流的大小。这里只选择了前10个偶数。
然后可以调用forEach终端操作来消费流，并分别打印每个元素。
*/

//使用一个数组的两个元素来代表元组。例如，new int[]{0,1}就代表了斐波纳契序列(0, 1)中的第一个元素。

Stream.iterate(new int[]{0, 1},t -> new int[]{t[1],t[0] + t[1]})
.limit(10)
.map(t -> t[0])
.forEach(System.out::println);

IntSupplier fib = new IntSupplier(){
  private int previous = 0;
  private int current = 1;
  public int getAsInt(){
    int oldPrevious = this.previous;
    int nextValue = this.previous + this.current;
    this.previous = this.current;
    this.current = nextValue;
    return oldPrevious;
  }
};
IntStream.generate(fib).limit(10).forEach(System.out::println);

/*
前面的代码创建了一个IntSupplier的实例。此对象有可变的状态：它在两个实例变量中
记录了前一个斐波纳契项和当前的斐波纳契项。getAsInt在调用时会改变对象的状态，由此在
每次调用时产生新的值。相比之下，使用iterate的方法则是纯粹不变的：它没有修改现有状态，
但在每次迭代时会创建新的元组。
*/

Comparator<Dish> dishCaloriesComparator = Comparator.comparingInt(Dish::getCalories);

Optional<Dish> mostCalorieDish =menu.stream().collect(maxBy(dishCaloriesComparator));

int totalCalories = menu.stream().collect(summingInt(Dish::getCalories));

IntSummaryStatistics menuStatistics = menu.stream().collect(summarizingInt(Dish::getCalories));
//这个收集器会把所有这些信息收集到一个叫作IntSummaryStatistics的类里，它提供了方便的取值（getter）方法来访问结果。打印menuStatisticobject会得到以下输出：
IntSummaryStatistics{count=9, sum=4300, min=120,average=477.777778, max=800}

String shortMenu = menu.stream().map(Dish::getName).collect(joining());

String shortMenu = menu.stream().collect(joining());

String shortMenu = menu.stream().map(Dish::getName).collect(joining(", "));

int totalCalories = menu.stream().collect(reducing(0, Dish::getCalories, (i, j) -> i + j));

int totalCalories = menu.stream().collect(reducing(0,Dish::getCalories,Integer::sum));

Optional<Dish> mostCalorieDish = menu.stream()
  .collect(reducing((d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2));

Map<Dish.Type, List<Dish>> dishesByType = menu.stream().collect(groupingBy(Dish::getType));

//{FISH=[prawns, salmon], OTHER=[french fries, rice, season fruit, pizza],MEAT=[pork, beef, chicken]}

public enum CaloricLevel { DIET, NORMAL, FAT }

Map<CaloricLevel, List<Dish>> dishesByCaloricLevel = menu.stream().collect(groupingBy(dish -> {
  if (dish.getCalories() <= 400) return CaloricLevel.DIET;
  else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
  else return CaloricLevel.FAT;
} ));

Map<Dish.Type, Map<CaloricLevel, List<Dish>>> dishesByTypeCaloricLevel =
menu.stream().collect(groupingBy(Dish::getType,groupingBy(dish -> {
  if (dish.getCalories() <= 400) return CaloricLevel.DIET;
  else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
  else return CaloricLevel.FAT;
  } )
  )
);

Map<Dish.Type, Long> typesCount = menu.stream().collect(groupingBy(Dish::getType, counting()));

Map<Dish.Type, Optional<Dish>> mostCaloricByType =menu.stream()
.collect(groupingBy(Dish::getType,maxBy(comparingInt(Dish::getCalories))));

Map<Dish.Type, Dish> mostCaloricByType = menu.stream()
.collect(groupingBy(Dish::getType,collectingAndThen(
maxBy(comparingInt(Dish::getCalories)),Optional::get)));

Map<Dish.Type, Set<CaloricLevel>> caloricLevelsByType =
menu.stream().collect(groupingBy(Dish::getType, mapping(
dish -> { if (dish.getCalories() <= 400) return CaloricLevel.DIET;
else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
else return CaloricLevel.FAT; },toSet() )));

//{OTHER=[DIET, NORMAL], MEAT=[DIET, NORMAL, FAT], FISH=[DIET, NORMAL]}
//对于返回的Set是什么类型并没有任何保证。但通过使用toCollection，你就可以有更多的控制。例如，你可以给它传递一个构造函数引用来要求HashSet：把toSet()换为toCollection(HashSet::new)

public class Demo2 {
    public static void main(String[] args) {
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // data list
        List<User> userList = Arrays.asList(
                User.builder().id(123456).name("Zhang, San").city("ShangHai").sex("man").birthDay(LocalDateTime.parse("2022-07-01 12:00:00", df)).build(),
                User.builder().id(777777).name("Zhang, San").city("ShangHai").sex("woman").birthDay(LocalDateTime.parse("2022-07-01 12:00:00", df)).build(),
                User.builder().id(888888).name("Li, Si").city("ShangHai").sex("man").birthDay(LocalDateTime.parse("2022-07-01 12:00:00", df)).build(),
                User.builder().id(999999).name("Zhan, San").city("HangZhou").sex("woman").birthDay(LocalDateTime.parse("2022-07-01 12:00:00", df)).build(),
                User.builder().id(555555).name("Li, Si").city("NaJin").sex("man").birthDay(LocalDateTime.parse("2022-07-01 12:00:00", df)).build()
        );
        
        //根据城市和性别进行分组
        Map<String, List<User>> groupMap = userList.stream()
        	.collect(Collectors.groupingBy(u -> u.getCity() + "|" + u.getSex()));
        groupMap.forEach((k, v) -> {
            System.out.println(k);
            System.out.println(v);
        });
    }
}

public class MyBeanUtil {

    public static void main(String[] args) {
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // data list
        List<User> userList = Arrays.asList(
                User.builder().id(123456).name("Zhang, San").city("ShangHai").sex("man").birthDay(LocalDateTime.parse("2022-07-01 12:00:00", df)).build(),
                User.builder().id(777777).name("Zhang, San").city("ShangHai").sex("woman").birthDay(LocalDateTime.parse("2022-07-01 12:00:00", df)).build(),
                User.builder().id(888888).name("Li, Si").city("ShangHai").sex("man").birthDay(LocalDateTime.parse("2022-07-01 12:00:00", df)).build(),
                User.builder().id(999999).name("Zhan, San").city("HangZhou").sex("woman").birthDay(LocalDateTime.parse("2022-07-01 12:00:00", df)).build(),
                User.builder().id(555555).name("Li, Si").city("NaJin").sex("man").birthDay(LocalDateTime.parse("2022-07-01 12:00:00", df)).build()
        );
        // 进行分组，根据名字和城市分组
        Map<String, List<User>> groupMap = groupingBy(userList, User::getSex, User::getCity);
        //打印分组结果
        groupMap.forEach((k, v) -> {
            System.out.println(k);
            System.out.println(v);
        });
    }
    /**
     * 将数据分组，根据方法引用（bean的get方法）
     *
     * @param list      为分组的数据
     * @param functions get方法数组
     */
    @SafeVarargs
    public static <T, R> Map<String, List<T>> groupingBy(List<T> list, Function<T, R>... functions) {
        return list.stream().collect(Collectors.groupingBy(t -> groupingBy(t, functions)));
    }

    /**
     * 分组工具根据函数式接口使用分组，将数据根据分组结果进行拆分
     */
    @SafeVarargs
    public static <T, R> String groupingBy(T t, Function<T, R>... functions) {
        if (functions == null || functions.length == 0) {
            throw new NullPointerException("functions数组不可以为空");
        } else if (functions.length == 1) {
            return functions[0].apply(t).toString();
        } else {
            return Arrays.stream(functions).map(fun -> fun.apply(t).toString()).reduce((str1, str2) -> str1 + "|" + str2).get();
        }
    }
}

    public static <T, K> Collector<T, ?, HashMap<K, List<T>>>
    groupingBy(Function<? super T, ? extends K>... classifier) {
        return groupingBy("|", classifier);
    }
    
    public static <T, K> Collector<T, ?, HashMap<K, List<T>>>
    groupingBy(String split, Function<? super T, ? extends K>... classifier) {
        return groupingBy(split, classifier, HashMap::new, toList());
    }
    
    public static <T, K, D, A, M extends Map<? super K, D>>
    Collector<T, ?, M> groupingBy(String split,
                                  Function<? super T, ? extends K>[] classifierArr,
                                  Supplier<M> mapFactory,
                                  Collector<? super T, A, D> downstream) {
        Supplier<A> downstreamSupplier = downstream.supplier();
        BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
        BiConsumer<Map<K, A>, T> accumulator = (m, t) -> {
            String key = Arrays.stream(classifierArr).map(classifier -> Objects.requireNonNull(classifier.apply(t))).map(String::valueOf).reduce((s1, s2) -> s1 + split + s2).get();
            A container = m.computeIfAbsent((K) key, k -> downstreamSupplier.get());
            downstreamAccumulator.accept(container, t);
        };
        BinaryOperator<Map<K, A>> merger = Collectors.<K, A, Map<K, A>>mapMerger(downstream.combiner());
        @SuppressWarnings("unchecked")
        Supplier<Map<K, A>> mangledFactory = (Supplier<Map<K, A>>) mapFactory;

        if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
            return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_ID);
        } else {
            @SuppressWarnings("unchecked")
            Function<A, A> downstreamFinisher = (Function<A, A>) downstream.finisher();
            Function<Map<K, A>, M> finisher = intermediate -> {
                intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
                @SuppressWarnings("unchecked")
                M castResult = (M) intermediate;
                return castResult;
            };
            return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_NOID);
        }
    }

Map<Boolean, List<Dish>> partitionedMenu =
menu.stream().collect(partitioningBy(Dish::isVegetarian));

//{false=[pork, beef, chicken, prawns, salmon],true=[french fries, rice, season fruit, pizza]}

List<Dish> vegetarianDishes =
menu.stream().filter(Dish::isVegetarian).collect(toList());

Map<Boolean, Map<Dish.Type, List<Dish>>> vegetarianDishesByType =
menu.stream().collect(
partitioningBy(Dish::isVegetarian,groupingBy(Dish::getType)));

//{false={FISH=[prawns, salmon], MEAT=[pork, beef, chicken]},true={OTHER=[french fries, rice, season fruit, pizza]}}

Map<Boolean, Dish> mostCaloricPartitionedByVegetarian =
menu.stream().collect(
partitioningBy(Dish::isVegetarian,
collectingAndThen(maxBy(comparingInt(Dish::getCalories)),Optional::get)));

//{false=pork, true=pizza}

public interface Collector<T, A, R> {
  Supplier<A> supplier();
  BiConsumer<A, T> accumulator();
  Function<A, R> finisher();
  BinaryOperator<A> combiner();
  Set<Characteristics> characteristics();
}
/*
T是流中要收集的项目的泛型。
A是累加器的类型，累加器是在收集过程中用于累积部分结果的对象。
R是收集操作得到的对象（通常但并不一定是集合）的类型。
*/

public class ToListCollector<T> implements Collector<T, List<T>, List<T>>{
  /*建立新的结果容器：supplier方法
  supplier方法必须返回一个结果为空的Supplier，也就是一个无参数函数，在调用时它会创建一个空的累加器实	     例，供数据收集过程使用。
  */
  public Supplier<List<T>> supplier() {
    return ArrayList::new;
  }
  /*
  将元素添加到结果容器：accumulator方法
  accumulator方法会返回执行归约操作的函数。当遍历到流中第n个元素时，这个函数执行时会有两个参数：保存归约结果的累加器（已收集了流中的前 n1 个项目），还有第n个元素本身。该函数将返回void，因为累加器是原位更新，即函数的执行改变了它的内部状态以体现遍历的
元素的效果。
  */
  public BiConsumer<List<T>, T> accumulator() {
  	return List::add;
  }
  /*
  对结果容器应用最终转换：finisher方法
  在遍历完流后，finisher方法必须返回在累积过程的最后要调用的一个函数，以便将累加器对象转换为整个集合操作的最终结果。
  */
  public Function<List<T>, List<T>> finisher() {
  	return Function.identity();
  }
  
  /*
  合并两个结果容器：combiner方法
  combiner方法会返回一个供归约操作使用的函数，它定义了对流的各个子部分进行并行处理时，各个子部分归约所得的累加器要如何合并。
  */
  public BinaryOperator<List<T>> combiner() {
    return (list1, list2) -> {
    list1.addAll(list2);
    return list1; }
  }
  
  /*
  characteristics方法
  characteristics会返回一个不可变的Characteristics集合，它定义了收集器的行为——尤其是关于流是否可以并行归约，以及可以使用哪些优化的提示。
  */
  public Set<Characteristics> characteristics() {
    return Collections.unmodifiableSet(EnumSet.of(
    IDENTITY_FINISH, CONCURRENT));
  }
}

public class CollectDemo {

    public static void main(String[] args) {
        // 转换为字符串数组
        final List<String> collect = Arrays.asList(1, 2, 3, 4).stream()
        .map(String::valueOf).collect(Collectors.toList());
    }
}

public class Demo {


    public static void main(String[] args) throws Exception {

        final ArrayList<User> users = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            users.add(User.builder().name(String.valueOf(i)).sex("男").age(11).build());
        }
        
        Map<String, Object> map = users.stream()
                .collect(Collectors.toMap(k -> k.name + k.sex, v -> v.age));

        map.forEach((k,v)->{
            System.out.println(k+" "+v);
        });
        
    }
}

public class Demo {

    public static void main(String[] args) {

        // 准备测试数据
        final ArrayList<User> users = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            users.add(User.builder().id(String.valueOf(i)).sex("男").build());
        }
        // 得到转换后的Map
        Map<String, String> map = users.stream().parallel()
                .collect(Collectors.toMap(k -> k.sex, v -> v.id, (x, y) -> {
                    System.out.println("第一个值的value："+x);
                    System.out.println("第二个值的value："+y);
                    System.out.println("===========保留："+y);
                    return y;
                }));

        // 遍历map
        map.forEach((k, v) -> {
            System.out.println("最终结果：" + k + " " + v);
        });

    }
}

public class CollectDemo {

    public static void main(String[] args) {

        ArrayList<Object> collect;
        collect = Arrays.asList(
                User.builder().age(1).build(),
                User.builder().age(2).build(),
                User.builder().age(1).build(),
                User.builder().age(2).build(),
                User.builder().age(5).build()
        ).stream().collect(ArrayList::new, ArrayList::add, (x, y) -> {
        });
        // 单线程进行收集
        System.out.println(collect);

        // 正确的并发收集
        collect = Arrays.asList(
                User.builder().age(1).build(),
                User.builder().age(2).build(),
                User.builder().age(1).build(),
                User.builder().age(2).build(),
                User.builder().age(5).build()
        ).stream().parallel().collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
        System.out.println(collect);

    }
}

public static long parallelSum(long n) {
  return Stream.iterate(1L, i -> i + 1)
  .limit(n)
  .parallel()//将流转换为并行流
  .reduce(0L, Long::sum);
}

public class ForkJoinSumCalculator extends java.util.concurrent.RecursiveTask<Long> {
	//要求和的数组
    private final long[] numbers;
    //子任务处理的数组的起始和终止位置
	private final int start;
	private final int end;
    //不再将任务分解为子任务的数组大小
	public static final long THRESHOLD = 10000;
  
    //公共构造函数用于创建主任务
	public ForkJoinSumCalculator(long[] numbers) {
		this(numbers, 0, numbers.length);
	}
  
    //私有构造函数用于以递归方式为主任务创建子任务
	private ForkJoinSumCalculator(long[] numbers, int start, int end) {
		this.numbers = numbers;
		this.start = start;
		this.end = end;
	}
  
    //覆盖RecursiveTask抽象方法
	@Override
	protected Long compute() {
        //该任务负责求和的部分的大小
		int length = end - start;
		if (length <= THRESHOLD) {
            //如果大小小于或等于阈值，顺序计算结果
			return computeSequentially();
		}
        //创建一个子任务来为数组的前一半求和
		ForkJoinSumCalculator leftTask =
		new ForkJoinSumCalculator(numbers, start, start + length/2);
        //利用另一个ForkJoinPool线程异步执行新创建的子任务
		leftTask.fork();
        //创建一个任务为数组的后一半求和
		ForkJoinSumCalculator rightTask =
		new ForkJoinSumCalculator(numbers, start + length/2, end);
        //同步执行第二个子任务，有可能允许进一步递归划分
		Long rightResult = rightTask.compute();
        //读取第一个子任务的结果，如果尚未完成就等待
		Long leftResult = leftTask.join();
        //该任务的结果是两个子任务结果的组合
		return leftResult + rightResult;
	}
  
    //在子任务不再可分时计算结果的简单算法
	private long computeSequentially() {
		long sum = 0;
		for (int i = start; i < end; i++) {
			sum += numbers[i];
		}
		return sum;
	}
}

public static long forkJoinSum(long n) {
	long[] numbers = LongStream.rangeClosed(1, n).toArray();
	ForkJoinTask<Long> task = new ForkJoinSumCalculator(numbers);
	return new ForkJoinPool().invoke(task);
}

public interface Spliterator<T> {
  boolean tryAdvance(Consumer<? super T> action);
  Spliterator<T> trySplit();
  long estimateSize();
  int characteristics();
}
/*
T是Spliterator遍历的元素的类型。

tryAdvance方法的行为类似于普通的Iterator，因为它会按顺序一个一个使用Spliterator中的元素，并且如果还有其他元素要遍历就返回true

trySplit是专为Spliterator接口设计的，因为它可以把一些元素划出去分给第二个Spliterator（由该方法返回），让它们两个并行处理

estimateSize方法估计还剩下多少元素要遍历，因为即使不那么确切，能快速算出来是一个值也有助于让拆分均匀一点
*/

default void sort(Comparator<? super E> c){
	Collections.sort(this, c);
}

default Stream<E> stream() {
	return StreamSupport.stream(spliterator(), false);
}

public class C implements B, A {
  void hello(){
  	B.super.hello();
  }
}

Optional<Car> optCar = Optional.empty();

Optional<Car> optCar = Optional.of(car);

Optional<Car> optCar = Optional.ofNullable(car);

public Optional<Insurance> nullSafeFindCheapestInsurance(
Optional<Person> person, Optional<Car> car) {
	return person.flatMap(p -> car.map(c -> findCheapestInsurance(p, c)));
}

/*
你对第一个Optional对象调用flatMap方法，如果它是个空值，传递给它
的Lambda表达式不会执行，这次调用会直接返回一个空的Optional对象。反之，如果person
对象存在，这次调用就会将其作为函数Function的输入，并按照与flatMap方法的约定返回
一个Optional<Insurance>对象。这个函数的函数体会对第二个Optional对象执行map操
作，如果第二个对象不包含car，函数Function就返回一个空的Optional对象，整个
nullSafeFindCheapestInsuranc方法的返回值也是一个空的Optional对象。最后，如果
person和car对象都存在，作为参数传递给map方法的Lambda表达式能够使用这两个值安全
地调用原始的findCheapestInsurance方法，完成期望的操作。
*/

//创建Executor-Service，通过它你可以向线程池提交任务
ExecutorService executor = Executors.newCachedThreadPool();
//向Executor-Service提交一个Callable对象
Future<Double> future = executor.submit(new Callable<Double>() {
  public Double call() {
  	return doSomeLongComputation();
}});
//异步操作进行的同时，你可以做其他的事情
doSomethingElse();
try {
  	//获取异步操作的结果，如果最终被阻塞，无法得到结果，那么在最多等待1秒钟之后退出
	Double result = future.get(1, TimeUnit.SECONDS);
} catch (ExecutionException ee) {
// 计算抛出一个异常
} catch (InterruptedException ie) {
// 当前线程在等待过程中被中断
} catch (TimeoutException te) {
// 在Future对象完成之前超过已过期
}