序
本文的灵感全全来自于阿里大佬的文章：《一种新的流：为 Java 加入生成器(Generator)特性》。
为此我必须在序言中就强烈声明这一点。同时也希望阅读此文章的JYM也能去读一下大佬的文章。
简述java8流
java8流相信大家都用过，也已经非常熟悉，虽然可能实现上大家并不一定都读过源码，但是用得时候都会感到代码冗长，一些复杂的操作总是要写得很长很长。身为一个精益求精的程序猿，有时候看到自己写得代码不免也是头疼。
这里顺便提一嘴，如果各位有兴趣去深入了解java8stream流，不妨阅读一下这个专栏：Java8 Stream源码精讲。
java8流设计的非常巧妙，对于现在的我来说那是不容置疑的，大佬说java8为了并行流做了很多让步导致stream流源码晦涩难懂。但如果你跳过并行流的相关代码，只去读核心代码的话其实java8流的设计我觉得真的是很巧妙的，Collectors的设计虽然重，但用起来却是通用且灵活。一些复杂的分组聚合操作都是信手捏来。大佬的文章中也讲到了这点，此处我就不多做赘述了。
本文的目的
本文并不会去探讨过多的技术和思想，这些东西大佬文章里都有。大佬珠玉在前，我又岂敢班门弄斧。
本文只是单纯的分享自己写的简易的java8流操作API。
如果大家有更好的想法都可以一起讨论。
我写的Seq和MapSeq工具类
这两个类都可以直接使用。
Seq
package com.demodebug.seq;
import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.*;
/**
* yaoj
*
* @param <T>
*/
@FunctionalInterface
public interface Seq<T> {
void consume(Consumer<T> consumer);
/**
* 生成Seq
*
* @param list
* @param <T>
* @return
*/
static <T> Seq<T> of(Iterable<T> list) {
return list::forEach;
}
static <E> Seq<E> unit(E e) {
return c -> c.accept(e);
}
/**
* 数据转换
*
* @param function
* @param <E>
* @return
*/
default <E> Seq<E> map(Function<T, E> function) {
return c -> consume(t -> c.accept(function.apply(t)));
}
/**
* 数据转换（不为null的）
*
* @param function
* @param <E>
* @return
*/
default <E> Seq<E> mapNotNull(Function<T, E> function) {
return c -> consume(t -> {
if (t != null) {
c.accept(function.apply(t));
}
}
);
}
/**
* 数据转换（从下标处开始）
*
* @param function
* @param <E>
* @return
*/
default <E> Seq<E> mapIndex(Function<T, E> function, int index) {
AtomicInteger indexStart = new AtomicInteger(0);
return c -> consume(t -> {
if (indexStart.get() >= index) {
c.accept(function.apply(t));
}
indexStart.getAndIncrement();
}
);
}
/**
* 数据转换flatMap
*
* @param seq
* @param <E>
* @return
*/
default <E> Seq<E> flatMap(Function<T, Seq<E>> seq) {
return c -> consume(t -> seq.apply(t).consume(c));
}
/**
* 数据过滤
*
* @param predicate
* @return
*/
default Seq<T> filter(Predicate<T> predicate) {
return c -> consume(t -> {
if (predicate.test(t)) {
c.accept(t);
}
});
}
/**
* 数据过滤（不为null的）
*
* @param predicate
* @return
*/
default Seq<T> filterNotNull(Predicate<T> predicate) {
return c -> consume(t -> {
if (t != null && predicate.test(t)) {
c.accept(t);
}
});
}
/**
* 数据过滤（从下标开始）且过滤不为null的
*
* @param predicate
* @param index
* @return
*/
default Seq<T> filterIndex(Predicate<T> predicate, int index) {
AtomicInteger indexStart = new AtomicInteger(0);
return c -> consume(t -> {
if (t != null && indexStart.get() >= index && predicate.test(t)) {
c.accept(t);
}
indexStart.getAndIncrement();
});
}
/**
* 过滤为null的数据
*
* @return
*/
default Seq<T> filterNotNull() {
return c -> consume(t -> {
if (t != null) {
c.accept(t);
}
});
}
/**
* 数据处理
*
* @param consumer
* @return
*/
default Seq<T> peek(Consumer<T> consumer) {
return c -> consume(t -> {
consumer.accept(t);
c.accept(t);
});
}
/**
* 去重
* List<String> list = Arrays.asList("AASDSA", "BBBASDSA", "QWEQDAS", "AASDSA");
* List<String> strings = Seq.of(list).distinct().toList();
* System.out.println(strings);
*
* @return
*/
default Seq<T> distinct() {
HashSet<T> set = new HashSet<>();
return c -> consume(t -> {
if (!set.contains(t)) {
set.add(t);
c.accept(t);
}
});
}
/**
* 对象去重
* List<User> users = Arrays.asList(new User("yaojie", "cz", 10), new User("yaojie", "cz", 20), new User("yaojie", "bj", 10));
* java 8：List<User> collect = users.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(e -> e.getName() + e.getAddr()))),ArrayList::new));
* List<User> userList = Seq.of(users).distinctBean(e -> e.getName() + e.getAddr()).toList();
*
* @param function
* @param <V>
* @return
*/
default <V> Seq<T> distinctBean(Function<T, V> function) {
HashSet<V> set = new HashSet<>();
return c -> consume(t -> {
V v = function.apply(t);
if (!set.contains(v)) {
set.add(v);
c.accept(t);
}
});
}
/**
* 规整成集合
*
* @return
*/
default Collection<T> toCollection(Supplier<Collection<T>> supplier) {
Collection<T> col = supplier.get();
consume(col::add);
return col;
}
/**
* 规整成List
*
* @return
*/
default List<T> toList() {
List<T> list = new ArrayList<>();
consume(list::add);
return list;
}
/**
* 规整成Set
*
* @return
*/
default Set<T> toSet() {
HashSet<T> set = new HashSet<>();
consume(set::add);
return set;
}
/**
* 规整成字符串
* List<String> list = Arrays.asList("AASDSA", "BBBASDSA", "QWEQDAS", "AASDSA");
* String join = Seq.of(list).join("--", "{", "}");
* System.out.println(join);
*
* @param split
* @param prefix
* @param suffix
* @return
*/
default String join(String split, String prefix, String suffix) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(prefix);
consume(t -> stringBuilder.append(t).append(split));
return stringBuilder.substring(0, stringBuilder.lastIndexOf(split)) + suffix;
}
/**
* 转map
*
* @param keyFunction
* @param valueFunction
* @param supplier
* @param <K>
* @param <V>
* @return
*/
default <K, V> Map<K, V> toMap(Function<T, K> keyFunction, Function<T, V> valueFunction, Supplier<Map<K, V>> supplier) {
Map<K, V> map = supplier.get();
consume(t -> map.put(keyFunction.apply(t), valueFunction.apply(t)));
return map;
}
/**
* 转map
*
* @param keyFunction
* @param valueFunction
* @param <K>
* @param <V>
* @return
*/
default <K, V> Map<K, V> toMap(Function<T, K> keyFunction, Function<T, V> valueFunction) {
return toMap(keyFunction, valueFunction, HashMap::new);
}
/**
* 分组以后对对象再做处理
* List<User> users = Arrays.asList(new User("yaojie", "cz", 10), new User("yaojie", "sz", 20), new User("yuxin", "bj", 10));
* Map<String, List<String>> stringListMap = Seq.of(users).groupByWithMapping(User::getName, e -> e.getName().toUpperCase(Locale.ROOT));
* Map<String, List<String>> collect = users.stream().collect(Collectors.groupingBy(User::getName, Collectors.mapping(e -> e.getName().toUpperCase(Locale.ROOT), Collectors.toList())));
*
* @param function
* @param supplier
* @param functionDown
* @param <V>
* @param <RR>
* @return
*/
default <V, RR> Map<V, List<RR>> groupByWithMapping(Function<T, V> function, Supplier<Map<V, List<RR>>> supplier, Function<T, RR> functionDown) {
Map<V, List<RR>> groupMap = supplier.get();
consume(t -> {
V key = function.apply(t);
if (groupMap.containsKey(key)) {
groupMap.get(key).add(functionDown.apply(t));
} else {
List<RR> list = new ArrayList<>();
list.add(functionDown.apply(t));
groupMap.put(key, list);
}
});
return groupMap;
}
default <V, RR> Map<V, List<RR>> groupByWithMapping(Function<T, V> function, Function<T, RR> functionDown) {
return groupByWithMapping(function, () -> new HashMap<>(), functionDown);
}
/**
* 分组
* List<User> users = Arrays.asList(new User("yaojie", "cz", 10),new User("yaojie", "sz", 20),new User("yuxin", "sz", 20),new User("yaojie", "bj", 10));
* Map<String, List<User>> stringListMap = Seq.of(users).groupBy(User::getName);
*
* @param function
* @param supplier
* @param <V>
* @return
*/
default <V> Map<V, List<T>> groupByOver(Function<T, V> function, Supplier<Map<V, List<T>>> supplier) {
Map<V, List<T>> groupMap = supplier.get();
consume(t -> {
V key = function.apply(t);
if (groupMap.containsKey(key)) {
groupMap.get(key).add(t);
} else {
List<T> list = new ArrayList<>();
list.add(t);
groupMap.put(key, list);
}
});
return groupMap;
}
default <V> Map<V, List<T>> groupByOver(Function<T, V> function) {
return groupByOver(function, () -> new HashMap<>());
}
/**
* 分组计算数量
*
* @param function
* @param supplier
* @param <V>
* @return
*/
default <V> Map<V, Integer> groupCount(Function<T, V> function, Supplier<Map<V, Integer>> supplier) {
Map<V, Integer> groupMap = supplier.get();
consume(t -> {
V key = function.apply(t);
if (groupMap.containsKey(key)) {
Integer count = groupMap.get(key);
count++;
groupMap.put(key, count);
} else {
groupMap.put(key, 1);
}
});
return groupMap;
}
default <V> Map<V, Integer> groupCount(Function<T, V> function) {
return groupCount(function, () -> new HashMap<>());
}
/**
* 分组
*
* @param function
* @param supplier
* @param <V>
* @return
*/
default <V> Seq<Map<V, List<T>>> groupBy(Function<T, V> function, Supplier<Map<V, List<T>>> supplier) {
Map<V, List<T>> groupMap = supplier.get();
return c -> consume(t -> {
V key = function.apply(t);
if (groupMap.containsKey(key)) {
groupMap.get(key).add(t);
} else {
List<T> list = new ArrayList<>();
list.add(t);
groupMap.put(key, list);
c.accept(groupMap);
}
});
}
default <V> Seq<Map<V, List<T>>> groupBy(Function<T, V> function) {
return groupBy(function, () -> new HashMap<>());
}
/**
* 分组整合成字符串
* List<User> users = Arrays.asList(new User("yaojie", "cz", 10), new User("yaojie", "sz", 20), new User("yuxin", "bj", 10));
* Java 8：Map<String, String> collect = users.stream().collect(Collectors.groupingBy(User::getName, Collectors.mapping(e -> e.getName().toUpperCase(Locale.ROOT), Collectors.joining("--"))));
* Map<String, String> stringListMap = Seq.of(users).groupByWithJoin(User::getName, e -> e.getName().toUpperCase(Locale.ROOT),"--");
*
* @param function
* @param functionDown
* @param split
* @param prefix
* @param suffix
* @param <V>
* @return
*/
default <V> Map<V, String> groupByWithJoin(Function<T, V> function, Function<T, String> functionDown, String split, String prefix, String suffix) {
Map<V, String> joinMap = new HashMap<>();
Map<V, String> resultMap = new HashMap<>();
consume(t -> {
V key = function.apply(t);
if (joinMap.containsKey(key)) {
joinMap.put(key, joinMap.get(key) + split + functionDown.apply(t));
} else {
String stringBuilder = prefix + functionDown.apply(t);
joinMap.put(key, stringBuilder);
}
});
joinMap.forEach((key, value) -> resultMap.put(key, value + suffix));
return resultMap;
}
default <V> Map<V, String> groupByWithJoin(Function<T, V> function, Function<T, String> functionDown, String split) {
return groupByWithJoin(function, functionDown, split, "", "");
}
/**
* BigDecimal 加法计算
* List<User> users = Arrays.asList(new User("yaojie", "cz", 10,new BigDecimal(100)), new User("yaojie", "sz", 20,new BigDecimal(300)), new User("yuxin", "bj", 10,new BigDecimal(400)));
* BigDecimal reduce = users.stream().map(User::getMoney).reduce(new BigDecimal(0), BigDecimal::add);
* BigDecimal bigDecimal = Seq.of(users).bigDecimalAdd(User::getMoney);
*
* @param bigDecimal
* @param function
* @return
*/
default BigDecimal bigDecimalAdd(BigDecimal bigDecimal, Function<T, BigDecimal> function) {
final BigDecimal[] returnNum = {bigDecimal};
consume(t -> {
returnNum[0] = returnNum[0].add(function.apply(t));
});
return returnNum[0];
}
default BigDecimal bigDecimalAdd(Function<T, BigDecimal> function) {
return bigDecimalAdd(BigDecimal.ZERO, function);
}
/**
* int 加法计算
*
* @param in
* @param tToIntFunction
* @return
*/
default Integer intSum(Integer in, ToIntFunction<T> tToIntFunction) {
final Integer[] returnNum = {in};
consume(t -> returnNum[0] = returnNum[0] + tToIntFunction.applyAsInt(t));
return returnNum[0];
}
default Integer intSum(ToIntFunction<T> tToIntFunction) {
return intSum(0, tToIntFunction);
}
/**
* long 加法计算
*
* @param in
* @param toLongFunction
* @return
*/
default Long longSum(Long in, ToLongFunction<T> toLongFunction) {
final Long[] returnNum = {in};
consume(t -> returnNum[0] = returnNum[0] + toLongFunction.applyAsLong(t));
return returnNum[0];
}
default Long longSum(ToLongFunction<T> toLongFunction) {
return longSum(0L, toLongFunction);
}
/**
* BigDecimal 最大值计算
* List<User> users = Arrays.asList(new User("yaojie", "cz", 10,new BigDecimal(100)), new User("yaojie", "sz", 20,new BigDecimal(300)), new User("yuxin", "bj", 10,new BigDecimal(400)));
* BigDecimal bigDecimal = Seq.of(users).bigDecimalMax(User::getMoney);
*
* @param function
* @return
*/
default BigDecimal bigDecimalMax(Function<T, BigDecimal> function) {
final BigDecimal[] returnNum = {BigDecimal.ZERO};
AtomicInteger index = new AtomicInteger(1);
consume(t -> {
BigDecimal apply = function.apply(t);
if (index.get() == 1) {
returnNum[0] = apply;
}
if (returnNum[0].compareTo(apply) < 0) {
returnNum[0] = apply;
}
index.getAndIncrement();
});
return returnNum[0];
}
/**
* int 最大值计算
*
* @param tToIntFunction
* @return
*/
default Integer intMax(ToIntFunction<T> tToIntFunction) {
final Integer[] returnNum = {0};
AtomicInteger index = new AtomicInteger(1);
consume(t -> {
Integer apply = tToIntFunction.applyAsInt(t);
if (index.get() == 1) {
returnNum[0] = apply;
}
if (returnNum[0].compareTo(apply) < 0) {
returnNum[0] = apply;
}
index.getAndIncrement();
});
return returnNum[0];
}
/**
* long 最大值计算
*
* @param tToLongFunction
* @return
*/
default Long longMax(ToLongFunction<T> tToLongFunction) {
final Long[] returnNum = {0L};
AtomicInteger index = new AtomicInteger(1);
consume(t -> {
Long apply = tToLongFunction.applyAsLong(t);
if (index.get() == 1) {
returnNum[0] = apply;
}
if (returnNum[0].compareTo(apply) < 0) {
returnNum[0] = apply;
}
index.getAndIncrement();
});
return returnNum[0];
}
/**
* BigDecimal 最小值计算
*
* @param function
* @return
*/
default BigDecimal bigDecimalMin(Function<T, BigDecimal> function) {
final BigDecimal[] returnNum = {BigDecimal.ZERO};
AtomicInteger index = new AtomicInteger(1);
consume(t -> {
BigDecimal apply = function.apply(t);
if (index.get() == 1) {
returnNum[0] = apply;
}
if (returnNum[0].compareTo(apply) > 0) {
returnNum[0] = apply;
}
index.getAndIncrement();
});
return returnNum[0];
}
/**
* int 最小值计算
*
* @param tToIntFunction
* @return
*/
default Integer intMin(ToIntFunction<T> tToIntFunction) {
final Integer[] returnNum = {0};
AtomicInteger index = new AtomicInteger(1);
consume(t -> {
Integer apply = tToIntFunction.applyAsInt(t);
if (index.get() == 1) {
returnNum[0] = apply;
}
if (returnNum[0].compareTo(apply) > 0) {
returnNum[0] = apply;
}
index.getAndIncrement();
});
return returnNum[0];
}
/**
* long 最小值计算
*
* @param tToLongFunction
* @return
*/
default Long longMin(ToLongFunction<T> tToLongFunction) {
final Long[] returnNum = {0L};
AtomicInteger index = new AtomicInteger(1);
consume(t -> {
Long apply = tToLongFunction.applyAsLong(t);
if (index.get() == 1) {
returnNum[0] = apply;
}
if (returnNum[0].compareTo(apply) > 0) {
returnNum[0] = apply;
}
index.getAndIncrement();
});
return returnNum[0];
}
/**
* BigDecimal 平均值值计算
* List<User> users = Arrays.asList(new User("yaojie", "cz", 10,new BigDecimal(100)), new User("yaojie", "sz", 20,new BigDecimal(300)), new User("yuxin", "bj", 10,new BigDecimal(400)));
* BigDecimal bigDecimal = Seq.of(users).bigDecimalAverage(User::getMoney,3,BigDecimal.ROUND_HALF_UP);
*
* @param function
* @return
*/
default BigDecimal bigDecimalAverage(Function<T, BigDecimal> function, int scale, int roundingMode) {
final BigDecimal[] returnNum = {BigDecimal.ZERO};
AtomicInteger index = new AtomicInteger(0);
consume(t -> {
returnNum[0] = returnNum[0].add(function.apply(t));
index.getAndIncrement();
});
return returnNum[0].divide(new BigDecimal(index.get()), scale, roundingMode);
}
/**
* 截取前面对象数量数据
* List<User> users = Arrays.asList(new User("yaojie", "cz", 10,new BigDecimal(100)), new User("yaojie", "sz", 20,new BigDecimal(300)), new User("yuxin", "bj", 10,new BigDecimal(400)));
* List<User> limit = Seq.of(users).limit(2);
*
* @param limit
* @return
*/
default List<T> limitOver(int limit) {
List<T> returnList = new ArrayList<>();
AtomicInteger index = new AtomicInteger(0);
consume(t -> {
if (limit > index.get()) {
returnList.add(t);
}
index.getAndIncrement();
});
return returnList;
}
/**
* 跳过前面对象数量数据
* List<User> users = Arrays.asList(new User("yaojie", "cz", 10,new BigDecimal(100)), new User("yaojie", "sz", 20,new BigDecimal(300)), new User("yuxin", "bj", 10,new BigDecimal(400)));
* List<User> limit = Seq.of(users).skip(2);
*
* @param skip
* @return
*/
default List<T> skipOver(int skip) {
List<T> returnList = new ArrayList<>();
AtomicInteger index = new AtomicInteger(0);
consume(t -> {
if (skip <= index.get()) {
returnList.add(t);
}
index.getAndIncrement();
});
return returnList;
}
/**
* 截取前面对象数量数据 返回Seq
*
* @param limit
* @return
*/
default Seq<T> limit(int limit) {
AtomicInteger index = new AtomicInteger(0);
return c -> consume(t -> {
if (limit > index.get()) {
c.accept(t);
}
index.getAndIncrement();
});
}
/**
* 跳过前面对象数量数据 返回Seq
*
* @param skip
* @return
*/
default Seq<T> skip(int skip) {
AtomicInteger index = new AtomicInteger(0);
return c -> consume(t -> {
if (skip <= index.get()) {
c.accept(t);
}
index.getAndIncrement();
});
}
/**
* 排序
*
* @param comparator
* @return
*/
default Seq<T> sort(Comparator<? super T> comparator) {
List<T> sortList = new ArrayList<>();
consume(sortList::add);
sortList.sort(comparator);
return sortList::forEach;
}
/**
* 排序
*
* @param comparator
* @return
*/
default List<T> sortOver(Comparator<? super T> comparator) {
List<T> sortList = new ArrayList<>();
consume(sortList::add);
sortList.sort(comparator);
return sortList;
}
/**
* 分流操作
*
* @param biFunction
* @returno
*/
default <E, RR> Seq<RR> zip(Iterable<E> iterable, BiFunction<T, E, RR> biFunction) {
Iterator<E> iterator = iterable.iterator();
return c -> consume(t -> {
if (iterator.hasNext()) {
E next = iterator.next();
RR rr = biFunction.apply(t, next);
c.accept(rr);
}
});
}
/**
* 分流操作
*
* @param biPredicate
* @returno
*/
default <E> Seq<T> filterZip(Iterable<E> iterable, BiPredicate<T, E> biPredicate) {
Iterator<E> iterator = iterable.iterator();
return c -> consume(t -> {
if (iterator.hasNext()) {
E next = iterator.next();
if (biPredicate.test(t, next)) {
c.accept(t);
}
}
});
}
/**
* 分流操作
*
* @param biConsumer
* @returno
*/
default <E> Seq<T> consumeZip(Iterable<E> iterable, BiConsumer<T, E> biConsumer) {
Iterator<E> iterator = iterable.iterator();
return c -> consume(t -> {
if (iterator.hasNext()) {
E next = iterator.next();
biConsumer.accept(t, next);
}
});
}
/**
* 分流操作
*
* @param binaryOperator
* @returno
*/
default Seq<T> operateZip(Iterable<T> iterable, BinaryOperator<T> binaryOperator) {
Iterator<T> iterator = iterable.iterator();
return c -> consume(t -> {
if (iterator.hasNext()) {
T next = iterator.next();
T res = binaryOperator.apply(t, next);
c.accept(res);
}else{
c.accept(t);
}
});
}
}
MapSeq
package com.demodebug.seq;
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
@FunctionalInterface
public interface MapSeq<K, V> {
void consume(BiConsumer<K, V> consumer);
static <K, V> MapSeq<K, V> of(Map<K, V> map) {
return map::forEach;
}
default Map<K, V> toOtherMap(Supplier<Map<K, V>> supplier) {
Map<K, V> kvMap = supplier.get();
consume(kvMap::put);
return kvMap;
}
default List<K> toKeyList() {
List<K> list = new ArrayList<>();
consume((k, v) -> list.add(k));
return list;
}
default List<V> toValueList() {
List<V> list = new ArrayList<>();
consume((k, v) -> list.add(v));
return list;
}
default Set<V> toValueSet() {
Set<V> set = new HashSet<>();
consume((k, v) -> set.add(v));
return set;
}
default <RR> MapSeq<K, RR> dealValue(Function<V, RR> function) {
return bc -> consume((k, v) -> {
RR r = function.apply(v);
bc.accept(k, r);
});
}
default <RR> Map<K, RR> dealValueOver(Function<V, RR> function, Supplier<Map<K, RR>> supplier) {
Map<K, RR> krrMap = supplier.get();
consume((k, v) -> krrMap.put(k, function.apply(v)));
return krrMap;
}
default <RR> Map<K, RR> dealValueOver(BiFunction<K,V, RR> function, Supplier<Map<K, RR>> supplier) {
Map<K, RR> krrMap = supplier.get();
consume((k, v) -> krrMap.put(k, function.apply(k,v)));
return krrMap;
}
default <RR> MapSeq<RR, V> dealKey(Function<K, RR> function) {
return bc -> consume((k, v) -> {
RR r = function.apply(k);
bc.accept(r, v);
});
}
default <RR> Map<RR, V> dealKeyOver(Function<K, RR> function, Supplier<Map<RR, V>> supplier) {
Map<RR, V> krrMap = supplier.get();
consume((k, v) -> krrMap.put(function.apply(k), v));
return krrMap;
}
default <KR, VR> MapSeq<KR, VR> dealKeyAndValue(Function<K, KR> keyFunction, Function<V, VR> valueFunction) {
return bc -> consume((k, v) -> {
KR key = keyFunction.apply(k);
VR value = valueFunction.apply(v);
bc.accept(key, value);
});
}
default <KR, VR> Map<KR, VR> dealKeyAndValueOver(Function<K, KR> keyFunction, Function<V, VR> valueFunction, Supplier<Map<KR, VR>> supplier) {
Map<KR, VR> krVrMap = supplier.get();
consume((k, v) -> {
KR key = keyFunction.apply(k);
VR value = valueFunction.apply(v);
krVrMap.put(key, value);
});
return krVrMap;
}
}
尾
我想说的东西基本上大佬的文章中都有，因此本文的篇幅并没有太多。
如果大家对这个Seq和MapSeq还有其他想法和扩展都可以一起讨论，我现在写的东西也只是最基本的一些API。
如果其中有错的也请大家多多指出，不吝赐教！
再次感谢能够看到这里的JVM。
