Share the streaming programming tools you wrote yourself, which do not involve the company's business, and is very convenient. You don't have to see one-stop Stream code at the business level;
The most commonly used ones should be to turn list, set, and setVFromE;
Just like it if you think it's easy to use
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
/**
* @desc Stream Stream Processing Tool
*/
public class StreamUtils {
/**
* Convert map, get itself, deduplicate, object and key ignore null
* @param source collection
* @param keyFunction Get key function
* @return
*/
public static <T,K> Map<K,T> toMap(Collection<T> source, Function<T,K> keyFunction){
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).filter(obj -> ((obj)))
.collect((keyFunction, (), (v1, v2) -> v2));
}
/**
* Convert map, get itself, deduplicate, object and key ignore null
* @param source collection
* @param keyFunction Get key function
* @param predicate filter conditions
* @return
*/
public static <T,K> Map<K,T> toMap(Collection<T> source, Function<T,K> keyFunction, Predicate<? super T> predict){
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).filter(obj -> ((obj))).filter(predicate)
.collect((keyFunction, (), (v1, v2) -> v2));
}
/**
* Convert map, deduplication, object, key, value ignore null
* @param source collection
* @param keyFunction Get key function
* @param valueFunction Get value function
* @return
*/
public static <T, K, V> Map<K, V> toMap(Collection<T> source, Function<T, K> keyFunction, Function<T, V> valueFunction) {
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).filter(obj -> ((obj)))
.filter(obj -> ((obj)))
.collect((keyFunction, valueFunction, (v1, v2) -> v2));
}
/**
* Convert map, deduplication, object, key, value ignore null
* @param source collection
* @param keyFunction Get key function
* @param valueFunction Get value function
* @param mergeFunction merge method
* @return
*/
public static <T, K, V> Map<K, V> toMap(Collection<T> source, Function<T, K> keyFunction, Function<T, V> valueFunction, BinaryOperator<V> mergeFunction) {
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).filter(obj -> ((obj)))
.filter(obj -> ((obj))).collect(
(keyFunction, valueFunction, mergeFunction));
}
/**
* Convert map, deduplication, use map to reput method
* @param source collection
* @param keyFunction Get key function
* @param valueFunction Get value function
* @return
*/
public static <T, K, V> HashMap<K, V> toMap2(Collection<T> source, Function<T, K> keyFunction, Function<T, V> valueFunction) {
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).filter(obj -> ((obj))).collect(
HashMap<K, V>::new,
(m, v) -> ((v), (v)),
HashMap<K, V>::putAll);
}
public static <T, R> List<R> toList(Collection<T> source, Function<T, R> function) {
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).map(function)
.collect(());
}
public static <T, R> List<R> toListIgnoreNull(Collection<T> source, Function<T, R> function) {
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).map(function).filter(Objects::nonNull)
.collect(());
}
public static <T,R> Set<R> toSet(Collection<T> source, Function<T,R> function) {
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).map(function)
.collect(());
}
public static <T,R> Set<R> toSetIgnoreNull(Collection<T> source, Function<T,R> function) {
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).map(function).filter(Objects::nonNull)
.collect(());
}
public static <T,R> LinkedHashSet<R> toLinkedHashSet(Collection<T> source, Function<T,R> function) {
if ((source)) {
return new LinkedHashSet<R>();
}
return ().filter(Objects::nonNull).map(function).filter(Objects::nonNull)
.collect((LinkedHashSet::new));
}
public static <T,R> LinkedList<R> toLinkedList(Collection<T> source, Function<T,R> function) {
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).map(function).filter(Objects::nonNull)
.collect((LinkedList::new));
}
/**
* Group the collection, encounter duplicate keys, put value into the collection
* @param source
* @param keyFunction
* @param <K>
* @param <V>
* @return
*/
public static <K,V> Map<K,List<V>> groupToMap(Collection<V> source,Function<? super V, ? extends K> keyFunction){
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).filter(s -> ((s))))
.collect((keyFunction));
}
/**
* Group the collection, encounter duplicate keys, put value into the collection
* @param source
* @param keyFunction
* @param <K>
* @param <V>
* @return
*/
public static <K,V> LinkedHashMap<K,List<V>> groupToLinkedHashMap(Collection<V> source,Function<? super V, ? extends K> keyFunction){
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).filter(s -> ((s))))
.collect((keyFunction, LinkedHashMap::new, ()));
}
/**
* Group the collection, encounter duplicate keys, and count the number of duplicate keys
* @param source
* @param keyFunction
* @param <K>
* @param <V>
* @return
*/
public static <K,V> Map<K,Long> groupToMapCount(Collection<V> source,Function<? super V, ? extends K> keyFunction){
if ((source)) {
return ();
}
return ().filter(Objects::nonNull).filter(s -> ((s))))
.collect((keyFunction,()));
}
public static <T> List<T> filter(Collection<T> source,Predicate<? super T> predict){
if ((source)) {
return ();
}
return ().filter(predicate).collect(());
}
public static <T> Set<T> filter(Set<T> set,Predicate<? super T> predicate){
if ((set)) {
return ();
}
return ().filter(predicate).collect((HashSet::new));
}
public static <T> LinkedHashSet<T> filterToSet(Collection<T> source,Predicate<? super T> predict){
if ((source)) {
return ();
}
return ().filter(predicate).collect((LinkedHashSet::new));
}
public static <T> Stream<T> filterStream(Collection<T> source, Predicate<? super T> predicate){
if ((source)) {
return ();
}
return ().filter(predicate);
}
public static <T> Stream<T> filterStream(Collection<T> source, Predicate<? super T> predicate1, Predicate<? super T> predicate2){
if ((source)) {
return ();
}
return ().filter(predicate1).filter(predicate2);
}
public static <T,R> List<R> filterMapList(Collection<T> source, Predicate<? super T> predict, Function<T , R> mapFunction){
if ((source)) {
return ();
}
return ().filter(predicate).map(mapFunction).collect(());
}
public static <T,R> List<R> filterMapList(Collection<T> source, Predicate<? super T> predict1, Predicate<? super T> predict2, Function<T , R> mapFunction){
if ((source)) {
return ();
}
return ().filter(predicate1).filter(predicate2).map(mapFunction).collect(());
}
public static <T,R> Set<R> filterMapSet(Collection<T> source, Predicate<? super T> predict, Function<T , R> mapFunction){
if ((source)) {
return ();
}
return ().filter(predicate).map(mapFunction).collect(());
}
public static <T,R> Set<R> filterMapSet(Collection<T> source, Predicate<? super T> predict1,Predicate<? super T> predict2, Function<T , R> mapFunction){
if ((source)) {
return ();
}
return ().filter(predicate1).filter(predicate2).map(mapFunction).collect(());
}
/**
* Set field value from eList to vList
* @param vList vList v object collection
* @param eList eList eObject Collection
* @param keyFunctionE e object to get key method
* @param keyFunctionV v object get key method
* @param consumer assignment conversion method
*/
public static <V,E,R> void setVFromE(Collection<V> vList, Collection<E> eList, Function<E,R> keyFunctionE,
Function<V,R> keyFunctionV,
BiConsumer<V,E> consumer){
if ((eList)) {
Map<R, E> map = (eList,keyFunctionE);
().filter(Objects::nonNull).forEach(v -> {
E e = ((v));
if ((e)) {
(v,e);
}
});
}
}
/**
* Set the collection item field value from eList to the collection item attribute in vList
* @param vList vList v object collection
* @param eList eList eObject Collection
* @param keyFunctionE e object to get key method
* @param keyFunctionV v object get key method
* @param consumer assignment conversion method
*/
public static <V,E,R> void setVListFromE(Collection<V> vList, Collection<E> eList, Function<E,R> keyFunctionE,
Function<V,R> keyFunctionV,
BiConsumer<V,List<E>> consumer){
if ((eList)) {
Map<R, List<E>> map = (eList,keyFunctionE);
().filter(Objects::nonNull).forEach(v -> {
List<E> e = ((v));
if ((e)) {
(v,e);
}
});
}
}
/**
*Accumulated
* @param source Original collection
* @param valueFunction Get BigDecimal field
* @param <T>
* @return
*/
public static <T> BigDecimal add(Collection<T> source, Function<T,BigDecimal> valueFunction) {
if ((source)) {
return ;
}
return ().filter(Objects::nonNull).map(valueFunction)
.reduce(,BigDecimal::add);
}
/**
* Accumulate and set rounding (retain newScale decimal places)
* @param source Original collection
* @param valueFunction Get BigDecimal field
* @param newScale Decimal places
* @param <T>
* @return
*/
public static <T> BigDecimal addHalfUp(Collection<T> source, Function<T,BigDecimal> valueFunction,int newScale) {
if ((source)) {
return ;
}
return ().filter(Objects::nonNull).map(valueFunction)
.reduce(,BigDecimal::add).setScale(newScale, RoundingMode.HALF_UP);
}
/**
* Accumulate and set rounding (retain 2 decimal places)
* @param source Original collection
* @param valueFunction Get BigDecimal field
* @param <T>
* @return
*/
public static <T> BigDecimal addHalfUp(Collection<T> source, Function<T,BigDecimal> valueFunction) {
return addHalfUp(source, valueFunction,2);
}
public static <T,K> Predicate<T> distinctByKey(Function<? super T, K> keyExtractor) {
Set<K> see = ();
return t -> ((t));
}
public static <T,K> List<T> distinctByKey(List<T> list, Function<? super T, K> keyExtractor) {
return ().filter(distinctByKey(keyExtractor)).collect(());
}
}