org.apache.hadoop.hbase.util

Class CollectionUtils

java.lang.Object

org.apache.hadoop.hbase.util.CollectionUtils

@InterfaceAudience.Private
public class CollectionUtils
extends Object

Utility methods for dealing with Collections, including treating null collections as empty.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	CollectionUtils.IOExceptionSupplier<V> A supplier that throws IOException when get.

Field Summary

Fields

Modifier and Type	Field and Description
private static List<Object>	EMPTY_LIST

Constructor Summary

Constructors

Constructor and Description
CollectionUtils()

Method Summary

Modifier and Type	Method and Description
static <K,V> V	computeIfAbsent(ConcurrentMap<K,V> map, K key, Supplier<V> supplier) In HBASE-16648 we found that ConcurrentHashMap.get is much faster than computeIfAbsent if the value already exists.
static <K,V> V	computeIfAbsent(ConcurrentMap<K,V> map, K key, Supplier<V> supplier, Runnable actionIfAbsent)
static <K,V> V	computeIfAbsentEx(ConcurrentMap<K,V> map, K key, CollectionUtils.IOExceptionSupplier<V> supplier) In HBASE-16648 we found that ConcurrentHashMap.get is much faster than computeIfAbsent if the value already exists.
static <T> T	getFirst(Collection<T> collection) first/last
static <T> T	getLast(List<T> list)
static int	getLastIndex(List<?> list)
static <T> boolean	isEmpty(Collection<T> collection) empty
static boolean	isLastIndex(List<?> list, int index)
static <T> boolean	notEmpty(Collection<T> collection)
static <T> Collection<T>	nullSafe(Collection<T> in)
static <A,B> boolean	nullSafeSameSize(Collection<A> a, Collection<B> b)
static <T> int	nullSafeSize(Collection<T> collection) size

Methods inherited from class java.lang.Object

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

Field Detail

EMPTY_LIST

private static final List<Object> EMPTY_LIST

Constructor Detail

CollectionUtils

public CollectionUtils()

Method Detail

nullSafe

public static <T> Collection<T> nullSafe(Collection<T> in)

nullSafeSize

public static <T> int nullSafeSize(Collection<T> collection)

size

nullSafeSameSize

public static <A,B> boolean nullSafeSameSize(Collection<A> a,
                                             Collection<B> b)

isEmpty

public static <T> boolean isEmpty(Collection<T> collection)

empty

notEmpty

public static <T> boolean notEmpty(Collection<T> collection)

getFirst

public static <T> T getFirst(Collection<T> collection)

first/last

getLastIndex

public static int getLastIndex(List<?> list)

Parameters:

list - any list

Returns:

-1 if list is empty, otherwise the max index

isLastIndex

public static boolean isLastIndex(List<?> list,
                                  int index)

Parameters:

list -

index - the index in question

Returns:

true if it is the last index or if list is empty and -1 is passed for the index param

getLast

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

computeIfAbsent

public static <K,V> V computeIfAbsent(ConcurrentMap<K,V> map,
                                      K key,
                                      Supplier<V> supplier)

In HBASE-16648 we found that ConcurrentHashMap.get is much faster than computeIfAbsent if the value already exists. Notice that the implementation does not guarantee that the supplier will only be executed once.

computeIfAbsentEx

public static <K,V> V computeIfAbsentEx(ConcurrentMap<K,V> map,
                                        K key,
                                        CollectionUtils.IOExceptionSupplier<V> supplier)
                                 throws IOException

In HBASE-16648 we found that ConcurrentHashMap.get is much faster than computeIfAbsent if the value already exists. So here we copy the implementation of ConcurrentMap.computeIfAbsent(Object, java.util.function.Function). It uses get and putIfAbsent to implement computeIfAbsent. And notice that the implementation does not guarantee that the supplier will only be executed once.

Throws:

IOException

computeIfAbsent

public static <K,V> V computeIfAbsent(ConcurrentMap<K,V> map,
                                      K key,
                                      Supplier<V> supplier,
                                      Runnable actionIfAbsent)