org.apache.hudi.common.util

Class CollectionUtils

java.lang.Object

org.apache.hudi.common.util.CollectionUtils

public class CollectionUtils
extends Object

Utils for Java Collection.

Constructor Summary

Constructors

Constructor and Description
CollectionUtils()

Method Summary

Modifier and Type	Method and Description
static <T> T[]	append(T[] array, T elem) Combines provided array and an element into a new array
static <E> List<List<E>>	batches(List<E> list, int batchSize)
static <E> Stream<List<E>>	batchesAsStream(List<E> list, int batchSize)
static <E> List<E>	combine(List<E> one, List<E> another) Combines provided Lists into one, returning new instance of ArrayList
static <K,V> HashMap<K,V>	combine(Map<K,V> one, Map<K,V> another) Combines provided Maps into one, returning new instance of HashMap.
static <K,V> HashMap<K,V>	combine(Map<K,V> one, Map<K,V> another, BiFunction<V,V,V> merge) Combines provided Maps into one, returning new instance of HashMap.
static <T> T[]	combine(T[] one, T[] another) Combines provided arrays into one
static Properties	copy(Properties props) Makes a copy of provided Properties object
static <T> List<T>	createImmutableList(List<T> list)
static <T> List<T>	createImmutableList(T... elements)
static <K,V> Map<K,V>	createImmutableMap(Map<K,V> map)
static <K,V> Map<K,V>	createImmutableMap(Pair<K,V>... elements)
static <T> Set<T>	createImmutableSet(Set<T> set)
static <T> Set<T>	createImmutableSet(T... elements)
static <T> Set<T>	createSet(T... elements)
static <E> List<E>	diff(Collection<E> one, Collection<E> another) Returns difference b/w one List of elements and another NOTE: This is less optimal counterpart to diff(Collection, Collection), accepting List as a holding collection to support duplicate elements use-cases
static <E> Set<E>	diffSet(Collection<E> one, Set<E> another) Returns difference b/w one Collection of elements and another The elements in collection one are also duplicated and returned as a Set.
static boolean	elementsEqual(Iterator<?> iterator1, Iterator<?> iterator2) Determines whether two iterators contain equal elements in the same order.
static Properties	emptyProps() Returns an empty Properties instance.
static boolean	isNullOrEmpty(Collection<?> c)
static boolean	isNullOrEmpty(Map<?,?> m)
static boolean	nonEmpty(Collection<?> c)
static <T,U> U	reduce(Collection<T> c, U identity, BiFunction<U,T,U> reducer) Reduces provided Collection using provided reducer applied to every element of the collection like following reduce(reduce(reduce(identity, e1), e2), ...)
static <T> T	tail(T[] ts) Returns last element of the array of T
static <T> Stream<T>	toStream(Iterator<T> iterator) Collects provided Iterator to a Stream
static <K,V> Map<K,V>	zipToMap(List<K> keys, List<V> values) Zip two lists into a Map.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CollectionUtils

public CollectionUtils()

Method Detail

emptyProps

public static Properties emptyProps()

Returns an empty Properties instance. The props instance is a singleton, it should not be modified in any case.

isNullOrEmpty

public static boolean isNullOrEmpty(Collection<?> c)

isNullOrEmpty

public static boolean isNullOrEmpty(Map<?,?> m)

nonEmpty

public static boolean nonEmpty(Collection<?> c)

reduce

public static <T,U> U reduce(Collection<T> c,
                             U identity,
                             BiFunction<U,T,U> reducer)

Reduces provided Collection using provided reducer applied to every element of the collection like following reduce(reduce(reduce(identity, e1), e2), ...)

Parameters:

c - target collection to be reduced

identity - element for reducing to start from

reducer - actual reducing operator

Returns:

result of the reduction of the collection using reducing operator

copy

public static Properties copy(Properties props)

Makes a copy of provided Properties object

tail

public static <T> T tail(T[] ts)

Returns last element of the array of T

toStream

public static <T> Stream<T> toStream(Iterator<T> iterator)

Collects provided Iterator to a Stream

combine

public static <T> T[] combine(T[] one,
                              T[] another)

Combines provided arrays into one

append

public static <T> T[] append(T[] array,
                             T elem)

Combines provided array and an element into a new array

combine

public static <E> List<E> combine(List<E> one,
                                  List<E> another)

Combines provided Lists into one, returning new instance of ArrayList

combine

public static <K,V> HashMap<K,V> combine(Map<K,V> one,
                                         Map<K,V> another)

Combines provided Maps into one, returning new instance of HashMap. NOTE: That values associated with overlapping keys from the second map, will override values from the first one

combine

public static <K,V> HashMap<K,V> combine(Map<K,V> one,
                                         Map<K,V> another,
                                         BiFunction<V,V,V> merge)

Combines provided Maps into one, returning new instance of HashMap. NOTE: That values associated with overlapping keys from the second map, will override values from the first one

zipToMap

public static <K,V> Map<K,V> zipToMap(List<K> keys,
                                      List<V> values)

Zip two lists into a Map. Will throw Exception if the size is different between these two lists.

diffSet

public static <E> Set<E> diffSet(Collection<E> one,
                                 Set<E> another)

Returns difference b/w one Collection of elements and another The elements in collection one are also duplicated and returned as a Set.

diff

public static <E> List<E> diff(Collection<E> one,
                               Collection<E> another)

Returns difference b/w one List of elements and another NOTE: This is less optimal counterpart to diff(Collection, Collection), accepting List as a holding collection to support duplicate elements use-cases

batchesAsStream

public static <E> Stream<List<E>> batchesAsStream(List<E> list,
                                                  int batchSize)

batches

public static <E> List<List<E>> batches(List<E> list,
                                        int batchSize)

elementsEqual

public static boolean elementsEqual(Iterator<?> iterator1,
                                    Iterator<?> iterator2)

Determines whether two iterators contain equal elements in the same order. More specifically, this method returns true if iterator1 and iterator2 contain the same number of elements and every element of iterator1 is equal to the corresponding element of iterator2.

Note that this will modify the supplied iterators, since they will have been advanced some number of elements forward.

createImmutableList

@SafeVarargs
public static <T> List<T> createImmutableList(T... elements)

createImmutableList

public static <T> List<T> createImmutableList(List<T> list)

createImmutableMap

@SafeVarargs
public static <K,V> Map<K,V> createImmutableMap(Pair<K,V>... elements)

createImmutableMap

public static <K,V> Map<K,V> createImmutableMap(Map<K,V> map)

createSet

@SafeVarargs
public static <T> Set<T> createSet(T... elements)

createImmutableSet

@SafeVarargs
public static <T> Set<T> createImmutableSet(T... elements)

createImmutableSet

public static <T> Set<T> createImmutableSet(Set<T> set)