yangyakun921/MoGoEagleEye
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
wangcongtao
2019-12-23 15:08:04 +08:00
commit 80cc1248b2
210 changed files with 17746 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

464
foudations/mogo-utils/src/main/java/com/mogo/utils/ArrayUtils.java Normal file
View File

@@ -0,0 +1,464 @@
package com.mogo.utils;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.RandomAccess;
@SuppressWarnings({ "unchecked" })
public class ArrayUtils {
/**
* 加强版的asList会检查传入是否为null，以保证不会抛出异常 并且返回的arraylist改为{@link ArrayList}
*
* @param <T>
* @param array
* @return
*/
public static <T> ArrayList<T> asList( T... array) {
if (array == null) {
return new ArrayList<T>(0);
}
ArrayList<T> list = new ArrayList<T>( Arrays.asList(array));
return list;
}
public static <T> List<T> asReadOnlyList( T... array) {
return new ReadOnlyArrayList<T>(array);
}
public static boolean contains( Object[] array, Object value) {
if (array == null) {
return false;
}
for ( Object object : array) {
if (object == null) {
if (value == null) {
return true;
}
} else if (object.equals(value)) {
return true;
}
}
return false;
}
/**
* 在已排序数组中查询是否存在某值
*
* @param array
* @param value
* @return
*/
public static boolean contains(int[] array, int value) {
return Arrays.binarySearch(array, value) >= 0 ? true : false;
}
/**
* 从jdk1.6拷贝过来，android中没有这些方法。<br />
* Copies the specified array, truncating or padding with <tt>false</tt> (if necessary) so the copy has the
* specified length. For all indices that are valid in both the original array and the copy, the two arrays will
* contain identical values. For any indices that are valid in the copy but not the original, the copy will contain
* <tt>false</tt>. Such indices will exist if and only if the specified length is greater than that of the original
* array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with false elements to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
*/
public static boolean[] copyOf(boolean[] original, int newLength) {
boolean[] copy = new boolean[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
/**
* 从jdk1.6拷贝过来，android中没有这些方法。<br />
* Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length.
* For all indices that are valid in both the original array and the copy, the two arrays will contain identical
* values. For any indices that are valid in the copy but not the original, the copy will contain <tt>(byte)0</tt>.
* Such indices will exist if and only if the specified length is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
*/
public static byte[] copyOf(byte[] original, int newLength) {
byte[] copy = new byte[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
/**
* 从jdk1.6拷贝过来，android中没有这些方法。<br />
* Copies the specified array, truncating or padding with null characters (if necessary) so the copy has the
* specified length. For all indices that are valid in both the original array and the copy, the two arrays will
* contain identical values. For any indices that are valid in the copy but not the original, the copy will contain
* <tt>'\\u000'</tt>. Such indices will exist if and only if the specified length is greater than that of the
* original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with null characters to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
*/
public static char[] copyOf(char[] original, int newLength) {
char[] copy = new char[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
/**
* 从jdk1.6拷贝过来，android中没有这些方法。<br />
* Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length.
* For all indices that are valid in both the original array and the copy, the two arrays will contain identical
* values. For any indices that are valid in the copy but not the original, the copy will contain <tt>0d</tt>. Such
* indices will exist if and only if the specified length is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
*/
public static double[] copyOf(double[] original, int newLength) {
double[] copy = new double[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
/**
* 从jdk1.6拷贝过来，android中没有这些方法。<br />
* Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length.
* For all indices that are valid in both the original array and the copy, the two arrays will contain identical
* values. For any indices that are valid in the copy but not the original, the copy will contain <tt>0f</tt>. Such
* indices will exist if and only if the specified length is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
*/
public static float[] copyOf(float[] original, int newLength) {
float[] copy = new float[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
/**
* 从jdk1.6拷贝过来，android中没有这些方法。<br />
* Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length.
* For all indices that are valid in both the original array and the copy, the two arrays will contain identical
* values. For any indices that are valid in the copy but not the original, the copy will contain <tt>0</tt>. Such
* indices will exist if and only if the specified length is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
*/
public static int[] copyOf(int[] original, int newLength) {
int[] copy = new int[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
/**
* 从jdk1.6拷贝过来，android中没有这些方法。<br />
* Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length.
* For all indices that are valid in both the original array and the copy, the two arrays will contain identical
* values. For any indices that are valid in the copy but not the original, the copy will contain <tt>0L</tt>. Such
* indices will exist if and only if the specified length is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
*/
public static long[] copyOf(long[] original, int newLength) {
long[] copy = new long[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
/**
* 从jdk1.6拷贝过来，android中没有这些方法。<br />
* Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length.
* For all indices that are valid in both the original array and the copy, the two arrays will contain identical
* values. For any indices that are valid in the copy but not the original, the copy will contain <tt>(short)0</tt>.
* Such indices will exist if and only if the specified length is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
*/
public static short[] copyOf(short[] original, int newLength) {
short[] copy = new short[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
/**
* 从jdk1.6拷贝过来，android中没有这些方法。<br />
* Copies the specified array, truncating or padding with nulls (if necessary) so the copy has the specified length.
* For all indices that are valid in both the original array and the copy, the two arrays will contain identical
* values. For any indices that are valid in the copy but not the original, the copy will contain <tt>null</tt>.
* Such indices will exist if and only if the specified length is greater than that of the original array. The
* resulting array is of exactly the same class as the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with nulls to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
*/
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
/**
* 从jdk1.6拷贝过来，android中没有这些方法。<br />
* Copies the specified array, truncating or padding with nulls (if necessary) so the copy has the specified length.
* For all indices that are valid in both the original array and the copy, the two arrays will contain identical
* values. For any indices that are valid in the copy but not the original, the copy will contain <tt>null</tt>.
* Such indices will exist if and only if the specified length is greater than that of the original array. The
* resulting array is of the class <tt>newType</tt>.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @param newType the class of the copy to be returned
* @return a copy of the original array, truncated or padded with nulls to obtain the specified length
* @throws NegativeArraySizeException if <tt>newLength</tt> is negative
* @throws NullPointerException if <tt>original</tt> is null
* @throws ArrayStoreException if an element copied from <tt>original</tt> is not of a runtime type that can be
* stored in an array of class <tt>newType</tt>
*/
public static <T, U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
T[] copy = ( Object ) newType == ( Object ) Object[].class ? (T[]) new Object[newLength] : (T[]) Array.newInstance(
newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
/**
* 在数组中查询某值所在位置
*
* @param array
* @param value
* @return
*/
public static int indexOf(int[] array, int value) {
for (int i = 0; i < array.length; i++) {
if (array[i] == value) {
return i;
}
}
throw new ArrayIndexOutOfBoundsException(value + "is not in " + Arrays.toString(array));
}
/**
* 在数组中查询某值所在位置
*
* @param <T>
* @param array
* @param value
* @return
*/
public static <T> int indexOf(T[] array, T value) {
for (int i = 0; i < array.length; i++) {
if (array[i].equals(value)) {
return i;
}
}
throw new ArrayIndexOutOfBoundsException(value.toString() + "is not in " + Arrays.toString(array));
}
private static class ReadOnlyArrayList<E> extends AbstractList<E> implements List<E>, Serializable, RandomAccess {
private static final long serialVersionUID = 1L;
private final E[] a;
ReadOnlyArrayList(E[] storage) {
a = storage;
}
@Override
public boolean contains( Object object) {
if (a == null) {
return false;
}
if (object != null) {
for (E element : a) {
if (object.equals(element)) {
return true;
}
}
} else {
for (E element : a) {
if (element == null) {
return true;
}
}
}
return false;
}
@Override
public E get(int location) {
try {
return a[location];
} catch ( ArrayIndexOutOfBoundsException e) {
throw new IndexOutOfBoundsException();
} catch ( NullPointerException e) {
throw new IndexOutOfBoundsException();
}
}
@Override
public int indexOf( Object object) {
if (a == null) {
return -1;
}
if (object != null) {
for (int i = 0; i < a.length; i++) {
if (object.equals(a[i])) {
return i;
}
}
} else {
for (int i = 0; i < a.length; i++) {
if (a[i] == null) {
return i;
}
}
}
return -1;
}
@Override
public int lastIndexOf( Object object) {
if (a == null) {
return -1;
}
if (object != null) {
for (int i = a.length - 1; i >= 0; i--) {
if (object.equals(a[i])) {
return i;
}
}
} else {
for (int i = a.length - 1; i >= 0; i--) {
if (a[i] == null) {
return i;
}
}
}
return -1;
}
@Override
public E set(int location, E object) {
if (a == null) {
throw new IndexOutOfBoundsException();
}
try {
E result = a[location];
a[location] = object;
return result;
} catch ( ArrayIndexOutOfBoundsException e) {
throw new IndexOutOfBoundsException();
} catch ( ArrayStoreException e) {
throw new ClassCastException();
}
}
@Override
public int size() {
return a == null ? 0 : a.length;
}
@Override
public Object[] toArray() {
if (a == null) {
return new Object[0];
}
return a.clone();
}
@Override
public <T> T[] toArray(T[] contents) {
if (a == null) {
return contents;
}
int size = size();
if (size > contents.length) {
Class<?> ct = contents.getClass().getComponentType();
contents = (T[]) Array.newInstance(ct, size);
}
System.arraycopy(a, 0, contents, 0, size);
if (size < contents.length) {
contents[size] = null;
}
return contents;
}
}
/**
* @param array
* @return
*/
public static <T> boolean isEmpty( Collection<T> array) {
if (array == null || array.size() == 0) {
return true;
}
return false;
}
/**
* @param array
* @return
*/
public static <T> boolean isEmpty(T[] array) {
if (array == null || array.length == 0) {
return true;
}
return false;
}
/**
* 合并2个array
*
* @param head
* @param tail
* @return
*/
public static <T> T[] join(T[] head, T[] tail) {
if (head == null) {
return tail;
}
if (tail == null) {
return head;
}
Class<?> type = head.getClass().getComponentType();
T[] result = (T[]) Array.newInstance(type, head.length + tail.length);
System.arraycopy(head, 0, result, 0, head.length);
System.arraycopy(tail, 0, result, head.length, tail.length);
return result;
}
}