package stream;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.IntSummaryStatistics;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.function.BinaryOperator;

import java.util.function.Consumer;

import java.util.function.Function;

import java.util.function.Predicate;

import java.util.function.Supplier;

import java.util.function.ToIntFunction;

import java.util.stream.Collectors;

import java.util.stream.Stream;

public class StreamApi {

public static void main(String[] args) {

juhe();

collect();

optional();

}

private static void juhe() {

Stream<Integer> stream = Stream.of(1, 2, 3);

// 返回流数据个数

long result = stream.count();

System.out.println("count " + result);

// 返回流中第一个元素,查找到结果后终止整个流

stream = Stream.of(1, 2, 3);

Optional<Integer> op = stream.findFirst();

System.out.println("findFirst " + op.get());

// 返回任意一个符合条件的元素，查找到结果后终止整个流

stream = Stream.of(1, 2, 3);

op = stream.findAny();

System.out.println("findAny " + op.get());

// 查询流中是否含有指定条件的元素

stream = Stream.of(1, 2, 3);

boolean anyMatch = stream.anyMatch(t -> {

return t == 1;

});

System.out.println("anyMatch " + anyMatch);

// 查询是否流中所有元素都符合指定条件

stream = Stream.of(1, 2, 3);

boolean allMatch = stream.allMatch(t -> {

return t == 1;

});

System.out.println("allMatch " + allMatch);

// 查询是否流中所有元素都不符合指定条件

stream = Stream.of(1, 2, 3);

boolean noneMatch = stream.noneMatch(t -> {

return t == 1;

});

System.out.println("noneMatch " + noneMatch);

}

private static void collect() {

Stream<Integer> stream = Stream.of(1, 2, 3);

// 将流收集为一个数组

stream = Stream.of(1, 2, 3);

Object[] array = stream.toArray();

System.out.println(array);

// 将流收集为一个List

stream = Stream.of(1, 2, 3);

stream.collect(Collectors.toList());

// 将流收集为一个collection

stream = Stream.of(1, 2, 3);

ArrayList<Integer> collection = stream.collect(Collectors.toCollection(new Supplier<ArrayList<Integer>>() {

@Override

public ArrayList<Integer> get() {

return new ArrayList<Integer>();

}

}));

// 将流元素拼装为string

Stream<String> streamStr = Stream.of("1", "2", "3");

String join = streamStr.collect(Collectors.joining());

System.out.println(join);

// 聚合流为SummaryStatistics

streamStr = Stream.of("1", "2", "3");

IntSummaryStatistics intSummaryStatistics = streamStr

.collect(Collectors.summarizingInt(new ToIntFunction<String>() {

@Override

public int applyAsInt(String value) {

return value.hashCode();

}

}));

double average = intSummaryStatistics.getAverage();

long count = intSummaryStatistics.getCount();

long max = intSummaryStatistics.getMax();

long min = intSummaryStatistics.getMin();

long sum = intSummaryStatistics.getSum();

// 将流聚合为一个map对象

Map<Integer, String> map = stream.collect(Collectors.toMap(new Function<Integer, Integer>() {

@Override

public Integer apply(Integer t) {

return t;

}

}, new Function<Integer, String>() {

@Override

public String apply(Integer t) {

return String.valueOf(t);

}

}));

stream.collect(Collectors.toMap(new Function<Integer, Integer>() {

@Override

public Integer apply(Integer t) {

return t;

}

}, new Function<Integer, String>() {

@Override

public String apply(Integer t) {

return String.valueOf(t);

}

}, new BinaryOperator<String>() {

@Override

public String apply(String t, String u) {

return t + u;

}

}));

Map<String, List<Integer>> map1 = stream.collect(Collectors.groupingBy(new Function<Integer, String>() {

@Override

public String apply(Integer t) {

return String.valueOf(t);

}

}));

Map<Boolean, List<Integer>> map2 = stream.collect(Collectors.partitioningBy(t -> {

return t > 0;

}));

stream.collect(Collectors.groupingBy(new Function<Integer, String>() {

@Override

public String apply(Integer t) {

return String.valueOf(t);

}

}, Collectors.counting()));

Map<String, Optional<Integer>> map3 = stream.collect(Collectors.groupingBy(new Function<Integer, String>() {

@Override

public String apply(Integer t) {

return String.valueOf(t);

}

}, Collectors.maxBy(new Comparator<Integer>() {

@Override

public int compare(Integer o1, Integer o2) {

return 0;

}

})));

// 迭代,终止

stream.forEach(new Consumer<Integer>() {

@Override

public void accept(Integer t) {

}

});

// 顺序迭代，线性迭代，终止

stream.forEachOrdered(new Consumer<Integer>() {

@Override

public void accept(Integer t) {

}

});

stream.peek(new Consumer<Integer>() {

@Override

public void accept(Integer t) {

}

});

}

private static void optional() {

Optional<String> optional = Optional.ofNullable("optional");

String value = optional.orElse("empty");

System.out.println("orElse " + value);

value = optional.get();

boolean isPresend = optional.isPresent();

System.out.println("isPresend " + isPresend);

value = optional.get();

optional.orElse("get else");

optional.orElseGet(new Supplier<String>() {

@Override

public String get() {

return "get Supplier";

}

});

optional.orElseThrow(new Supplier<IllegalArgumentException>() {

@Override

public IllegalArgumentException get() {

return new IllegalArgumentException();

}

});

optional.ifPresent(new Consumer<String>() {

@Override

public void accept(String t) {

System.out.println("ifPresent consumer " + t);

}

});

optional.filter(new Predicate<String>() {

@Override

public boolean test(String t) {

System.out.println("filter " + t);

return false;

}

});

optional.map(new Function<String, String>() {

@Override

public String apply(String t) {

return t + ".map";

}

});

optional.flatMap(new Function<String, Optional<String>>() {

@Override

public Optional<String> apply(String t) {

return Optional.of(t + ".flatMap");

}

});

optional.filter(new Predicate<String>() {

@Override

public boolean test(String t) {

return false;

}

});

}

}