com.github.paganini2008.devtools

类 ArrayUtils

java.lang.Object

com.github.paganini2008.devtools.ArrayUtils

public abstract class ArrayUtils
extends Object

ArrayUtils

版本:

1.0

作者:

Fred Feng

字段概要

字段

限定符和类型	字段和说明
static Object[]	EMPTY_OBJECT_ARRAY
static int	INDEX_NOT_FOUND
static int	MERGE_SORT_THRESHOLD

构造器概要

构造器

构造器和说明
ArrayUtils()

方法概要

限定符和类型	方法和说明
static <T> T[]	add(T[] array, T a)
static <T extends Comparable<T>> void	asc(T[] array)
static <T> T[]	concat(T[] left, T[] right)
static boolean	contains(char[] a, int b)
static boolean	contains(double[] a, double b)
static boolean	contains(float[] a, float b)
static boolean	contains(int[] a, int b)
static boolean	contains(long[] a, long b)
static boolean	contains(Object[] a, Object b)
static boolean	contains(short[] a, short b)
static boolean	containsAll(Object[] left, Object[] right)
static <T> T[]	copy(T[] array)
static <T> T[]	copy(T[] array, int startIndex)
static <T> T[]	copy(T[] array, int startIndex, int length)
static <T> T[]	copy(T[] array, int startIndex, int length, T defaultValue)
static <T> T[]	create(Class<?> type, int length)
static <T> T[][]	create(Class<?> type, int row, int column)
static <T> T[][]	create(Class<?> type, int row, int column, T defaultValue)
static <T> T[]	create(Class<?> type, int length, T defaultValue)
static boolean	deepEquals(Object[] left, Object[] right)
static int	deepHashCode(Object[] args)
static <T extends Comparable<T>> void	desc(T[] array)
static Object[][]	divide(Object[] src, int n)
static <T> T[]	ensureCapacity(T[] array, int index)
static <T> T[]	expandCapacity(T[] array)
static <T> T[]	expandCapacity(T[] array, int size)
static int	getLength(Object[] array)
private static <T> void	hardCopy(T[] src, int srcFrom, T[] dest, int destFrom, int length)
static int	indexOf(char[] a, int b)
static int	indexOf(char[] a, int b, int start, int end)
static int	indexOf(double[] a, double b)
static int	indexOf(double[] a, double b, int start, int end)
static int	indexOf(float[] a, float b)
static int	indexOf(float[] a, float b, int start, int end)
static int	indexOf(int[] a, int b)
static int	indexOf(int[] a, int b, int start, int end)
static int	indexOf(long[] a, long b)
static int	indexOf(long[] a, long b, int start, int end)
static int	indexOf(Object[] a, Object b)
static int	indexOf(Object[] a, Object b, int start, int end)
static int	indexOf(short[] a, short b)
static int	indexOf(short[] a, short b, int start)
static int	indexOf(short[] a, short b, int start, int end)
static <T> T[]	intersect(T[] a, T[] b)
static boolean	isEmpty(Object[] args)
static boolean	isNotEmpty(Object[] args)
static boolean	isNotSameLength(Object[] left, Object[] right)
static boolean	isSameLength(Object[] left, Object[] right)
static boolean	isSubarray(Object[] left, Object[] right)
static String	join(Object[] array)
static String	join(Object[] left, Object[] right, String delimiter)
static String	join(Object[] left, Object[] right, String conjunction, String delimiter)
static String	join(Object[] array, String delimiter)
static int	lastIndexOf(Object[] a, Object b)
static int	lastIndexOf(Object[] a, Object b, int start)
static void	leftScroll(Object[] src, int n)
static void	main(String[] args)
private static <T> void	mergeSort(T[] src, T[] dest, int low, int high, Comparator<T> c)
static <T> T[]	minus(T[] a, T[] b)
static boolean	notContains(char[] a, int b)
static boolean	notContains(double[] a, double b)
static boolean	notContains(float[] a, float b)
static boolean	notContains(int[] a, int b)
static boolean	notContains(long[] a, long b)
static boolean	notContains(Object[] a, Object b)
static boolean	notContains(short[] a, short b)
static <T> T[]	remove(T[] array, T a)
static <T> T[]	removeAt(T[] array, int index)
static void	reverse(Object[] src)
static void	rightScroll(Object[] src, int n)
private static void	rightScroll(Object[] src, int n, int m)
static boolean	same(Object[] array)
static void	shuffle(Object[] src)
static void	shuffle(Object[] src, Random rn)
static Object[][]	slice(Object[] src, int n)
static <T> void	sort(T[] array, Comparator<T> c)
private static <T> void	sort(T[] dest, int low, int high, Comparator<T> c)
static void	swap(Object[] x, int a, int b)
static String	toString(Object[] array)
static String[]	toStringArray(Object[] args)
static <T> T[]	union(T[] a, T[] b)
static <T> T[]	unionAll(T[] a, T[] b)

从类继承的方法 java.lang.Object

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

字段详细资料

EMPTY_OBJECT_ARRAY

public static final Object[] EMPTY_OBJECT_ARRAY

INDEX_NOT_FOUND

public static final int INDEX_NOT_FOUND

另请参阅:

常量字段值

MERGE_SORT_THRESHOLD

public static final int MERGE_SORT_THRESHOLD

另请参阅:

常量字段值

构造器详细资料

ArrayUtils

public ArrayUtils()

方法详细资料

isNotSameLength

public static boolean isNotSameLength(Object[] left,
                                      Object[] right)

isSameLength

public static boolean isSameLength(Object[] left,
                                   Object[] right)

getLength

public static int getLength(Object[] array)

reverse

public static void reverse(Object[] src)

swap

public static void swap(Object[] x,
                        int a,
                        int b)

unionAll

public static <T> T[] unionAll(T[] a,
                               T[] b)

union

public static <T> T[] union(T[] a,
                            T[] b)

minus

public static <T> T[] minus(T[] a,
                            T[] b)

intersect

public static <T> T[] intersect(T[] a,
                                T[] b)

notContains

public static boolean notContains(Object[] a,
                                  Object b)

contains

public static boolean contains(Object[] a,
                               Object b)

indexOf

public static int indexOf(Object[] a,
                          Object b)

indexOf

public static int indexOf(Object[] a,
                          Object b,
                          int start,
                          int end)

lastIndexOf

public static int lastIndexOf(Object[] a,
                              Object b)

lastIndexOf

public static int lastIndexOf(Object[] a,
                              Object b,
                              int start)

main

public static void main(String[] args)

ensureCapacity

public static <T> T[] ensureCapacity(T[] array,
                                     int index)

expandCapacity

public static <T> T[] expandCapacity(T[] array)

expandCapacity

public static <T> T[] expandCapacity(T[] array,
                                     int size)

isEmpty

public static boolean isEmpty(Object[] args)

isNotEmpty

public static boolean isNotEmpty(Object[] args)

asc

public static <T extends Comparable<T>> void asc(T[] array)

desc

public static <T extends Comparable<T>> void desc(T[] array)

sort

public static <T> void sort(T[] array,
                            Comparator<T> c)

mergeSort

private static <T> void mergeSort(T[] src,
                                  T[] dest,
                                  int low,
                                  int high,
                                  Comparator<T> c)

sort

private static <T> void sort(T[] dest,
                             int low,
                             int high,
                             Comparator<T> c)

create

public static <T> T[][] create(Class<?> type,
                               int row,
                               int column)

create

public static <T> T[][] create(Class<?> type,
                               int row,
                               int column,
                               T defaultValue)

create

public static <T> T[] create(Class<?> type,
                             int length)

create

public static <T> T[] create(Class<?> type,
                             int length,
                             T defaultValue)

concat

public static <T> T[] concat(T[] left,
                             T[] right)

add

public static <T> T[] add(T[] array,
                          T a)

remove

public static <T> T[] remove(T[] array,
                             T a)

removeAt

public static <T> T[] removeAt(T[] array,
                               int index)

copy

public static <T> T[] copy(T[] array)

copy

public static <T> T[] copy(T[] array,
                           int startIndex)

copy

public static <T> T[] copy(T[] array,
                           int startIndex,
                           int length)

copy

public static <T> T[] copy(T[] array,
                           int startIndex,
                           int length,
                           T defaultValue)

hardCopy

private static <T> void hardCopy(T[] src,
                                 int srcFrom,
                                 T[] dest,
                                 int destFrom,
                                 int length)

toString

public static String toString(Object[] array)

join

public static String join(Object[] array)

join

public static String join(Object[] array,
                          String delimiter)

join

public static String join(Object[] left,
                          Object[] right,
                          String delimiter)

join

public static String join(Object[] left,
                          Object[] right,
                          String conjunction,
                          String delimiter)

deepEquals

public static boolean deepEquals(Object[] left,
                                 Object[] right)

deepHashCode

public static int deepHashCode(Object[] args)

toStringArray

public static String[] toStringArray(Object[] args)

isSubarray

public static boolean isSubarray(Object[] left,
                                 Object[] right)

containsAll

public static boolean containsAll(Object[] left,
                                  Object[] right)

same

public static boolean same(Object[] array)

leftScroll

public static void leftScroll(Object[] src,
                              int n)

rightScroll

public static void rightScroll(Object[] src,
                               int n)

rightScroll

private static void rightScroll(Object[] src,
                                int n,
                                int m)

slice

public static Object[][] slice(Object[] src,
                               int n)

divide

public static Object[][] divide(Object[] src,
                                int n)

shuffle

public static void shuffle(Object[] src)

shuffle

public static void shuffle(Object[] src,
                           Random rn)

notContains

public static boolean notContains(char[] a,
                                  int b)

contains

public static boolean contains(char[] a,
                               int b)

indexOf

public static int indexOf(char[] a,
                          int b)

indexOf

public static int indexOf(char[] a,
                          int b,
                          int start,
                          int end)

notContains

public static boolean notContains(double[] a,
                                  double b)

contains

public static boolean contains(double[] a,
                               double b)

indexOf

public static int indexOf(double[] a,
                          double b)

indexOf

public static int indexOf(double[] a,
                          double b,
                          int start,
                          int end)

notContains

public static boolean notContains(long[] a,
                                  long b)

contains

public static boolean contains(long[] a,
                               long b)

indexOf

public static int indexOf(long[] a,
                          long b)

indexOf

public static int indexOf(long[] a,
                          long b,
                          int start,
                          int end)

notContains

public static boolean notContains(float[] a,
                                  float b)

contains

public static boolean contains(float[] a,
                               float b)

indexOf

public static int indexOf(float[] a,
                          float b)

indexOf

public static int indexOf(float[] a,
                          float b,
                          int start,
                          int end)

notContains

public static boolean notContains(int[] a,
                                  int b)

contains

public static boolean contains(int[] a,
                               int b)

indexOf

public static int indexOf(int[] a,
                          int b)

indexOf

public static int indexOf(int[] a,
                          int b,
                          int start,
                          int end)

notContains

public static boolean notContains(short[] a,
                                  short b)

contains

public static boolean contains(short[] a,
                               short b)

indexOf

public static int indexOf(short[] a,
                          short b)

indexOf

public static int indexOf(short[] a,
                          short b,
                          int start)

indexOf

public static int indexOf(short[] a,
                          short b,
                          int start,
                          int end)