Class PZArrayUtil

java.lang.Object

zombie.util.list.PZArrayUtil

public class PZArrayUtil
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	PZArrayUtil.Comparators
static interface	PZArrayUtil.IListConverter1Param<S,E,T1>

Field Summary

Fields

Modifier and Type	Field	Description
static final float[]	emptyFloatArray
static final int[]	emptyIntArray

Constructor Summary

Constructors

Constructor	Description
PZArrayUtil()

Method Summary

Modifier and Type	Method	Description
static float[]	add(float[] array, float val)
static int[]	add(int[] array, int val)
static <E> E[]	add(E[] array, E val)
static <E> void	addAll(ArrayList<E> dest, List<E> src)
static <E> void	addAll(PZArrayList<E> dest, List<E> src)
static int[]	arrayAdd(int[] in_out_a, int[] b)
static <L extends List<E>, E, S> L	arrayConvert(L to, List<S> from, Function<S,E> converter)
static float[]	arrayCopy(float[] to, float[] from, int startIdx, int endIdx)
static int[]	arrayCopy(int[] to, int[] from, int startIdx, int endIdx)
static <E> E[]	arrayCopy(E[] to, List<? extends E> from)
static <E, S extends E> E[]	arrayCopy(E[] to, S[] from)
static <E, S extends E> E[]	arrayCopy(E[] to, S[] from, int startIdx, int endIdx)
static <E, S extends E> E[]	arrayCopy(E[] to, S[] from, int startIdx, int endIdx, Supplier<E> in_allocator, Invokers.Params2.ICallback<E,S> in_copier)
static <L extends List<E>, E> L	arrayCopy(L to, List<? extends E> from)
static <E> E[]	arrayPopulate(E[] arr, Supplier<E> supplier)
static <E> E[]	arrayPopulate(E[] arr, Supplier<E> supplier, int in_startIdx, int in_endIdx)
static float[]	arraySet(float[] arr, float val)
static int[]	arraySet(int[] arr, int val)
static <E> E[]	arraySet(E[] arr, E val)
static String	arrayToString(float[] list)
static String	arrayToString(float[] list, String prefix, String suffix, String delimiter)
static <E> String	arrayToString(E[] list)
static <E> String	arrayToString(E[] list, String prefix, String suffix, String delimiter)
static <E> String	arrayToString(E[] list, Function<E,String> toString, String prefix, String suffix, String delimiter)
static <E> String	arrayToString(Iterable<E> list)
static <E> String	arrayToString(Iterable<E> list, String prefix, String suffix, String delimiter)
static <E> String	arrayToString(Iterable<E> list, Function<E,String> toString)
static <E> String	arrayToString(Iterable<E> list, Function<E,String> toString, String prefix, String suffix, String delimiter)
static float[]	clone(float[] src)
static <E> E[]	clone(E[] src, Supplier<E> in_allocator, Invokers.Params2.ICallback<E,E> in_copier)
static <E> E[]	concat(E[] arrayA, E[] arrayB)
static boolean	contains(float[] arr, int count, float val)
static boolean	contains(int[] arr, int count, int val)
static <E> boolean	contains(E[] collection, int count, E e)
static <E,E1> boolean	contains(E[] collection, E1 containsItem, Predicates.Params1.ICallback<E1,E> predicate)
static <E> boolean	contains(E[] collection, Predicate<E> predicate)
static <E,E1> boolean	contains(Iterable<E> it, E1 containsItem, Predicates.Params1.ICallback<E1,E> predicate)
static <E> boolean	contains(Iterable<E> it, Predicate<E> predicate)
static <E,E1> boolean	contains(Collection<E> it, E1 containsItem, Predicates.Params1.ICallback<E1,E> predicate)
static <E> boolean	contains(Collection<E> it, Predicate<E> predicate)
static <E,E1> boolean	contains(List<E> collection, E1 containsItem, Predicates.Params1.ICallback<E1,E> predicate)
static <E> boolean	contains(List<E> collection, Predicate<E> predicate)
static <E> void	copy(ArrayList<E> target, ArrayList<E> source)
static <E> void	copy(ArrayList<E> target, ArrayList<E> source, ICloner<E> elementCloner)
static <E> E	find(E[] collection, Predicate<E> predicate)
static <E> E	find(Iterable<E> collection, Predicate<E> predicate)
static <E> E	find(List<E> collection, Predicate<E> predicate)
static <E> void	forEach(E[] elements, Consumer<? super E> consumer)
static <E> void	forEach(Iterable<E> it, Consumer<? super E> consumer)
static <E> void	forEach(List<E> list, Consumer<? super E> consumer)
static <E> void	forEachReplace(List<E> list, Function<? super E, ? super E> replacer)
static <E> E	getElementAt(Iterable<E> collection, int index)
static <K,V> V	getOrCreate(HashMap<K,V> map, K key, Supplier<V> allocator)
static float	getOrDefault(float[] list, int i, float defaultVal)
static <E> E	getOrDefault(E[] list, int i, E defaultVal)
static <E> E	getOrDefault(List<E> list, int i)
static <E> E	getOrDefault(List<E> list, int i, E defaultVal)
static <E> int	getSize(Iterable<E> collection)
static int	indexOf(float[] arr, int count, float val)
static int	indexOf(int[] arr, int count, int val)
static <E> int	indexOf(E[] arr, int count, E val)
static <E,E1> int	indexOf(E[] collection, E1 containsItem, Predicates.Params1.ICallback<E1,E> predicate)
static <E> int	indexOf(E[] collection, Predicate<E> predicate)
static <E,E1> int	indexOf(List<E> collection, E1 containsItem, Predicates.Params1.ICallback<E1,E> predicate)
static <E> int	indexOf(List<E> collection, Predicate<E> predicate)
static void	insertAt(float[] arr, int insertAt, float val)
static void	insertAt(int[] arr, int insertAt, int val)
static boolean	isNullOrEmpty(float[] array)
static boolean	isNullOrEmpty(int[] array)
static <E> boolean	isNullOrEmpty(E[] array)
static <E> boolean	isNullOrEmpty(Iterable<E> it)
static <E> boolean	isNullOrEmpty(List<E> list)
static <E,S> Iterable<E>	itConvert(Iterable<S> source, Function<S,E> converter)
static int	lengthOf(float[] in_array)
static int	lengthOf(int[] in_array)
static <E> int	lengthOf(E[] in_array)
static <E,S> List<E>	listConvert(List<S> source, Function<S,E> converter)
static <E,S> List<E>	listConvert(List<S> source, List<E> dest, Function<S,E> converter)
static <E,S,T1> List<E>	listConvert(List<S> source, List<E> dest, T1 v1, PZArrayUtil.IListConverter1Param<S,E,T1> converter)
static <E> E[]	newInstance(Class<?> componentType, int length)
static <E> E[]	newInstance(Class<?> componentType, int length, Supplier<E> allocator)
static <E> E[]	newInstance(Class<?> componentType, E[] reusableArray, int newLength)
static <E> E[]	newInstance(Class<?> componentType, E[] reusableArray, int newLength, boolean growOnly)
static <E> E[]	newInstance(Class<?> componentType, E[] reusableArray, int newLength, boolean growOnly, Supplier<E> newAllocator)
static <E> E[]	newInstance(Class<?> componentType, E[] reusableArray, int newLength, Supplier<E> newAllocator)
static <E> E	pickRandom(E[] collection)
static <E> E	pickRandom(E[] collection, RandInterface rnd)
static <E> E	pickRandom(Iterable<E> collection)
static <E> E	pickRandom(Iterable<E> collection, RandInterface rnd)
static <E> E	pickRandom(Collection<E> collection)
static <E> E	pickRandom(Collection<E> collection, RandInterface rnd)
static <E> E	pickRandom(List<E> collection)
static <E> E	pickRandom(List<E> collection, RandInterface rnd)
static <E> boolean	sequenceEqual(E[] a, List<? extends E> b)
static <E> boolean	sequenceEqual(E[] a, List<? extends E> b, Comparator<E> comparator)
static <E> boolean	sequenceEqual(List<? extends E> a, List<? extends E> b)
static <E> boolean	sequenceEqual(List<? extends E> a, List<? extends E> b, Comparator<E> comparator)
static <E> E[]	shallowClone(E[] src)
static <E> void	sort(Stack<E> stack, Comparator<E> comparator)
static <E> E[]	toArray(List<E> list)

Methods inherited from class Object

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

Field Details

emptyIntArray

public static final int[] emptyIntArray

emptyFloatArray

public static final float[] emptyFloatArray

Constructor Details

PZArrayUtil

public PZArrayUtil()

Method Details

pickRandom

public static <E> E pickRandom(E[] collection,
 RandInterface rnd)

pickRandom

public static <E> E pickRandom(List<E> collection,
 RandInterface rnd)

pickRandom

public static <E> E pickRandom(Collection<E> collection,
 RandInterface rnd)

pickRandom

public static <E> E pickRandom(Iterable<E> collection,
 RandInterface rnd)

pickRandom

public static <E> E pickRandom(E[] collection)

pickRandom

public static <E> E pickRandom(List<E> collection)

pickRandom

public static <E> E pickRandom(Collection<E> collection)

pickRandom

public static <E> E pickRandom(Iterable<E> collection)

getSize

public static <E> int getSize(Iterable<E> collection)

getElementAt

public static <E> E getElementAt(Iterable<E> collection,
 int index)
                          throws ArrayIndexOutOfBoundsException

Throws:

ArrayIndexOutOfBoundsException

copy

public static <E> void copy(ArrayList<E> target,
 ArrayList<E> source)

copy

public static <E> void copy(ArrayList<E> target,
 ArrayList<E> source,
 ICloner<E> elementCloner)

indexOf

public static <E,E1> int indexOf(E[] collection,
 E1 containsItem,
 Predicates.Params1.ICallback<E1,E> predicate)

indexOf

public static <E,E1> int indexOf(List<E> collection,
 E1 containsItem,
 Predicates.Params1.ICallback<E1,E> predicate)

indexOf

public static <E> int indexOf(E[] collection,
 Predicate<E> predicate)

indexOf

public static <E> int indexOf(List<E> collection,
 Predicate<E> predicate)

contains

public static <E> boolean contains(E[] collection,
 int count,
 E e)

contains

public static <E,E1> boolean contains(E[] collection,
 E1 containsItem,
 Predicates.Params1.ICallback<E1,E> predicate)

contains

public static <E,E1> boolean contains(List<E> collection,
 E1 containsItem,
 Predicates.Params1.ICallback<E1,E> predicate)

contains

public static <E,E1> boolean contains(Collection<E> it,
 E1 containsItem,
 Predicates.Params1.ICallback<E1,E> predicate)

contains

public static <E,E1> boolean contains(Iterable<E> it,
 E1 containsItem,
 Predicates.Params1.ICallback<E1,E> predicate)

contains

public static <E> boolean contains(E[] collection,
 Predicate<E> predicate)

contains

public static <E> boolean contains(List<E> collection,
 Predicate<E> predicate)

contains

public static <E> boolean contains(Collection<E> it,
 Predicate<E> predicate)

contains

public static <E> boolean contains(Iterable<E> it,
 Predicate<E> predicate)

find

public static <E> E find(E[] collection,
 Predicate<E> predicate)

find

public static <E> E find(List<E> collection,
 Predicate<E> predicate)

find

public static <E> E find(Iterable<E> collection,
 Predicate<E> predicate)

listConvert

public static <E,S> List<E> listConvert(List<S> source,
 Function<S,E> converter)

itConvert

public static <E,S> Iterable<E> itConvert(Iterable<S> source,
 Function<S,E> converter)

listConvert

public static <E,S> List<E> listConvert(List<S> source,
 List<E> dest,
 Function<S,E> converter)

lengthOf

public static <E> int lengthOf(E[] in_array)

lengthOf

public static int lengthOf(int[] in_array)

lengthOf

public static int lengthOf(float[] in_array)

listConvert

public static <E,S,T1> List<E> listConvert(List<S> source,
 List<E> dest,
 T1 v1,
 PZArrayUtil.IListConverter1Param<S,E,T1> converter)

arrayToString

public static String arrayToString(float[] list)

arrayToString

public static String arrayToString(float[] list,
 String prefix,
 String suffix,
 String delimiter)

arrayToString

public static <E> String arrayToString(E[] list)

arrayToString

public static <E> String arrayToString(E[] list,
 String prefix,
 String suffix,
 String delimiter)

arrayToString

public static <E> String arrayToString(E[] list,
 Function<E,String> toString,
 String prefix,
 String suffix,
 String delimiter)

arrayToString

public static <E> String arrayToString(Iterable<E> list,
 Function<E,String> toString)

arrayToString

public static <E> String arrayToString(Iterable<E> list)

arrayToString

public static <E> String arrayToString(Iterable<E> list,
 String prefix,
 String suffix,
 String delimiter)

arrayToString

public static <E> String arrayToString(Iterable<E> list,
 Function<E,String> toString,
 String prefix,
 String suffix,
 String delimiter)

newInstance

public static <E> E[] newInstance(Class<?> componentType,
 int length)

newInstance

public static <E> E[] newInstance(Class<?> componentType,
 int length,
 Supplier<E> allocator)

newInstance

public static <E> E[] newInstance(Class<?> componentType,
 E[] reusableArray,
 int newLength)

newInstance

public static <E> E[] newInstance(Class<?> componentType,
 E[] reusableArray,
 int newLength,
 boolean growOnly)

newInstance

public static <E> E[] newInstance(Class<?> componentType,
 E[] reusableArray,
 int newLength,
 Supplier<E> newAllocator)

newInstance

public static <E> E[] newInstance(Class<?> componentType,
 E[] reusableArray,
 int newLength,
 boolean growOnly,
 Supplier<E> newAllocator)

add

public static float[] add(float[] array,
 float val)

add

public static int[] add(int[] array,
 int val)

add

public static <E> E[] add(E[] array,
 E val)

concat

public static <E> E[] concat(E[] arrayA,
 E[] arrayB)

arrayCopy

public static <E, S extends E> E[] arrayCopy(E[] to,
 S[] from,
 int startIdx,
 int endIdx)

arrayCopy

public static <E, S extends E> E[] arrayCopy(E[] to,
 S[] from,
 int startIdx,
 int endIdx,
 Supplier<E> in_allocator,
 Invokers.Params2.ICallback<E,S> in_copier)

arrayCopy

public static float[] arrayCopy(float[] to,
 float[] from,
 int startIdx,
 int endIdx)

arrayCopy

public static int[] arrayCopy(int[] to,
 int[] from,
 int startIdx,
 int endIdx)

arrayCopy

public static <L extends List<E>, E> L arrayCopy(L to,
 List<? extends E> from)

arrayCopy

public static <E> E[] arrayCopy(E[] to,
 List<? extends E> from)

arrayCopy

public static <E, S extends E> E[] arrayCopy(E[] to,
 S[] from)

arrayConvert

public static <L extends List<E>, E, S> L arrayConvert(L to,
 List<S> from,
 Function<S,E> converter)

clone

public static float[] clone(float[] src)

clone

public static <E> E[] clone(E[] src,
 Supplier<E> in_allocator,
 Invokers.Params2.ICallback<E,E> in_copier)

shallowClone

public static <E> E[] shallowClone(E[] src)

isNullOrEmpty

public static <E> boolean isNullOrEmpty(E[] array)

isNullOrEmpty

public static boolean isNullOrEmpty(int[] array)

isNullOrEmpty

public static boolean isNullOrEmpty(float[] array)

isNullOrEmpty

public static <E> boolean isNullOrEmpty(List<E> list)

isNullOrEmpty

public static <E> boolean isNullOrEmpty(Iterable<E> it)

getOrDefault

public static <E> E getOrDefault(List<E> list,
 int i)

getOrDefault

public static <E> E getOrDefault(List<E> list,
 int i,
 E defaultVal)

getOrDefault

public static <E> E getOrDefault(E[] list,
 int i,
 E defaultVal)

getOrDefault

public static float getOrDefault(float[] list,
 int i,
 float defaultVal)

arraySet

public static int[] arraySet(int[] arr,
 int val)

arraySet

public static float[] arraySet(float[] arr,
 float val)

arraySet

public static <E> E[] arraySet(E[] arr,
 E val)

arrayPopulate

public static <E> E[] arrayPopulate(E[] arr,
 Supplier<E> supplier)

arrayPopulate

public static <E> E[] arrayPopulate(E[] arr,
 Supplier<E> supplier,
 int in_startIdx,
 int in_endIdx)

insertAt

public static void insertAt(int[] arr,
 int insertAt,
 int val)

insertAt

public static void insertAt(float[] arr,
 int insertAt,
 float val)

toArray

public static <E> E[] toArray(List<E> list)

indexOf

public static <E> int indexOf(E[] arr,
 int count,
 E val)

indexOf

public static int indexOf(float[] arr,
 int count,
 float val)

contains

public static boolean contains(float[] arr,
 int count,
 float val)

indexOf

public static int indexOf(int[] arr,
 int count,
 int val)

contains

public static boolean contains(int[] arr,
 int count,
 int val)

forEach

public static <E> void forEach(List<E> list,
 Consumer<? super E> consumer)

forEach

public static <E> void forEach(Iterable<E> it,
 Consumer<? super E> consumer)

forEach

public static <E> void forEach(E[] elements,
 Consumer<? super E> consumer)

forEachReplace

public static <E> void forEachReplace(List<E> list,
 Function<? super E, ? super E> replacer)

getOrCreate

public static <K,V> V getOrCreate(HashMap<K,V> map,
 K key,
 Supplier<V> allocator)

sort

public static <E> void sort(Stack<E> stack,
 Comparator<E> comparator)

sequenceEqual

public static <E> boolean sequenceEqual(E[] a,
 List<? extends E> b)

sequenceEqual

public static <E> boolean sequenceEqual(E[] a,
 List<? extends E> b,
 Comparator<E> comparator)

sequenceEqual

public static <E> boolean sequenceEqual(List<? extends E> a,
 List<? extends E> b)

sequenceEqual

public static <E> boolean sequenceEqual(List<? extends E> a,
 List<? extends E> b,
 Comparator<E> comparator)

arrayAdd

public static int[] arrayAdd(int[] in_out_a,
 int[] b)

addAll

public static <E> void addAll(ArrayList<E> dest,
 List<E> src)

addAll

public static <E> void addAll(PZArrayList<E> dest,
 List<E> src)