Java学习网站 logicbig
java 8 Stream Tutoriala
介绍下几个常用的函数接口
@FunctionalInterface public interface Consumer<T> { void accept(T t); default Consumer<T> andThen(Consumer<? super T> after) { Objects.requireNonNull(after); return (T t) -> { accept(t); after.accept(t); }; } }
|
@FunctionalInterface public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); }
default Predicate<T> negate() { return (t) -> !test(t); }
default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); }
static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); } }
|
@FunctionalInterface public interface Supplier<T> { T get(); }
|
@FunctionalInterface public interface Function<T, R> { R apply(T t); default <V> Function<V, R> compose(Function<? super V, ? extends T> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); } default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); } static <T> Function<T, T> identity() { return t -> t; }
|
Predicate
的运用,可以组合条件筛选数据,可以去重等
public class Test { static Predicate<String> p1 = s -> s.contains("bar"), p2 = s -> s.length() < 5, p3 = s -> s.contains("foo"), p4 = p1.negate().and(p2).or(p3);
public static void main(String[] args) { Stream.of("bar","foobar","barBaz").filter(p4).forEach(System.out::println); } }
|
public class Test { static List<Bean> list = Lists.newArrayList(new Bean("a"),new Bean("a"),new Bean("c")); @Data static class Bean { @NonNull String name; } static <T> Predicate<T> distinct(Function<? super T,?> function) { Set<Object> set = new HashSet<>(); return t -> set.add(function.apply(t)); } public static void main(String[] args) { list.stream().filter(distinct(Bean::getName)).forEach(System.out::println); } }
|
Function
的运用,如求正整数 n 的阶乘是所有小于或等于 n 的正整数的乘积function(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
,斐波那契数列 0、1、1、2、3、5、8、13、21、34
,柯里化等
public class Test { static Function<Integer, Integer> function; public static void main(String[] args) { function = n -> n == 0 ? 1 : n * function.apply(n - 1); IntStream.range(0,10).forEach(i -> System.out.println(function.apply(i))); } }
|
public class Test { static Function<Integer, Integer> function; public static void main(String[] args) { function = n -> n == 0 ? 0 : n == 1 ? 1 : function.apply(n - 1) + function.apply(n - 2); IntStream.range(0,10).forEach(i -> System.out.println(function.apply(i))); } }
|
public class Test { static Function<String, String> f1 = s -> s.toLowerCase(), f2 = s -> s.replaceAll("a","b"),f3 = f1.andThen(f2),f4= f1.compose(f2); public static void main(String[] args) { System.out.println(f3.apply("A")); System.out.println(f4.apply("A")); } }
|
public class Test { static Function<String, Function<String,String>> f = a -> b -> a + b; public static void main(String[] args) { System.out.println(f.apply("hello").apply("java")); } }
|
Supplier
的运用,如反射实例化对象
public class MySupplier<T> implements Supplier<T> { private Class<T> type; public MySupplier(Class<T> type) { this.type = type; } @Override @SneakyThrows public T get() { return type.newInstance(); }
public static <T> Supplier<T> newInstance(Class<T> type) { return new MySupplier<>(type); }
public static void main(String[] args) { Bean bean = newInstance(Bean.class).get(); } } @Data class Bean { String name; }
|
public class Test implements Supplier<Integer>{ private int item; @Override public Integer get() { return item++ ; } public static void main(String[] args) { Stream.generate(new Test()).limit(10).forEach(System.out::println); } }
|
举一些比较冷门的例子
merge
public class Test { public static void main(String[] args) { HashMap<String,String> map = new HashMap<>(); map.put("k","v"); map.merge("k","v",(oldV,newV) -> oldV.concat(newV)); map.entrySet().forEach(System.out::println); } }
|
reduce
public class Test { public static void main(String[] args) { HashMap<String,String> map = new HashMap<>(); map.put("k1","v1"); map.put("k2","v2"); String result = map.entrySet().stream().map(Map.Entry::getKey).reduce((k1,k2) -> k1.concat(k2)).get(); System.out.println(result); } }
|
Collectors.mapping
下游收集器,对姓名进行分组,然后收集count
最大的数据
public class Test { public static void main(String[] args) { List<Bean> list = Lists.newArrayList( new Bean("a",100), new Bean("a",200), new Bean("c",200)); Map<String, Optional<Integer>> map = list .stream() .collect(Collectors.groupingBy(Bean::getName, Collectors.mapping(Bean::getCount,Collectors.maxBy( Comparator.comparing(Function.identity()))))); System.out.println(map.get("a")); System.out.println(map.get("c")); } @Data static class Bean { @NonNull String name; @NonNull Integer count; } }
|
collectingAndThen
下游收集器 ,对名字进行分组,然后收集最大的 count
数据,并取得最大的结果,
collectingAndThen
是为了对分组的数据进一步处理,而 Collectors.mapping
和 .map
类似,是对数据的一种转换,映射,看下面第二个例子, collectingAndThen
和 toMap
类似,看下面第三个例子
public class Test { public static void main(String[] args) { List<Bean> list = Lists.newArrayList( new Bean("a",100), new Bean("a",200), new Bean("c",200)); Map<String, Integer> map = list .stream() .collect(Collectors.groupingBy(Bean::getName, Collectors.collectingAndThen(Collectors.mapping(Bean::getCount,Collectors.maxBy(Comparator.comparing(Function.identity()))),Optional::get))); map.entrySet().forEach(System.out::println); } @Data static class Bean { @NonNull String name; @NonNull Integer count; } }
|
结果和 list.stream().map(Bean::getCount).collect(Collectors.toList());
一样
public class Test { public static void main(String[] args) { List<Bean> list = Lists.newArrayList( new Bean("a",100), new Bean("a",200), new Bean("c",200)); Collector<Bean,Integer,List<Integer>> collector = (Collector<Bean, Integer, List<Integer>>) Collectors.mapping(Bean::getCount,Collectors.toList()); List<Integer> temp = list.stream().collect(collector); temp.forEach(System.out::println); } @Data static class Bean { @NonNull String name; @NonNull Integer count; } }
|
public class Test { public static void main(String[] args) { List<Bean> list = Lists.newArrayList( new Bean("a",100), new Bean("a",200), new Bean("c",200)); Map<String,Integer> map = list.stream().collect(Collectors.toMap(Bean::getName,Bean::getCount,Integer::max)); map.entrySet().stream().forEach(System.out::println); } @Data static class Bean { @NonNull String name; @NonNull Integer count; } }
|
Collectors.partitioningBy
条件分组,满足条件为 true
,举个例子
public class Test { public static void main(String[] args) { List<Bean> list = Lists.newArrayList( new Bean("a",100), new Bean("a",200), new Bean("c",200)); Map<Boolean, List<Bean>> map = list.stream().collect(Collectors.partitioningBy(bean -> bean.getCount() > 100, Collectors.mapping(Function.identity(),Collectors.toList()))); map.entrySet().stream().forEach(System.out::println); } @Data static class Bean { @NonNull String name; @NonNull Integer count; } }
|
控制台打印
false=[Test.Bean(name=a, count=100)] true=[Test.Bean(name=a, count=200), Test.Bean(name=c, count=200)]
|
Collectors.reducing
对名字进行分组,然后收集最大的 count
数据
public class Test { public static void main(String[] args) { List<Bean> list = Lists.newArrayList( new Bean("a",100), new Bean("a",200), new Bean("c",200)); BinaryOperator<Integer> beanBinaryOperator = BinaryOperator.maxBy(Integer::compareTo); Map<String,Integer> map = list.stream().collect(Collectors.groupingBy(Bean::getName,Collectors.reducing(0,Bean::getCount,beanBinaryOperator))); map.entrySet().stream().forEach(System.out::println); } @Data static class Bean { @NonNull String name; @NonNull Integer count; } }
|
打印
Collector.of()
看下部分源码,supplier
提供者A
,一般是提供操作的容器,元素等工具,accumulator
是 A
对 T
元素进行一个操作,combiner
是A
对 T
操作的结果进行一个合并,finisher
将 A
进行转换返回结果 R
public static<T, A, R> Collector<T, A, R> of(Supplier<A> supplier, BiConsumer<A, T> accumulator, BinaryOperator<A> combiner, Function<A, R> finisher
|
举个例子
public class Test { public static void main(String[] args) { List<Bean> list = Lists.newArrayList( new Bean("a",100), new Bean("a",200), new Bean("c",200)); Collector<Bean,StringJoiner,String> collector = Collector.of( () -> new StringJoiner(","), (stringJoiner,bean) -> stringJoiner.add(bean.getName()), StringJoiner::merge, StringJoiner::toString ); System.out.println(list.stream().collect(collector)); } @Data static class Bean { @NonNull String name; @NonNull Integer count; } }
|
参考
java-8-tutorial
恕我直言:你可能真的不会java编程