{\n\n /**\n * Constructs a new instance of this AbstractCollection.\n */\n protected AbstractCollection() {\n }\n\n public boolean add(E object) {\n throw new UnsupportedOperationException();\n }\n\n /**\n * Attempts to add all of the objects contained in {@code collection}\n * to the contents of this {@code Collection} (optional). This implementation\n * iterates over the given {@code Collection} and calls {@code add} for each\n * element. If any of these calls return {@code true}, then {@code true} is\n * returned as result of this method call, {@code false} otherwise. If this\n * {@code Collection} does not support adding elements, an {@code\n * UnsupportedOperationException} is thrown.\n * \n * If the passed {@code Collection} is changed during the process of adding elements\n * to this {@code Collection}, the behavior depends on the behavior of the passed\n * {@code Collection}.\n *\n * @param collection\n * the collection of objects.\n * @return {@code true} if this {@code Collection} is modified, {@code false}\n * otherwise.\n * @throws UnsupportedOperationException\n * if adding to this {@code Collection} is not supported.\n * @throws ClassCastException\n * if the class of an object is inappropriate for this\n * {@code Collection}.\n * @throws IllegalArgumentException\n * if an object cannot be added to this {@code Collection}.\n * @throws NullPointerException\n * if {@code collection} is {@code null}, or if it contains\n * {@code null} elements and this {@code Collection} does not support\n * such elements.\n */\n public boolean addAll(Collection collection) {\n boolean result = false;\n Iterator it = collection.iterator();\n while (it.hasNext()) {\n if (add(it.next())) {\n result = true;\n }\n }\n return result;\n }\n\n /**\n * Removes all elements from this {@code Collection}, leaving it empty (optional).\n * This implementation iterates over this {@code Collection} and calls the {@code\n * remove} method on each element. If the iterator does not support removal\n * of elements, an {@code UnsupportedOperationException} is thrown.\n *
\n * Concrete implementations usually can clear a {@code Collection} more efficiently\n * and should therefore overwrite this method.\n *\n * @throws UnsupportedOperationException\n * it the iterator does not support removing elements from\n * this {@code Collection}\n * @see #iterator\n * @see #isEmpty\n * @see #size\n */\n public void clear() {\n Iterator it = iterator();\n while (it.hasNext()) {\n it.next();\n it.remove();\n }\n }\n\n /**\n * Tests whether this {@code Collection} contains the specified object. This\n * implementation iterates over this {@code Collection} and tests, whether any\n * element is equal to the given object. If {@code object != null} then\n * {@code object.equals(e)} is called for each element {@code e} returned by\n * the iterator until the element is found. If {@code object == null} then\n * each element {@code e} returned by the iterator is compared with the test\n * {@code e == null}.\n *\n * @param object\n * the object to search for.\n * @return {@code true} if object is an element of this {@code Collection}, {@code\n * false} otherwise.\n * @throws ClassCastException\n * if the object to look for isn't of the correct type.\n * @throws NullPointerException\n * if the object to look for is {@code null} and this\n * {@code Collection} doesn't support {@code null} elements.\n */\n public boolean contains(Object object) {\n Iterator it = iterator();\n if (object != null) {\n while (it.hasNext()) {\n if (object.equals(it.next())) {\n return true;\n }\n }\n } else {\n while (it.hasNext()) {\n if (it.next() == null) {\n return true;\n }\n }\n }\n return false;\n }\n\n /**\n * Tests whether this {@code Collection} contains all objects contained in the\n * specified {@code Collection}. This implementation iterates over the specified\n * {@code Collection}. If one element returned by the iterator is not contained in\n * this {@code Collection}, then {@code false} is returned; {@code true} otherwise.\n *\n * @param collection\n * the collection of objects.\n * @return {@code true} if all objects in the specified {@code Collection} are\n * elements of this {@code Collection}, {@code false} otherwise.\n * @throws ClassCastException\n * if one or more elements of {@code collection} isn't of the\n * correct type.\n * @throws NullPointerException\n * if {@code collection} contains at least one {@code null}\n * element and this {@code Collection} doesn't support {@code null}\n * elements.\n * @throws NullPointerException\n * if {@code collection} is {@code null}.\n */\n public boolean containsAll(Collection collection) {\n Iterator it = collection.iterator();\n while (it.hasNext()) {\n if (!contains(it.next())) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Returns if this {@code Collection} contains no elements. This implementation\n * tests, whether {@code size} returns 0.\n *\n * @return {@code true} if this {@code Collection} has no elements, {@code false}\n * otherwise.\n *\n * @see #size\n */\n public boolean isEmpty() {\n return size() == 0;\n }\n\n /**\n * Returns an instance of {@link Iterator} that may be used to access the\n * objects contained by this {@code Collection}. The order in which the elements are\n * returned by the {@link Iterator} is not defined unless the instance of the\n * {@code Collection} has a defined order. In that case, the elements are returned in that order.\n * \n * In this class this method is declared abstract and has to be implemented\n * by concrete {@code Collection} implementations.\n *\n * @return an iterator for accessing the {@code Collection} contents.\n */\n public abstract Iterator iterator();\n\n /**\n * Removes one instance of the specified object from this {@code Collection} if one\n * is contained (optional). This implementation iterates over this\n * {@code Collection} and tests for each element {@code e} returned by the iterator,\n * whether {@code e} is equal to the given object. If {@code object != null}\n * then this test is performed using {@code object.equals(e)}, otherwise\n * using {@code object == null}. If an element equal to the given object is\n * found, then the {@code remove} method is called on the iterator and\n * {@code true} is returned, {@code false} otherwise. If the iterator does\n * not support removing elements, an {@code UnsupportedOperationException}\n * is thrown.\n *\n * @param object\n * the object to remove.\n * @return {@code true} if this {@code Collection} is modified, {@code false}\n * otherwise.\n * @throws UnsupportedOperationException\n * if removing from this {@code Collection} is not supported.\n * @throws ClassCastException\n * if the object passed is not of the correct type.\n * @throws NullPointerException\n * if {@code object} is {@code null} and this {@code Collection}\n * doesn't support {@code null} elements.\n */\n public boolean remove(Object object) {\n Iterator it = iterator();\n if (object != null) {\n while (it.hasNext()) {\n if (object.equals(it.next())) {\n it.remove();\n return true;\n }\n }\n } else {\n while (it.hasNext()) {\n if (it.next() == null) {\n it.remove();\n return true;\n }\n }\n }\n return false;\n }\n\n /**\n * Removes all occurrences in this {@code Collection} of each object in the\n * specified {@code Collection} (optional). After this method returns none of the\n * elements in the passed {@code Collection} can be found in this {@code Collection}\n * anymore.\n * \n * This implementation iterates over this {@code Collection} and tests for each\n * element {@code e} returned by the iterator, whether it is contained in\n * the specified {@code Collection}. If this test is positive, then the {@code\n * remove} method is called on the iterator. If the iterator does not\n * support removing elements, an {@code UnsupportedOperationException} is\n * thrown.\n *\n * @param collection\n * the collection of objects to remove.\n * @return {@code true} if this {@code Collection} is modified, {@code false}\n * otherwise.\n * @throws UnsupportedOperationException\n * if removing from this {@code Collection} is not supported.\n * @throws ClassCastException\n * if one or more elements of {@code collection} isn't of the\n * correct type.\n * @throws NullPointerException\n * if {@code collection} contains at least one {@code null}\n * element and this {@code Collection} doesn't support {@code null}\n * elements.\n * @throws NullPointerException\n * if {@code collection} is {@code null}.\n */\n public boolean removeAll(Collection collection) {\n boolean result = false;\n Iterator it = iterator();\n while (it.hasNext()) {\n if (collection.contains(it.next())) {\n it.remove();\n result = true;\n }\n }\n return result;\n }\n\n /**\n * Removes all objects from this {@code Collection} that are not also found in the\n * {@code Collection} passed (optional). After this method returns this {@code Collection}\n * will only contain elements that also can be found in the {@code Collection}\n * passed to this method.\n *
\n * This implementation iterates over this {@code Collection} and tests for each\n * element {@code e} returned by the iterator, whether it is contained in\n * the specified {@code Collection}. If this test is negative, then the {@code\n * remove} method is called on the iterator. If the iterator does not\n * support removing elements, an {@code UnsupportedOperationException} is\n * thrown.\n *\n * @param collection\n * the collection of objects to retain.\n * @return {@code true} if this {@code Collection} is modified, {@code false}\n * otherwise.\n * @throws UnsupportedOperationException\n * if removing from this {@code Collection} is not supported.\n * @throws ClassCastException\n * if one or more elements of {@code collection}\n * isn't of the correct type.\n * @throws NullPointerException\n * if {@code collection} contains at least one\n * {@code null} element and this {@code Collection} doesn't support\n * {@code null} elements.\n * @throws NullPointerException\n * if {@code collection} is {@code null}.\n */\n public boolean retainAll(Collection collection) {\n boolean result = false;\n Iterator it = iterator();\n while (it.hasNext()) {\n if (!collection.contains(it.next())) {\n it.remove();\n result = true;\n }\n }\n return result;\n }\n\n /**\n * Returns a count of how many objects this {@code Collection} contains.\n *
\n * In this class this method is declared abstract and has to be implemented\n * by concrete {@code Collection} implementations.\n *\n * @return how many objects this {@code Collection} contains, or {@code Integer.MAX_VALUE}\n * if there are more than {@code Integer.MAX_VALUE} elements in this\n * {@code Collection}.\n */\n public abstract int size();\n\n public Object[] toArray() {\n int size = size(), index = 0;\n Iterator it = iterator();\n Object[] array = new Object[size];\n while (index < size) {\n array[index++] = it.next();\n }\n return array;\n }\n\n @SuppressWarnings(\"unchecked\")\n public T[] toArray(T[] contents) {\n int size = size(), index = 0;\n if (size > contents.length) {\n Class ct = contents.getClass().getComponentType();\n contents = (T[]) Array.newInstance(ct, size);\n }\n for (E entry : this) {\n contents[index++] = (T) entry;\n }\n if (index < contents.length) {\n contents[index] = null;\n }\n return contents;\n }\n\n /**\n * Returns the string representation of this {@code Collection}. The presentation\n * has a specific format. It is enclosed by square brackets (\"[]\"). Elements\n * are separated by ', ' (comma and space).\n *\n * @return the string representation of this {@code Collection}.\n */\n @Override\n public String toString() {\n if (isEmpty()) {\n return \"[]\";\n }\n\n StringBuilder buffer = new StringBuilder(size() * 16);\n buffer.append('[');\n Iterator it = iterator();\n while (it.hasNext()) {\n Object next = it.next();\n if (next != this) {\n buffer.append(next);\n } else {\n buffer.append(\"(this Collection)\");\n }\n if (it.hasNext()) {\n buffer.append(\", \");\n }\n }\n buffer.append(']');\n return buffer.toString();\n }\n}\n"
},
{
"path": "orm-library/src/main/java/net/tsz/afinal/core/ArrayDeque.java",
"content": "/*\n * Written by Josh Bloch of Google Inc. and released to the public domain,\n * as explained at http://creativecommons.org/licenses/publicdomain.\n */\n\npackage net.tsz.afinal.core;\n\n// BEGIN android-note\n// removed link to collections framework docs\n// END android-note\n\nimport java.io.*;\nimport java.util.Collection;\nimport java.util.ConcurrentModificationException;\nimport java.util.Iterator;\nimport java.util.NoSuchElementException;\n\n/**\n * Resizable-array implementation of the {@link Deque} interface. Array\n * deques have no capacity restrictions; they grow as necessary to support\n * usage. They are not thread-safe; in the absence of external\n * synchronization, they do not support concurrent access by multiple threads.\n * Null elements are prohibited. This class is likely to be faster than\n * {@link Stack} when used as a stack, and faster than {@link LinkedList}\n * when used as a queue.\n *\n * Most ArrayDeque operations run in amortized constant time.\n * Exceptions include {@link #remove(Object) remove}, {@link\n * #removeFirstOccurrence removeFirstOccurrence}, {@link #removeLastOccurrence\n * removeLastOccurrence}, {@link #contains contains}, {@link #iterator\n * iterator.remove()}, and the bulk operations, all of which run in linear\n * time.\n *\n *
The iterators returned by this class's iterator method are\n * fail-fast: If the deque is modified at any time after the iterator\n * is created, in any way except through the iterator's own remove\n * method, the iterator will generally throw a {@link\n * ConcurrentModificationException}. Thus, in the face of concurrent\n * modification, the iterator fails quickly and cleanly, rather than risking\n * arbitrary, non-deterministic behavior at an undetermined time in the\n * future.\n *\n *
Note that the fail-fast behavior of an iterator cannot be guaranteed\n * as it is, generally speaking, impossible to make any hard guarantees in the\n * presence of unsynchronized concurrent modification. Fail-fast iterators\n * throw ConcurrentModificationException on a best-effort basis.\n * Therefore, it would be wrong to write a program that depended on this\n * exception for its correctness: the fail-fast behavior of iterators\n * should be used only to detect bugs.\n *\n *
This class and its iterator implement all of the\n * optional methods of the {@link Collection} and {@link\n * Iterator} interfaces.\n *\n * @author Josh Bloch and Doug Lea\n * @since 1.6\n * @param the type of elements held in this collection\n */\npublic class ArrayDeque extends AbstractCollection implements Deque, Cloneable, Serializable\n{\n /**\n * The array in which the elements of the deque are stored.\n * The capacity of the deque is the length of this array, which is\n * always a power of two. The array is never allowed to become\n * full, except transiently within an addX method where it is\n * resized (see doubleCapacity) immediately upon becoming full,\n * thus avoiding head and tail wrapping around to equal each\n * other. We also guarantee that all array cells not holding\n * deque elements are always null.\n */\n private transient E[] elements;\n\n /**\n * The index of the element at the head of the deque (which is the\n * element that would be removed by remove() or pop()); or an\n * arbitrary number equal to tail if the deque is empty.\n */\n private transient int head;\n\n /**\n * The index at which the next element would be added to the tail\n * of the deque (via addLast(E), add(E), or push(E)).\n */\n private transient int tail;\n\n /**\n * The minimum capacity that we'll use for a newly created deque.\n * Must be a power of 2.\n */\n private static final int MIN_INITIAL_CAPACITY = 8;\n\n // ****** Array allocation and resizing utilities ******\n\n /**\n * Allocate empty array to hold the given number of elements.\n *\n * @param numElements the number of elements to hold\n */\n @SuppressWarnings(\"unchecked\")\n\tprivate void allocateElements(int numElements) {\n int initialCapacity = MIN_INITIAL_CAPACITY;\n // Find the best power of two to hold elements.\n // Tests \"<=\" because arrays aren't kept full.\n if (numElements >= initialCapacity) {\n initialCapacity = numElements;\n initialCapacity |= (initialCapacity >>> 1);\n initialCapacity |= (initialCapacity >>> 2);\n initialCapacity |= (initialCapacity >>> 4);\n initialCapacity |= (initialCapacity >>> 8);\n initialCapacity |= (initialCapacity >>> 16);\n initialCapacity++;\n\n if (initialCapacity < 0) // Too many elements, must back off\n initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements\n }\n elements = (E[]) new Object[initialCapacity];\n }\n\n /**\n * Double the capacity of this deque. Call only when full, i.e.,\n * when head and tail have wrapped around to become equal.\n */\n @SuppressWarnings(\"unchecked\")\n\tprivate void doubleCapacity() {\n assert head == tail;\n int p = head;\n int n = elements.length;\n int r = n - p; // number of elements to the right of p\n int newCapacity = n << 1;\n if (newCapacity < 0)\n throw new IllegalStateException(\"Sorry, deque too big\");\n Object[] a = new Object[newCapacity];\n System.arraycopy(elements, p, a, 0, r);\n System.arraycopy(elements, 0, a, r, p);\n elements = (E[])a;\n head = 0;\n tail = n;\n }\n\n /**\n * Copies the elements from our element array into the specified array,\n * in order (from first to last element in the deque). It is assumed\n * that the array is large enough to hold all elements in the deque.\n *\n * @return its argument\n */\n private T[] copyElements(T[] a) {\n if (head < tail) {\n System.arraycopy(elements, head, a, 0, size());\n } else if (head > tail) {\n int headPortionLen = elements.length - head;\n System.arraycopy(elements, head, a, 0, headPortionLen);\n System.arraycopy(elements, 0, a, headPortionLen, tail);\n }\n return a;\n }\n\n /**\n * Constructs an empty array deque with an initial capacity\n * sufficient to hold 16 elements.\n */\n @SuppressWarnings(\"unchecked\")\n\tpublic ArrayDeque() {\n elements = (E[]) new Object[16];\n }\n\n /**\n * Constructs an empty array deque with an initial capacity\n * sufficient to hold the specified number of elements.\n *\n * @param numElements lower bound on initial capacity of the deque\n */\n public ArrayDeque(int numElements) {\n allocateElements(numElements);\n }\n\n /**\n * Constructs a deque containing the elements of the specified\n * collection, in the order they are returned by the collection's\n * iterator. (The first element returned by the collection's\n * iterator becomes the first element, or front of the\n * deque.)\n *\n * @param c the collection whose elements are to be placed into the deque\n * @throws NullPointerException if the specified collection is null\n */\n public ArrayDeque(Collection c) {\n allocateElements(c.size());\n addAll(c);\n }\n\n // The main insertion and extraction methods are addFirst,\n // addLast, pollFirst, pollLast. The other methods are defined in\n // terms of these.\n\n /**\n * Inserts the specified element at the front of this deque.\n *\n * @param e the element to add\n * @throws NullPointerException if the specified element is null\n */\n public void addFirst(E e) {\n if (e == null)\n throw new NullPointerException();\n elements[head = (head - 1) & (elements.length - 1)] = e;\n if (head == tail)\n doubleCapacity();\n }\n\n /**\n * Inserts the specified element at the end of this deque.\n *\n * This method is equivalent to {@link #add}.\n *\n * @param e the element to add\n * @throws NullPointerException if the specified element is null\n */\n public void addLast(E e) {\n if (e == null)\n throw new NullPointerException();\n elements[tail] = e;\n if ( (tail = (tail + 1) & (elements.length - 1)) == head)\n doubleCapacity();\n }\n\n /**\n * Inserts the specified element at the front of this deque.\n *\n * @param e the element to add\n * @return true (as specified by {@link Deque#offerFirst})\n * @throws NullPointerException if the specified element is null\n */\n public boolean offerFirst(E e) {\n addFirst(e);\n return true;\n }\n\n /**\n * Inserts the specified element at the end of this deque.\n *\n * @param e the element to add\n * @return true (as specified by {@link Deque#offerLast})\n * @throws NullPointerException if the specified element is null\n */\n public boolean offerLast(E e) {\n addLast(e);\n return true;\n }\n\n /**\n * @throws NoSuchElementException {@inheritDoc}\n */\n public E removeFirst() {\n E x = pollFirst();\n if (x == null)\n throw new NoSuchElementException();\n return x;\n }\n\n /**\n * @throws NoSuchElementException {@inheritDoc}\n */\n public E removeLast() {\n E x = pollLast();\n if (x == null)\n throw new NoSuchElementException();\n return x;\n }\n\n public E pollFirst() {\n int h = head;\n E result = elements[h]; // Element is null if deque empty\n if (result == null)\n return null;\n elements[h] = null; // Must null out slot\n head = (h + 1) & (elements.length - 1);\n return result;\n }\n\n public E pollLast() {\n int t = (tail - 1) & (elements.length - 1);\n E result = elements[t];\n if (result == null)\n return null;\n elements[t] = null;\n tail = t;\n return result;\n }\n\n /**\n * @throws NoSuchElementException {@inheritDoc}\n */\n public E getFirst() {\n E x = elements[head];\n if (x == null)\n throw new NoSuchElementException();\n return x;\n }\n\n /**\n * @throws NoSuchElementException {@inheritDoc}\n */\n public E getLast() {\n E x = elements[(tail - 1) & (elements.length - 1)];\n if (x == null)\n throw new NoSuchElementException();\n return x;\n }\n\n public E peekFirst() {\n return elements[head]; // elements[head] is null if deque empty\n }\n\n public E peekLast() {\n return elements[(tail - 1) & (elements.length - 1)];\n }\n\n /**\n * Removes the first occurrence of the specified element in this\n * deque (when traversing the deque from head to tail).\n * If the deque does not contain the element, it is unchanged.\n * More formally, removes the first element e such that\n * o.equals(e) (if such an element exists).\n * Returns true if this deque contained the specified element\n * (or equivalently, if this deque changed as a result of the call).\n *\n * @param o element to be removed from this deque, if present\n * @return true if the deque contained the specified element\n */\n public boolean removeFirstOccurrence(Object o) {\n if (o == null)\n return false;\n int mask = elements.length - 1;\n int i = head;\n E x;\n while ( (x = elements[i]) != null) {\n if (o.equals(x)) {\n delete(i);\n return true;\n }\n i = (i + 1) & mask;\n }\n return false;\n }\n\n /**\n * Removes the last occurrence of the specified element in this\n * deque (when traversing the deque from head to tail).\n * If the deque does not contain the element, it is unchanged.\n * More formally, removes the last element e such that\n * o.equals(e) (if such an element exists).\n * Returns true if this deque contained the specified element\n * (or equivalently, if this deque changed as a result of the call).\n *\n * @param o element to be removed from this deque, if present\n * @return true if the deque contained the specified element\n */\n public boolean removeLastOccurrence(Object o) {\n if (o == null)\n return false;\n int mask = elements.length - 1;\n int i = (tail - 1) & mask;\n E x;\n while ( (x = elements[i]) != null) {\n if (o.equals(x)) {\n delete(i);\n return true;\n }\n i = (i - 1) & mask;\n }\n return false;\n }\n\n // *** Queue methods ***\n\n /**\n * Inserts the specified element at the end of this deque.\n *\n *
This method is equivalent to {@link #addLast}.\n *\n * @param e the element to add\n * @return true (as specified by {@link Collection#add})\n * @throws NullPointerException if the specified element is null\n */\n public boolean add(E e) {\n addLast(e);\n return true;\n }\n\n /**\n * Inserts the specified element at the end of this deque.\n *\n *
This method is equivalent to {@link #offerLast}.\n *\n * @param e the element to add\n * @return true (as specified by {@link Queue#offer})\n * @throws NullPointerException if the specified element is null\n */\n public boolean offer(E e) {\n return offerLast(e);\n }\n\n /**\n * Retrieves and removes the head of the queue represented by this deque.\n *\n * This method differs from {@link #poll poll} only in that it throws an\n * exception if this deque is empty.\n *\n *
This method is equivalent to {@link #removeFirst}.\n *\n * @return the head of the queue represented by this deque\n * @throws NoSuchElementException {@inheritDoc}\n */\n public E remove() {\n return removeFirst();\n }\n\n /**\n * Retrieves and removes the head of the queue represented by this deque\n * (in other words, the first element of this deque), or returns\n * null if this deque is empty.\n *\n *
This method is equivalent to {@link #pollFirst}.\n *\n * @return the head of the queue represented by this deque, or\n * null if this deque is empty\n */\n public E poll() {\n return pollFirst();\n }\n\n /**\n * Retrieves, but does not remove, the head of the queue represented by\n * this deque. This method differs from {@link #peek peek} only in\n * that it throws an exception if this deque is empty.\n *\n *
This method is equivalent to {@link #getFirst}.\n *\n * @return the head of the queue represented by this deque\n * @throws NoSuchElementException {@inheritDoc}\n */\n public E element() {\n return getFirst();\n }\n\n /**\n * Retrieves, but does not remove, the head of the queue represented by\n * this deque, or returns null if this deque is empty.\n *\n *
This method is equivalent to {@link #peekFirst}.\n *\n * @return the head of the queue represented by this deque, or\n * null if this deque is empty\n */\n public E peek() {\n return peekFirst();\n }\n\n // *** Stack methods ***\n\n /**\n * Pushes an element onto the stack represented by this deque. In other\n * words, inserts the element at the front of this deque.\n *\n *
This method is equivalent to {@link #addFirst}.\n *\n * @param e the element to push\n * @throws NullPointerException if the specified element is null\n */\n public void push(E e) {\n addFirst(e);\n }\n\n /**\n * Pops an element from the stack represented by this deque. In other\n * words, removes and returns the first element of this deque.\n *\n *
This method is equivalent to {@link #removeFirst()}.\n *\n * @return the element at the front of this deque (which is the top\n * of the stack represented by this deque)\n * @throws NoSuchElementException {@inheritDoc}\n */\n public E pop() {\n return removeFirst();\n }\n\n private void checkInvariants() {\n assert elements[tail] == null;\n assert head == tail ? elements[head] == null :\n (elements[head] != null &&\n elements[(tail - 1) & (elements.length - 1)] != null);\n assert elements[(head - 1) & (elements.length - 1)] == null;\n }\n\n /**\n * Removes the element at the specified position in the elements array,\n * adjusting head and tail as necessary. This can result in motion of\n * elements backwards or forwards in the array.\n *\n *
This method is called delete rather than remove to emphasize\n * that its semantics differ from those of {@link List#remove(int)}.\n *\n * @return true if elements moved backwards\n */\n private boolean delete(int i) {\n checkInvariants();\n final E[] elements = this.elements;\n final int mask = elements.length - 1;\n final int h = head;\n final int t = tail;\n final int front = (i - h) & mask;\n final int back = (t - i) & mask;\n\n // Invariant: head <= i < tail mod circularity\n if (front >= ((t - h) & mask))\n throw new ConcurrentModificationException();\n\n // Optimize for least element motion\n if (front < back) {\n if (h <= i) {\n System.arraycopy(elements, h, elements, h + 1, front);\n } else { // Wrap around\n System.arraycopy(elements, 0, elements, 1, i);\n elements[0] = elements[mask];\n System.arraycopy(elements, h, elements, h + 1, mask - h);\n }\n elements[h] = null;\n head = (h + 1) & mask;\n return false;\n } else {\n if (i < t) { // Copy the null tail as well\n System.arraycopy(elements, i + 1, elements, i, back);\n tail = t - 1;\n } else { // Wrap around\n System.arraycopy(elements, i + 1, elements, i, mask - i);\n elements[mask] = elements[0];\n System.arraycopy(elements, 1, elements, 0, t);\n tail = (t - 1) & mask;\n }\n return true;\n }\n }\n\n // *** Collection Methods ***\n\n /**\n * Returns the number of elements in this deque.\n *\n * @return the number of elements in this deque\n */\n public int size() {\n return (tail - head) & (elements.length - 1);\n }\n\n /**\n * Returns true if this deque contains no elements.\n *\n * @return true if this deque contains no elements\n */\n public boolean isEmpty() {\n return head == tail;\n }\n\n /**\n * Returns an iterator over the elements in this deque. The elements\n * will be ordered from first (head) to last (tail). This is the same\n * order that elements would be dequeued (via successive calls to\n * {@link #remove} or popped (via successive calls to {@link #pop}).\n *\n * @return an iterator over the elements in this deque\n */\n public Iterator iterator() {\n return new DeqIterator();\n }\n\n public Iterator descendingIterator() {\n return new DescendingIterator();\n }\n\n private class DeqIterator implements Iterator {\n /**\n * Index of element to be returned by subsequent call to next.\n */\n private int cursor = head;\n\n /**\n * Tail recorded at construction (also in remove), to stop\n * iterator and also to check for comodification.\n */\n private int fence = tail;\n\n /**\n * Index of element returned by most recent call to next.\n * Reset to -1 if element is deleted by a call to remove.\n */\n private int lastRet = -1;\n\n public boolean hasNext() {\n return cursor != fence;\n }\n\n public E next() {\n if (cursor == fence)\n throw new NoSuchElementException();\n E result = elements[cursor];\n // This check doesn't catch all possible comodifications,\n // but does catch the ones that corrupt traversal\n if (tail != fence || result == null)\n throw new ConcurrentModificationException();\n lastRet = cursor;\n cursor = (cursor + 1) & (elements.length - 1);\n return result;\n }\n\n public void remove() {\n if (lastRet < 0)\n throw new IllegalStateException();\n if (delete(lastRet)) { // if left-shifted, undo increment in next()\n cursor = (cursor - 1) & (elements.length - 1);\n fence = tail;\n }\n lastRet = -1;\n }\n }\n\n private class DescendingIterator implements Iterator {\n /*\n * This class is nearly a mirror-image of DeqIterator, using\n * tail instead of head for initial cursor, and head instead of\n * tail for fence.\n */\n private int cursor = tail;\n private int fence = head;\n private int lastRet = -1;\n\n public boolean hasNext() {\n return cursor != fence;\n }\n\n public E next() {\n if (cursor == fence)\n throw new NoSuchElementException();\n cursor = (cursor - 1) & (elements.length - 1);\n E result = elements[cursor];\n if (head != fence || result == null)\n throw new ConcurrentModificationException();\n lastRet = cursor;\n return result;\n }\n\n public void remove() {\n if (lastRet < 0)\n throw new IllegalStateException();\n if (!delete(lastRet)) {\n cursor = (cursor + 1) & (elements.length - 1);\n fence = head;\n }\n lastRet = -1;\n }\n }\n\n /**\n * Returns true if this deque contains the specified element.\n * More formally, returns true if and only if this deque contains\n * at least one element e such that o.equals(e).\n *\n * @param o object to be checked for containment in this deque\n * @return true if this deque contains the specified element\n */\n public boolean contains(Object o) {\n if (o == null)\n return false;\n int mask = elements.length - 1;\n int i = head;\n E x;\n while ( (x = elements[i]) != null) {\n if (o.equals(x))\n return true;\n i = (i + 1) & mask;\n }\n return false;\n }\n\n /**\n * Removes a single instance of the specified element from this deque.\n * If the deque does not contain the element, it is unchanged.\n * More formally, removes the first element e such that\n * o.equals(e) (if such an element exists).\n * Returns true if this deque contained the specified element\n * (or equivalently, if this deque changed as a result of the call).\n *\n * This method is equivalent to {@link #removeFirstOccurrence}.\n *\n * @param o element to be removed from this deque, if present\n * @return true if this deque contained the specified element\n */\n public boolean remove(Object o) {\n return removeFirstOccurrence(o);\n }\n\n /**\n * Removes all of the elements from this deque.\n * The deque will be empty after this call returns.\n */\n public void clear() {\n int h = head;\n int t = tail;\n if (h != t) { // clear all cells\n head = tail = 0;\n int i = h;\n int mask = elements.length - 1;\n do {\n elements[i] = null;\n i = (i + 1) & mask;\n } while (i != t);\n }\n }\n\n /**\n * Returns an array containing all of the elements in this deque\n * in proper sequence (from first to last element).\n *\n *
The returned array will be \"safe\" in that no references to it are\n * maintained by this deque. (In other words, this method must allocate\n * a new array). The caller is thus free to modify the returned array.\n *\n *
This method acts as bridge between array-based and collection-based\n * APIs.\n *\n * @return an array containing all of the elements in this deque\n */\n public Object[] toArray() {\n return copyElements(new Object[size()]);\n }\n\n /**\n * Returns an array containing all of the elements in this deque in\n * proper sequence (from first to last element); the runtime type of the\n * returned array is that of the specified array. If the deque fits in\n * the specified array, it is returned therein. Otherwise, a new array\n * is allocated with the runtime type of the specified array and the\n * size of this deque.\n *\n *
If this deque fits in the specified array with room to spare\n * (i.e., the array has more elements than this deque), the element in\n * the array immediately following the end of the deque is set to\n * null.\n *\n *
Like the {@link #toArray()} method, this method acts as bridge between\n * array-based and collection-based APIs. Further, this method allows\n * precise control over the runtime type of the output array, and may,\n * under certain circumstances, be used to save allocation costs.\n *\n *
Suppose x is a deque known to contain only strings.\n * The following code can be used to dump the deque into a newly\n * allocated array of String:\n *\n *
\n * String[] y = x.toArray(new String[0]);
\n *\n * Note that toArray(new Object[0]) is identical in function to\n * toArray().\n *\n * @param a the array into which the elements of the deque are to\n * be stored, if it is big enough; otherwise, a new array of the\n * same runtime type is allocated for this purpose\n * @return an array containing all of the elements in this deque\n * @throws ArrayStoreException if the runtime type of the specified array\n * is not a supertype of the runtime type of every element in\n * this deque\n * @throws NullPointerException if the specified array is null\n */\n @SuppressWarnings(\"unchecked\")\n\tpublic T[] toArray(T[] a) {\n int size = size();\n if (a.length < size)\n a = (T[])java.lang.reflect.Array.newInstance(\n a.getClass().getComponentType(), size);\n copyElements(a);\n if (a.length > size)\n a[size] = null;\n return a;\n }\n\n // *** Object methods ***\n\n /**\n * Returns a copy of this deque.\n *\n * @return a copy of this deque\n */\n public ArrayDeque clone() {\n try {\n @SuppressWarnings(\"unchecked\")\n\t\t\tArrayDeque result = (ArrayDeque) super.clone();\n result.elements = Arrays.copyOf(elements, elements.length);\n return result;\n\n } catch (CloneNotSupportedException e) {\n throw new AssertionError();\n }\n }\n\n /**\n * Appease the serialization gods.\n */\n private static final long serialVersionUID = 2340985798034038923L;\n\n /**\n * Serialize this deque.\n *\n * @serialData The current size (int) of the deque,\n * followed by all of its elements (each an object reference) in\n * first-to-last order.\n */\n private void writeObject(ObjectOutputStream s) throws IOException {\n s.defaultWriteObject();\n\n // Write out size\n s.writeInt(size());\n\n // Write out elements in order.\n int mask = elements.length - 1;\n for (int i = head; i != tail; i = (i + 1) & mask)\n s.writeObject(elements[i]);\n }\n\n /**\n * Deserialize this deque.\n */\n @SuppressWarnings(\"unchecked\")\n\tprivate void readObject(ObjectInputStream s)\n throws IOException, ClassNotFoundException {\n s.defaultReadObject();\n\n // Read in size and allocate array\n int size = s.readInt();\n allocateElements(size);\n head = 0;\n tail = size;\n\n // Read in all elements in the proper order.\n for (int i = 0; i < size; i++)\n elements[i] = (E)s.readObject();\n }\n}\n"
},
{
"path": "orm-library/src/main/java/net/tsz/afinal/core/Arrays.java",
"content": "/*\n * Licensed to the Apache Software Foundation (ASF) under one or more\n * contributor license agreements. See the NOTICE file distributed with\n * this work for additional information regarding copyright ownership.\n * The ASF licenses this file to You under the Apache License, Version 2.0\n * (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage net.tsz.afinal.core;\n\nimport java.io.Serializable;\nimport java.lang.reflect.Array;\nimport java.util.AbstractList;\nimport java.util.Comparator;\nimport java.util.List;\nimport java.util.RandomAccess;\n\n/**\n * {@code Arrays} contains static methods which operate on arrays.\n *\n * @since 1.2\n */\npublic class Arrays {\n private static class ArrayList extends AbstractList implements\n List, Serializable, RandomAccess {\n\n private static final long serialVersionUID = -2764017481108945198L;\n\n private final E[] a;\n\n ArrayList(E[] storage) {\n if (storage == null) {\n throw new NullPointerException();\n }\n a = storage;\n }\n\n @Override\n public boolean contains(Object object) {\n if (object != null) {\n for (E element : a) {\n if (object.equals(element)) {\n return true;\n }\n }\n } else {\n for (E element : a) {\n if (element == null) {\n return true;\n }\n }\n }\n return false;\n }\n\n @Override\n public E get(int location) {\n try {\n return a[location];\n } catch (ArrayIndexOutOfBoundsException e) {\n// throw java.util.ArrayList.throwIndexOutOfBoundsException(location, a.length);\n \tthrow e;\n }\n }\n\n @Override\n public int indexOf(Object object) {\n if (object != null) {\n for (int i = 0; i < a.length; i++) {\n if (object.equals(a[i])) {\n return i;\n }\n }\n } else {\n for (int i = 0; i < a.length; i++) {\n if (a[i] == null) {\n return i;\n }\n }\n }\n return -1;\n }\n\n @Override\n public int lastIndexOf(Object object) {\n if (object != null) {\n for (int i = a.length - 1; i >= 0; i--) {\n if (object.equals(a[i])) {\n return i;\n }\n }\n } else {\n for (int i = a.length - 1; i >= 0; i--) {\n if (a[i] == null) {\n return i;\n }\n }\n }\n return -1;\n }\n\n @Override\n public E set(int location, E object) {\n E result = a[location];\n a[location] = object;\n return result;\n }\n\n @Override\n public int size() {\n return a.length;\n }\n\n @Override\n public Object[] toArray() {\n return a.clone();\n }\n\n @SuppressWarnings(\"unchecked\")\n\t\t@Override\n public T[] toArray(T[] contents) {\n int size = size();\n if (size > contents.length) {\n Class ct = contents.getClass().getComponentType();\n contents = (T[]) Array.newInstance(ct, size);\n }\n System.arraycopy(a, 0, contents, 0, size);\n if (size < contents.length) {\n contents[size] = null;\n }\n return contents;\n }\n }\n\n private Arrays() {\n /* empty */\n }\n\n /**\n * Returns a {@code List} of the objects in the specified array. The size of the\n * {@code List} cannot be modified, i.e. adding and removing are unsupported, but\n * the elements can be set. Setting an element modifies the underlying\n * array.\n *\n * @param array\n * the array.\n * @return a {@code List} of the elements of the specified array.\n */\n public static List asList(T... array) {\n return new ArrayList(array);\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array}.\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n */\n public static int binarySearch(byte[] array, byte value) {\n return binarySearch(array, 0, array.length, value);\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array},\n * in the range specified by fromIndex (inclusive) and toIndex (exclusive).\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param startIndex the inclusive start index.\n * @param endIndex the exclusive start index.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws IllegalArgumentException if {@code startIndex > endIndex}\n * @throws ArrayIndexOutOfBoundsException if {@code startIndex < 0 || endIndex > array.length}\n * @since 1.6\n */\n public static int binarySearch(byte[] array, int startIndex, int endIndex, byte value) {\n checkBinarySearchBounds(startIndex, endIndex, array.length);\n int lo = startIndex;\n int hi = endIndex - 1;\n\n while (lo <= hi) {\n int mid = (lo + hi) >>> 1;\n byte midVal = array[mid];\n\n if (midVal < value) {\n lo = mid + 1;\n } else if (midVal > value) {\n hi = mid - 1;\n } else {\n return mid; // value found\n }\n }\n return ~lo; // value not present\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array}.\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n */\n public static int binarySearch(char[] array, char value) {\n return binarySearch(array, 0, array.length, value);\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array},\n * in the range specified by fromIndex (inclusive) and toIndex (exclusive).\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param startIndex the inclusive start index.\n * @param endIndex the exclusive start index.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws IllegalArgumentException if {@code startIndex > endIndex}\n * @throws ArrayIndexOutOfBoundsException if {@code startIndex < 0 || endIndex > array.length}\n * @since 1.6\n */\n public static int binarySearch(char[] array, int startIndex, int endIndex, char value) {\n checkBinarySearchBounds(startIndex, endIndex, array.length);\n int lo = startIndex;\n int hi = endIndex - 1;\n\n while (lo <= hi) {\n int mid = (lo + hi) >>> 1;\n char midVal = array[mid];\n\n if (midVal < value) {\n lo = mid + 1;\n } else if (midVal > value) {\n hi = mid - 1;\n } else {\n return mid; // value found\n }\n }\n return ~lo; // value not present\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array}.\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n */\n public static int binarySearch(double[] array, double value) {\n return binarySearch(array, 0, array.length, value);\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array},\n * in the range specified by fromIndex (inclusive) and toIndex (exclusive).\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param startIndex the inclusive start index.\n * @param endIndex the exclusive start index.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws IllegalArgumentException if {@code startIndex > endIndex}\n * @throws ArrayIndexOutOfBoundsException if {@code startIndex < 0 || endIndex > array.length}\n * @since 1.6\n */\n public static int binarySearch(double[] array, int startIndex, int endIndex, double value) {\n checkBinarySearchBounds(startIndex, endIndex, array.length);\n int lo = startIndex;\n int hi = endIndex - 1;\n\n while (lo <= hi) {\n int mid = (lo + hi) >>> 1;\n double midVal = array[mid];\n\n if (midVal < value) {\n lo = mid + 1;\n } else if (midVal > value) {\n hi = mid - 1;\n } else if (midVal != 0 && midVal == value) {\n return mid; // value found\n } else { // Either midVal and value are == 0 or at least one is NaN\n long midValBits = Double.doubleToLongBits(midVal);\n long valueBits = Double.doubleToLongBits(value);\n\n if (midValBits < valueBits) {\n lo = mid + 1; // (-0.0, 0.0) or (not NaN, NaN); midVal < val\n } else if (midValBits > valueBits) {\n hi = mid - 1; // (0.0, -0.0) or (NaN, not NaN); midVal > val\n } else {\n return mid; // bit patterns are equal; value found\n }\n }\n }\n return ~lo; // value not present\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array}.\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n */\n public static int binarySearch(float[] array, float value) {\n return binarySearch(array, 0, array.length, value);\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array},\n * in the range specified by fromIndex (inclusive) and toIndex (exclusive).\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param startIndex the inclusive start index.\n * @param endIndex the exclusive start index.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws IllegalArgumentException if {@code startIndex > endIndex}\n * @throws ArrayIndexOutOfBoundsException if {@code startIndex < 0 || endIndex > array.length}\n * @since 1.6\n */\n public static int binarySearch(float[] array, int startIndex, int endIndex, float value) {\n checkBinarySearchBounds(startIndex, endIndex, array.length);\n int lo = startIndex;\n int hi = endIndex - 1;\n\n while (lo <= hi) {\n int mid = (lo + hi) >>> 1;\n float midVal = array[mid];\n\n if (midVal < value) {\n lo = mid + 1;\n } else if (midVal > value) {\n hi = mid - 1;\n } else if (midVal != 0 && midVal == value) {\n return mid; // value found\n } else { // Either midVal and value are == 0 or at least one is NaN\n int midValBits = Float.floatToIntBits(midVal);\n int valueBits = Float.floatToIntBits(value);\n\n if (midValBits < valueBits) {\n lo = mid + 1; // (-0.0, 0.0) or (not NaN, NaN); midVal < val\n } else if (midValBits > valueBits) {\n hi = mid - 1; // (0.0, -0.0) or (NaN, not NaN); midVal > val\n } else {\n return mid; // bit patterns are equal; value found\n }\n }\n }\n return ~lo; // value not present\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array}.\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n */\n public static int binarySearch(int[] array, int value) {\n return binarySearch(array, 0, array.length, value);\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array},\n * in the range specified by fromIndex (inclusive) and toIndex (exclusive).\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param startIndex the inclusive start index.\n * @param endIndex the exclusive start index.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws IllegalArgumentException if {@code startIndex > endIndex}\n * @throws ArrayIndexOutOfBoundsException if {@code startIndex < 0 || endIndex > array.length}\n * @since 1.6\n */\n public static int binarySearch(int[] array, int startIndex, int endIndex, int value) {\n checkBinarySearchBounds(startIndex, endIndex, array.length);\n int lo = startIndex;\n int hi = endIndex - 1;\n\n while (lo <= hi) {\n int mid = (lo + hi) >>> 1;\n int midVal = array[mid];\n\n if (midVal < value) {\n lo = mid + 1;\n } else if (midVal > value) {\n hi = mid - 1;\n } else {\n return mid; // value found\n }\n }\n return ~lo; // value not present\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array}.\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n */\n public static int binarySearch(long[] array, long value) {\n return binarySearch(array, 0, array.length, value);\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array},\n * in the range specified by fromIndex (inclusive) and toIndex (exclusive).\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param startIndex the inclusive start index.\n * @param endIndex the exclusive start index.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws IllegalArgumentException if {@code startIndex > endIndex}\n * @throws ArrayIndexOutOfBoundsException if {@code startIndex < 0 || endIndex > array.length}\n * @since 1.6\n */\n public static int binarySearch(long[] array, int startIndex, int endIndex, long value) {\n checkBinarySearchBounds(startIndex, endIndex, array.length);\n int lo = startIndex;\n int hi = endIndex - 1;\n\n while (lo <= hi) {\n int mid = (lo + hi) >>> 1;\n long midVal = array[mid];\n\n if (midVal < value) {\n lo = mid + 1;\n } else if (midVal > value) {\n hi = mid - 1;\n } else {\n return mid; // value found\n }\n }\n return ~lo; // value not present\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array}.\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws ClassCastException\n * if an element in the array or the search element does not\n * implement {@code Comparable}, or cannot be compared to each other.\n */\n public static int binarySearch(Object[] array, Object value) {\n return binarySearch(array, 0, array.length, value);\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array},\n * in the range specified by fromIndex (inclusive) and toIndex (exclusive).\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param startIndex the inclusive start index.\n * @param endIndex the exclusive start index.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws ClassCastException\n * if an element in the array or the search element does not\n * implement {@code Comparable}, or cannot be compared to each other.\n * @throws IllegalArgumentException if {@code startIndex > endIndex}\n * @throws ArrayIndexOutOfBoundsException if {@code startIndex < 0 || endIndex > array.length}\n * @since 1.6\n */\n @SuppressWarnings(\"unchecked\")\n\tpublic static int binarySearch(Object[] array, int startIndex, int endIndex, Object value) {\n checkBinarySearchBounds(startIndex, endIndex, array.length);\n int lo = startIndex;\n int hi = endIndex - 1;\n\n while (lo <= hi) {\n int mid = (lo + hi) >>> 1;\n @SuppressWarnings(\"rawtypes\")\n\t\t\tint midValCmp = ((Comparable) array[mid]).compareTo(value);\n\n if (midValCmp < 0) {\n lo = mid + 1;\n } else if (midValCmp > 0) {\n hi = mid - 1;\n } else {\n return mid; // value found\n }\n }\n return ~lo; // value not present\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array},\n * using {@code comparator} to compare elements.\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param value the element to find.\n * @param comparator the {@code Comparator} used to compare the elements.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws ClassCastException\n * if an element in the array or the search element does not\n * implement {@code Comparable}, or cannot be compared to each other.\n */\n public static int binarySearch(T[] array, T value, Comparator comparator) {\n return binarySearch(array, 0, array.length, value, comparator);\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array},\n * in the range specified by fromIndex (inclusive) and toIndex (exclusive),\n * using {@code comparator} to compare elements.\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param startIndex the inclusive start index.\n * @param endIndex the exclusive start index.\n * @param value the element to find.\n * @param comparator the {@code Comparator} used to compare the elements.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws ClassCastException\n * if an element in the array or the search element does not\n * implement {@code Comparable}, or cannot be compared to each other.\n * @throws IllegalArgumentException if {@code startIndex > endIndex}\n * @throws ArrayIndexOutOfBoundsException if {@code startIndex < 0 || endIndex > array.length}\n * @since 1.6\n */\n public static int binarySearch(T[] array, int startIndex, int endIndex, T value,\n Comparator comparator) {\n if (comparator == null) {\n return binarySearch(array, startIndex, endIndex, value);\n }\n\n checkBinarySearchBounds(startIndex, endIndex, array.length);\n int lo = startIndex;\n int hi = endIndex - 1;\n\n while (lo <= hi) {\n int mid = (lo + hi) >>> 1;\n int midValCmp = comparator.compare(array[mid], value);\n\n if (midValCmp < 0) {\n lo = mid + 1;\n } else if (midValCmp > 0) {\n hi = mid - 1;\n } else {\n return mid; // value found\n }\n }\n return ~lo; // value not present\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array}.\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n */\n public static int binarySearch(short[] array, short value) {\n return binarySearch(array, 0, array.length, value);\n }\n\n /**\n * Performs a binary search for {@code value} in the ascending sorted array {@code array},\n * in the range specified by fromIndex (inclusive) and toIndex (exclusive).\n * Searching in an unsorted array has an undefined result. It's also undefined which element\n * is found if there are multiple occurrences of the same element.\n *\n * @param array the sorted array to search.\n * @param startIndex the inclusive start index.\n * @param endIndex the exclusive start index.\n * @param value the element to find.\n * @return the non-negative index of the element, or a negative index which\n * is {@code -index - 1} where the element would be inserted.\n * @throws IllegalArgumentException if {@code startIndex > endIndex}\n * @throws ArrayIndexOutOfBoundsException if {@code startIndex < 0 || endIndex > array.length}\n * @since 1.6\n */\n public static int binarySearch(short[] array, int startIndex, int endIndex, short value) {\n checkBinarySearchBounds(startIndex, endIndex, array.length);\n int lo = startIndex;\n int hi = endIndex - 1;\n\n while (lo <= hi) {\n int mid = (lo + hi) >>> 1;\n short midVal = array[mid];\n\n if (midVal < value) {\n lo = mid + 1;\n } else if (midVal > value) {\n hi = mid - 1;\n } else {\n return mid; // value found\n }\n }\n return ~lo; // value not present\n }\n\n private static void checkBinarySearchBounds(int startIndex, int endIndex, int length) {\n if (startIndex > endIndex) {\n throw new IllegalArgumentException();\n }\n if (startIndex < 0 || endIndex > length) {\n throw new ArrayIndexOutOfBoundsException();\n }\n }\n\n /**\n * Fills the specified array with the specified element.\n *\n * @param array\n * the {@code byte} array to fill.\n * @param value\n * the {@code byte} element.\n */\n public static void fill(byte[] array, byte value) {\n for (int i = 0; i < array.length; i++) {\n array[i] = value;\n }\n }\n\n \n\n /**\n * Fills the specified array with the specified element.\n *\n * @param array\n * the {@code int} array to fill.\n * @param value\n * the {@code int} element.\n */\n public static void fill(int[] array, int value) {\n for (int i = 0; i < array.length; i++) {\n array[i] = value;\n }\n }\n\n \n\n /**\n * Fills the specified array with the specified element.\n *\n * @param array\n * the {@code boolean} array to fill.\n * @param value\n * the {@code boolean} element.\n */\n public static void fill(boolean[] array, boolean value) {\n for (int i = 0; i < array.length; i++) {\n array[i] = value;\n }\n }\n\n \n\n /**\n * Fills the specified array with the specified element.\n *\n * @param array\n * the {@code Object} array to fill.\n * @param value\n * the {@code Object} element.\n */\n public static void fill(Object[] array, Object value) {\n for (int i = 0; i < array.length; i++) {\n array[i] = value;\n }\n }\n\n \n\n /**\n * Returns a hash code based on the contents of the given array. For any two\n * {@code boolean} arrays {@code a} and {@code b}, if\n * {@code Arrays.equals(a, b)} returns {@code true}, it means\n * that the return value of {@code Arrays.hashCode(a)} equals {@code Arrays.hashCode(b)}.\n * \n * The value returned by this method is the same value as the\n * {@link List#hashCode()} method which is invoked on a {@link List}\n * containing a sequence of {@link Boolean} instances representing the\n * elements of array in the same order. If the array is {@code null}, the return\n * value is 0.\n *\n * @param array\n * the array whose hash code to compute.\n * @return the hash code for {@code array}.\n */\n public static int hashCode(boolean[] array) {\n if (array == null) {\n return 0;\n }\n int hashCode = 1;\n for (boolean element : array) {\n // 1231, 1237 are hash code values for boolean value\n hashCode = 31 * hashCode + (element ? 1231 : 1237);\n }\n return hashCode;\n }\n\n /**\n * Returns a hash code based on the contents of the given array. For any two\n * not-null {@code int} arrays {@code a} and {@code b}, if\n * {@code Arrays.equals(a, b)} returns {@code true}, it means\n * that the return value of {@code Arrays.hashCode(a)} equals {@code Arrays.hashCode(b)}.\n *
\n * The value returned by this method is the same value as the\n * {@link List#hashCode()} method which is invoked on a {@link List}\n * containing a sequence of {@link Integer} instances representing the\n * elements of array in the same order. If the array is {@code null}, the return\n * value is 0.\n *\n * @param array\n * the array whose hash code to compute.\n * @return the hash code for {@code array}.\n */\n public static int hashCode(int[] array) {\n if (array == null) {\n return 0;\n }\n int hashCode = 1;\n for (int element : array) {\n // the hash code value for integer value is integer value itself\n hashCode = 31 * hashCode + element;\n }\n return hashCode;\n }\n\n /**\n * Returns a hash code based on the contents of the given array. For any two\n * {@code short} arrays {@code a} and {@code b}, if\n * {@code Arrays.equals(a, b)} returns {@code true}, it means\n * that the return value of {@code Arrays.hashCode(a)} equals {@code Arrays.hashCode(b)}.\n *
\n * The value returned by this method is the same value as the\n * {@link List#hashCode()} method which is invoked on a {@link List}\n * containing a sequence of {@link Short} instances representing the\n * elements of array in the same order. If the array is {@code null}, the return\n * value is 0.\n *\n * @param array\n * the array whose hash code to compute.\n * @return the hash code for {@code array}.\n */\n public static int hashCode(short[] array) {\n if (array == null) {\n return 0;\n }\n int hashCode = 1;\n for (short element : array) {\n // the hash code value for short value is its integer value\n hashCode = 31 * hashCode + element;\n }\n return hashCode;\n }\n\n /**\n * Returns a hash code based on the contents of the given array. For any two\n * {@code char} arrays {@code a} and {@code b}, if\n * {@code Arrays.equals(a, b)} returns {@code true}, it means\n * that the return value of {@code Arrays.hashCode(a)} equals {@code Arrays.hashCode(b)}.\n *
\n * The value returned by this method is the same value as the\n * {@link List#hashCode()} method which is invoked on a {@link List}\n * containing a sequence of {@link Character} instances representing the\n * elements of array in the same order. If the array is {@code null}, the return\n * value is 0.\n *\n * @param array\n * the array whose hash code to compute.\n * @return the hash code for {@code array}.\n */\n public static int hashCode(char[] array) {\n if (array == null) {\n return 0;\n }\n int hashCode = 1;\n for (char element : array) {\n // the hash code value for char value is its integer value\n hashCode = 31 * hashCode + element;\n }\n return hashCode;\n }\n\n /**\n * Returns a hash code based on the contents of the given array. For any two\n * {@code byte} arrays {@code a} and {@code b}, if\n * {@code Arrays.equals(a, b)} returns {@code true}, it means\n * that the return value of {@code Arrays.hashCode(a)} equals {@code Arrays.hashCode(b)}.\n *
\n * The value returned by this method is the same value as the\n * {@link List#hashCode()} method which is invoked on a {@link List}\n * containing a sequence of {@link Byte} instances representing the\n * elements of array in the same order. If the array is {@code null}, the return\n * value is 0.\n *\n * @param array\n * the array whose hash code to compute.\n * @return the hash code for {@code array}.\n */\n public static int hashCode(byte[] array) {\n if (array == null) {\n return 0;\n }\n int hashCode = 1;\n for (byte element : array) {\n // the hash code value for byte value is its integer value\n hashCode = 31 * hashCode + element;\n }\n return hashCode;\n }\n\n /**\n * Returns a hash code based on the contents of the given array. For any two\n * {@code long} arrays {@code a} and {@code b}, if\n * {@code Arrays.equals(a, b)} returns {@code true}, it means\n * that the return value of {@code Arrays.hashCode(a)} equals {@code Arrays.hashCode(b)}.\n *
\n * The value returned by this method is the same value as the\n * {@link List#hashCode()} method which is invoked on a {@link List}\n * containing a sequence of {@link Long} instances representing the\n * elements of array in the same order. If the array is {@code null}, the return\n * value is 0.\n *\n * @param array\n * the array whose hash code to compute.\n * @return the hash code for {@code array}.\n */\n public static int hashCode(long[] array) {\n if (array == null) {\n return 0;\n }\n int hashCode = 1;\n for (long elementValue : array) {\n /*\n * the hash code value for long value is (int) (value ^ (value >>>\n * 32))\n */\n hashCode = 31 * hashCode\n + (int) (elementValue ^ (elementValue >>> 32));\n }\n return hashCode;\n }\n\n /**\n * Returns a hash code based on the contents of the given array. For any two\n * {@code float} arrays {@code a} and {@code b}, if\n * {@code Arrays.equals(a, b)} returns {@code true}, it means\n * that the return value of {@code Arrays.hashCode(a)} equals {@code Arrays.hashCode(b)}.\n *
\n * The value returned by this method is the same value as the\n * {@link List#hashCode()} method which is invoked on a {@link List}\n * containing a sequence of {@link Float} instances representing the\n * elements of array in the same order. If the array is {@code null}, the return\n * value is 0.\n *\n * @param array\n * the array whose hash code to compute.\n * @return the hash code for {@code array}.\n */\n public static int hashCode(float[] array) {\n if (array == null) {\n return 0;\n }\n int hashCode = 1;\n for (float element : array) {\n /*\n * the hash code value for float value is\n * Float.floatToIntBits(value)\n */\n hashCode = 31 * hashCode + Float.floatToIntBits(element);\n }\n return hashCode;\n }\n\n /**\n * Returns a hash code based on the contents of the given array. For any two\n * {@code double} arrays {@code a} and {@code b}, if\n * {@code Arrays.equals(a, b)} returns {@code true}, it means\n * that the return value of {@code Arrays.hashCode(a)} equals {@code Arrays.hashCode(b)}.\n *
\n * The value returned by this method is the same value as the\n * {@link List#hashCode()} method which is invoked on a {@link List}\n * containing a sequence of {@link Double} instances representing the\n * elements of array in the same order. If the array is {@code null}, the return\n * value is 0.\n *\n * @param array\n * the array whose hash code to compute.\n * @return the hash code for {@code array}.\n */\n public static int hashCode(double[] array) {\n if (array == null) {\n return 0;\n }\n int hashCode = 1;\n\n for (double element : array) {\n long v = Double.doubleToLongBits(element);\n /*\n * the hash code value for double value is (int) (v ^ (v >>> 32))\n * where v = Double.doubleToLongBits(value)\n */\n hashCode = 31 * hashCode + (int) (v ^ (v >>> 32));\n }\n return hashCode;\n }\n\n /**\n * Returns a hash code based on the contents of the given array. If the\n * array contains other arrays as its elements, the hash code is based on\n * their identities not their contents. So it is acceptable to invoke this\n * method on an array that contains itself as an element, either directly or\n * indirectly.\n *
\n * For any two arrays {@code a} and {@code b}, if\n * {@code Arrays.equals(a, b)} returns {@code true}, it means\n * that the return value of {@code Arrays.hashCode(a)} equals\n * {@code Arrays.hashCode(b)}.\n *
\n * The value returned by this method is the same value as the method\n * Arrays.asList(array).hashCode(). If the array is {@code null}, the return value\n * is 0.\n *\n * @param array\n * the array whose hash code to compute.\n * @return the hash code for {@code array}.\n */\n public static int hashCode(Object[] array) {\n if (array == null) {\n return 0;\n }\n int hashCode = 1;\n for (Object element : array) {\n int elementHashCode;\n\n if (element == null) {\n elementHashCode = 0;\n } else {\n elementHashCode = (element).hashCode();\n }\n hashCode = 31 * hashCode + elementHashCode;\n }\n return hashCode;\n }\n\n /**\n * Returns a hash code based on the \"deep contents\" of the given array. If\n * the array contains other arrays as its elements, the hash code is based\n * on their contents not their identities. So it is not acceptable to invoke\n * this method on an array that contains itself as an element, either\n * directly or indirectly.\n *
\n * For any two arrays {@code a} and {@code b}, if\n * {@code Arrays.deepEquals(a, b)} returns {@code true}, it\n * means that the return value of {@code Arrays.deepHashCode(a)} equals\n * {@code Arrays.deepHashCode(b)}.\n *
\n * The computation of the value returned by this method is similar to that\n * of the value returned by {@link List#hashCode()} invoked on a\n * {@link List} containing a sequence of instances representing the\n * elements of array in the same order. The difference is: If an element e\n * of array is itself an array, its hash code is computed by calling the\n * appropriate overloading of {@code Arrays.hashCode(e)} if e is an array of a\n * primitive type, or by calling {@code Arrays.deepHashCode(e)} recursively if e is\n * an array of a reference type. The value returned by this method is the\n * same value as the method {@code Arrays.asList(array).hashCode()}. If the array is\n * {@code null}, the return value is 0.\n *\n * @param array\n * the array whose hash code to compute.\n * @return the hash code for {@code array}.\n */\n public static int deepHashCode(Object[] array) {\n if (array == null) {\n return 0;\n }\n int hashCode = 1;\n for (Object element : array) {\n int elementHashCode = deepHashCodeElement(element);\n hashCode = 31 * hashCode + elementHashCode;\n }\n return hashCode;\n }\n\n private static int deepHashCodeElement(Object element) {\n Class cl;\n if (element == null) {\n return 0;\n }\n\n cl = element.getClass().getComponentType();\n\n if (cl == null) {\n return element.hashCode();\n }\n\n /*\n * element is an array\n */\n if (!cl.isPrimitive()) {\n return deepHashCode((Object[]) element);\n }\n if (cl.equals(int.class)) {\n return hashCode((int[]) element);\n }\n if (cl.equals(char.class)) {\n return hashCode((char[]) element);\n }\n if (cl.equals(boolean.class)) {\n return hashCode((boolean[]) element);\n }\n if (cl.equals(byte.class)) {\n return hashCode((byte[]) element);\n }\n if (cl.equals(long.class)) {\n return hashCode((long[]) element);\n }\n if (cl.equals(float.class)) {\n return hashCode((float[]) element);\n }\n if (cl.equals(double.class)) {\n return hashCode((double[]) element);\n }\n return hashCode((short[]) element);\n }\n\n /**\n * Compares the two arrays.\n *\n * @param array1\n * the first {@code byte} array.\n * @param array2\n * the second {@code byte} array.\n * @return {@code true} if both arrays are {@code null} or if the arrays have the\n * same length and the elements at each index in the two arrays are\n * equal, {@code false} otherwise.\n */\n public static boolean equals(byte[] array1, byte[] array2) {\n if (array1 == array2) {\n return true;\n }\n if (array1 == null || array2 == null || array1.length != array2.length) {\n return false;\n }\n for (int i = 0; i < array1.length; i++) {\n if (array1[i] != array2[i]) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Compares the two arrays.\n *\n * @param array1\n * the first {@code short} array.\n * @param array2\n * the second {@code short} array.\n * @return {@code true} if both arrays are {@code null} or if the arrays have the\n * same length and the elements at each index in the two arrays are\n * equal, {@code false} otherwise.\n */\n public static boolean equals(short[] array1, short[] array2) {\n if (array1 == array2) {\n return true;\n }\n if (array1 == null || array2 == null || array1.length != array2.length) {\n return false;\n }\n for (int i = 0; i < array1.length; i++) {\n if (array1[i] != array2[i]) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Compares the two arrays.\n *\n * @param array1\n * the first {@code char} array.\n * @param array2\n * the second {@code char} array.\n * @return {@code true} if both arrays are {@code null} or if the arrays have the\n * same length and the elements at each index in the two arrays are\n * equal, {@code false} otherwise.\n */\n public static boolean equals(char[] array1, char[] array2) {\n if (array1 == array2) {\n return true;\n }\n if (array1 == null || array2 == null || array1.length != array2.length) {\n return false;\n }\n for (int i = 0; i < array1.length; i++) {\n if (array1[i] != array2[i]) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Compares the two arrays.\n *\n * @param array1\n * the first {@code int} array.\n * @param array2\n * the second {@code int} array.\n * @return {@code true} if both arrays are {@code null} or if the arrays have the\n * same length and the elements at each index in the two arrays are\n * equal, {@code false} otherwise.\n */\n public static boolean equals(int[] array1, int[] array2) {\n if (array1 == array2) {\n return true;\n }\n if (array1 == null || array2 == null || array1.length != array2.length) {\n return false;\n }\n for (int i = 0; i < array1.length; i++) {\n if (array1[i] != array2[i]) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Compares the two arrays.\n *\n * @param array1\n * the first {@code long} array.\n * @param array2\n * the second {@code long} array.\n * @return {@code true} if both arrays are {@code null} or if the arrays have the\n * same length and the elements at each index in the two arrays are\n * equal, {@code false} otherwise.\n */\n public static boolean equals(long[] array1, long[] array2) {\n if (array1 == array2) {\n return true;\n }\n if (array1 == null || array2 == null || array1.length != array2.length) {\n return false;\n }\n for (int i = 0; i < array1.length; i++) {\n if (array1[i] != array2[i]) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Compares the two arrays. The values are compared in the same manner as\n * {@code Float.equals()}.\n *\n * @param array1\n * the first {@code float} array.\n * @param array2\n * the second {@code float} array.\n * @return {@code true} if both arrays are {@code null} or if the arrays have the\n * same length and the elements at each index in the two arrays are\n * equal, {@code false} otherwise.\n * @see Float#equals(Object)\n */\n public static boolean equals(float[] array1, float[] array2) {\n if (array1 == array2) {\n return true;\n }\n if (array1 == null || array2 == null || array1.length != array2.length) {\n return false;\n }\n for (int i = 0; i < array1.length; i++) {\n if (Float.floatToIntBits(array1[i]) != Float\n .floatToIntBits(array2[i])) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Compares the two arrays. The values are compared in the same manner as\n * {@code Double.equals()}.\n *\n * @param array1\n * the first {@code double} array.\n * @param array2\n * the second {@code double} array.\n * @return {@code true} if both arrays are {@code null} or if the arrays have the\n * same length and the elements at each index in the two arrays are\n * equal, {@code false} otherwise.\n * @see Double#equals(Object)\n */\n public static boolean equals(double[] array1, double[] array2) {\n if (array1 == array2) {\n return true;\n }\n if (array1 == null || array2 == null || array1.length != array2.length) {\n return false;\n }\n for (int i = 0; i < array1.length; i++) {\n if (Double.doubleToLongBits(array1[i]) != Double\n .doubleToLongBits(array2[i])) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Compares the two arrays.\n *\n * @param array1\n * the first {@code boolean} array.\n * @param array2\n * the second {@code boolean} array.\n * @return {@code true} if both arrays are {@code null} or if the arrays have the\n * same length and the elements at each index in the two arrays are\n * equal, {@code false} otherwise.\n */\n public static boolean equals(boolean[] array1, boolean[] array2) {\n if (array1 == array2) {\n return true;\n }\n if (array1 == null || array2 == null || array1.length != array2.length) {\n return false;\n }\n for (int i = 0; i < array1.length; i++) {\n if (array1[i] != array2[i]) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Compares the two arrays.\n *\n * @param array1\n * the first {@code Object} array.\n * @param array2\n * the second {@code Object} array.\n * @return {@code true} if both arrays are {@code null} or if the arrays have the\n * same length and the elements at each index in the two arrays are\n * equal according to {@code equals()}, {@code false} otherwise.\n */\n public static boolean equals(Object[] array1, Object[] array2) {\n if (array1 == array2) {\n return true;\n }\n if (array1 == null || array2 == null || array1.length != array2.length) {\n return false;\n }\n for (int i = 0; i < array1.length; i++) {\n Object e1 = array1[i], e2 = array2[i];\n if (!(e1 == null ? e2 == null : e1.equals(e2))) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Returns {@code true} if the two given arrays are deeply equal to one another.\n * Unlike the method {@code equals(Object[] array1, Object[] array2)}, this method\n * is appropriate for use for nested arrays of arbitrary depth.\n *
\n * Two array references are considered deeply equal if they are both {@code null},\n * or if they refer to arrays that have the same length and the elements at\n * each index in the two arrays are equal.\n *
\n * Two {@code null} elements {@code element1} and {@code element2} are possibly deeply equal if any\n * of the following conditions satisfied:\n *
\n * {@code element1} and {@code element2} are both arrays of object reference types, and\n * {@code Arrays.deepEquals(element1, element2)} would return {@code true}.\n *
\n * {@code element1} and {@code element2} are arrays of the same primitive type, and the\n * appropriate overloading of {@code Arrays.equals(element1, element2)} would return\n * {@code true}.\n *
\n * {@code element1 == element2}\n *
\n * {@code element1.equals(element2)} would return {@code true}.\n *
\n * Note that this definition permits {@code null} elements at any depth.\n *
\n * If either of the given arrays contain themselves as elements, the\n * behavior of this method is uncertain.\n *\n * @param array1\n * the first {@code Object} array.\n * @param array2\n * the second {@code Object} array.\n * @return {@code true} if both arrays are {@code null} or if the arrays have the\n * same length and the elements at each index in the two arrays are\n * equal according to {@code equals()}, {@code false} otherwise.\n */\n public static boolean deepEquals(Object[] array1, Object[] array2) {\n if (array1 == array2) {\n return true;\n }\n if (array1 == null || array2 == null || array1.length != array2.length) {\n return false;\n }\n for (int i = 0; i < array1.length; i++) {\n Object e1 = array1[i], e2 = array2[i];\n\n if (!deepEqualsElements(e1, e2)) {\n return false;\n }\n }\n return true;\n }\n\n private static boolean deepEqualsElements(Object e1, Object e2) {\n Class cl1, cl2;\n\n if (e1 == e2) {\n return true;\n }\n\n if (e1 == null || e2 == null) {\n return false;\n }\n\n cl1 = e1.getClass().getComponentType();\n cl2 = e2.getClass().getComponentType();\n\n if (cl1 != cl2) {\n return false;\n }\n\n if (cl1 == null) {\n return e1.equals(e2);\n }\n\n /*\n * compare as arrays\n */\n if (!cl1.isPrimitive()) {\n return deepEquals((Object[]) e1, (Object[]) e2);\n }\n\n if (cl1.equals(int.class)) {\n return equals((int[]) e1, (int[]) e2);\n }\n if (cl1.equals(char.class)) {\n return equals((char[]) e1, (char[]) e2);\n }\n if (cl1.equals(boolean.class)) {\n return equals((boolean[]) e1, (boolean[]) e2);\n }\n if (cl1.equals(byte.class)) {\n return equals((byte[]) e1, (byte[]) e2);\n }\n if (cl1.equals(long.class)) {\n return equals((long[]) e1, (long[]) e2);\n }\n if (cl1.equals(float.class)) {\n return equals((float[]) e1, (float[]) e2);\n }\n if (cl1.equals(double.class)) {\n return equals((double[]) e1, (double[]) e2);\n }\n return equals((short[]) e1, (short[]) e2);\n }\n\n \n\n /**\n * Sorts the specified range in the array in ascending numerical order.\n *\n * @param array\n * the {@code byte} array to be sorted.\n * @param start\n * the start index to sort.\n * @param end\n * the last + 1 index to sort.\n * @throws IllegalArgumentException\n * if {@code start > end}.\n * @throws ArrayIndexOutOfBoundsException\n * if {@code start < 0} or {@code end > array.length}.\n */\n \n\n /**\n * Creates a {@code String} representation of the {@code boolean[]} passed.\n * The result is surrounded by brackets ({@code \"[]\"}), each\n * element is converted to a {@code String} via the\n * {@link String#valueOf(boolean)} and separated by {@code \", \"}.\n * If the array is {@code null}, then {@code \"null\"} is returned.\n *\n * @param array\n * the {@code boolean} array to convert.\n * @return the {@code String} representation of {@code array}.\n * @since 1.5\n */\n public static String toString(boolean[] array) {\n if (array == null) {\n return \"null\";\n }\n if (array.length == 0) {\n return \"[]\";\n }\n StringBuilder sb = new StringBuilder(array.length * 7);\n sb.append('[');\n sb.append(array[0]);\n for (int i = 1; i < array.length; i++) {\n sb.append(\", \");\n sb.append(array[i]);\n }\n sb.append(']');\n return sb.toString();\n }\n\n /**\n * Creates a {@code String} representation of the {@code byte[]} passed. The\n * result is surrounded by brackets ({@code \"[]\"}), each element\n * is converted to a {@code String} via the {@link String#valueOf(int)} and\n * separated by {@code \", \"}. If the array is {@code null}, then\n * {@code \"null\"} is returned.\n *\n * @param array\n * the {@code byte} array to convert.\n * @return the {@code String} representation of {@code array}.\n * @since 1.5\n */\n public static String toString(byte[] array) {\n if (array == null) {\n return \"null\";\n }\n if (array.length == 0) {\n return \"[]\";\n }\n StringBuilder sb = new StringBuilder(array.length * 6);\n sb.append('[');\n sb.append(array[0]);\n for (int i = 1; i < array.length; i++) {\n sb.append(\", \");\n sb.append(array[i]);\n }\n sb.append(']');\n return sb.toString();\n }\n\n /**\n * Creates a {@code String} representation of the {@code char[]} passed. The\n * result is surrounded by brackets ({@code \"[]\"}), each element\n * is converted to a {@code String} via the {@link String#valueOf(char)} and\n * separated by {@code \", \"}. If the array is {@code null}, then\n * {@code \"null\"} is returned.\n *\n * @param array\n * the {@code char} array to convert.\n * @return the {@code String} representation of {@code array}.\n * @since 1.5\n */\n public static String toString(char[] array) {\n if (array == null) {\n return \"null\";\n }\n if (array.length == 0) {\n return \"[]\";\n }\n StringBuilder sb = new StringBuilder(array.length * 3);\n sb.append('[');\n sb.append(array[0]);\n for (int i = 1; i < array.length; i++) {\n sb.append(\", \");\n sb.append(array[i]);\n }\n sb.append(']');\n return sb.toString();\n }\n\n /**\n * Creates a {@code String} representation of the {@code double[]} passed.\n * The result is surrounded by brackets ({@code \"[]\"}), each\n * element is converted to a {@code String} via the\n * {@link String#valueOf(double)} and separated by {@code \", \"}.\n * If the array is {@code null}, then {@code \"null\"} is returned.\n *\n * @param array\n * the {@code double} array to convert.\n * @return the {@code String} representation of {@code array}.\n * @since 1.5\n */\n public static String toString(double[] array) {\n if (array == null) {\n return \"null\";\n }\n if (array.length == 0) {\n return \"[]\";\n }\n StringBuilder sb = new StringBuilder(array.length * 7);\n sb.append('[');\n sb.append(array[0]);\n for (int i = 1; i < array.length; i++) {\n sb.append(\", \");\n sb.append(array[i]);\n }\n sb.append(']');\n return sb.toString();\n }\n\n /**\n * Creates a {@code String} representation of the {@code float[]} passed.\n * The result is surrounded by brackets ({@code \"[]\"}), each\n * element is converted to a {@code String} via the\n * {@link String#valueOf(float)} and separated by {@code \", \"}.\n * If the array is {@code null}, then {@code \"null\"} is returned.\n *\n * @param array\n * the {@code float} array to convert.\n * @return the {@code String} representation of {@code array}.\n * @since 1.5\n */\n public static String toString(float[] array) {\n if (array == null) {\n return \"null\";\n }\n if (array.length == 0) {\n return \"[]\";\n }\n StringBuilder sb = new StringBuilder(array.length * 7);\n sb.append('[');\n sb.append(array[0]);\n for (int i = 1; i < array.length; i++) {\n sb.append(\", \");\n sb.append(array[i]);\n }\n sb.append(']');\n return sb.toString();\n }\n\n /**\n * Creates a {@code String} representation of the {@code int[]} passed. The\n * result is surrounded by brackets ({@code \"[]\"}), each element\n * is converted to a {@code String} via the {@link String#valueOf(int)} and\n * separated by {@code \", \"}. If the array is {@code null}, then\n * {@code \"null\"} is returned.\n *\n * @param array\n * the {@code int} array to convert.\n * @return the {@code String} representation of {@code array}.\n * @since 1.5\n */\n public static String toString(int[] array) {\n if (array == null) {\n return \"null\";\n }\n if (array.length == 0) {\n return \"[]\";\n }\n StringBuilder sb = new StringBuilder(array.length * 6);\n sb.append('[');\n sb.append(array[0]);\n for (int i = 1; i < array.length; i++) {\n sb.append(\", \");\n sb.append(array[i]);\n }\n sb.append(']');\n return sb.toString();\n }\n\n /**\n * Creates a {@code String} representation of the {@code long[]} passed. The\n * result is surrounded by brackets ({@code \"[]\"}), each element\n * is converted to a {@code String} via the {@link String#valueOf(long)} and\n * separated by {@code \", \"}. If the array is {@code null}, then\n * {@code \"null\"} is returned.\n *\n * @param array\n * the {@code long} array to convert.\n * @return the {@code String} representation of {@code array}.\n * @since 1.5\n */\n public static String toString(long[] array) {\n if (array == null) {\n return \"null\";\n }\n if (array.length == 0) {\n return \"[]\";\n }\n StringBuilder sb = new StringBuilder(array.length * 6);\n sb.append('[');\n sb.append(array[0]);\n for (int i = 1; i < array.length; i++) {\n sb.append(\", \");\n sb.append(array[i]);\n }\n sb.append(']');\n return sb.toString();\n }\n\n /**\n * Creates a {@code String} representation of the {@code short[]} passed.\n * The result is surrounded by brackets ({@code \"[]\"}), each\n * element is converted to a {@code String} via the\n * {@link String#valueOf(int)} and separated by {@code \", \"}. If\n * the array is {@code null}, then {@code \"null\"} is returned.\n *\n * @param array\n * the {@code short} array to convert.\n * @return the {@code String} representation of {@code array}.\n * @since 1.5\n */\n public static String toString(short[] array) {\n if (array == null) {\n return \"null\";\n }\n if (array.length == 0) {\n return \"[]\";\n }\n StringBuilder sb = new StringBuilder(array.length * 6);\n sb.append('[');\n sb.append(array[0]);\n for (int i = 1; i < array.length; i++) {\n sb.append(\", \");\n sb.append(array[i]);\n }\n sb.append(']');\n return sb.toString();\n }\n\n /**\n * Creates a {@code String} representation of the {@code Object[]} passed.\n * The result is surrounded by brackets ({@code \"[]\"}), each\n * element is converted to a {@code String} via the\n * {@link String#valueOf(Object)} and separated by {@code \", \"}.\n * If the array is {@code null}, then {@code \"null\"} is returned.\n *\n * @param array\n * the {@code Object} array to convert.\n * @return the {@code String} representation of {@code array}.\n * @since 1.5\n */\n public static String toString(Object[] array) {\n if (array == null) {\n return \"null\";\n }\n if (array.length == 0) {\n return \"[]\";\n }\n StringBuilder sb = new StringBuilder(array.length * 7);\n sb.append('[');\n sb.append(array[0]);\n for (int i = 1; i < array.length; i++) {\n sb.append(\", \");\n sb.append(array[i]);\n }\n sb.append(']');\n return sb.toString();\n }\n\n /**\n * Creates a \"deep\" {@code String} representation of the\n * {@code Object[]} passed, such that if the array contains other arrays,\n * the {@code String} representation of those arrays is generated as well.\n *
\n * If any of the elements are primitive arrays, the generation is delegated\n * to the other {@code toString} methods in this class. If any element\n * contains a reference to the original array, then it will be represented\n * as {@code \"[...]\"}. If an element is an {@code Object[]}, then its\n * representation is generated by a recursive call to this method. All other\n * elements are converted via the {@link String#valueOf(Object)} method.\n *\n * @param array\n * the {@code Object} array to convert.\n * @return the {@code String} representation of {@code array}.\n * @since 1.5\n */\n public static String deepToString(Object[] array) {\n // Special case null to prevent NPE\n if (array == null) {\n return \"null\";\n }\n // delegate this to the recursive method\n StringBuilder buf = new StringBuilder(array.length * 9);\n deepToStringImpl(array, new Object[] { array }, buf);\n return buf.toString();\n }\n\n /**\n * Implementation method used by {@link #deepToString(Object[])}.\n *\n * @param array\n * the {@code Object[]} to dive into.\n * @param origArrays\n * the original {@code Object[]}; used to test for self\n * references.\n * @param sb\n * the {@code StringBuilder} instance to append to or\n * {@code null} one hasn't been created yet.\n * @return the result.\n * @see #deepToString(Object[])\n */\n private static void deepToStringImpl(Object[] array, Object[] origArrays,\n StringBuilder sb) {\n if (array == null) {\n sb.append(\"null\");\n return;\n }\n\n sb.append('[');\n\n for (int i = 0; i < array.length; i++) {\n if (i != 0) {\n sb.append(\", \");\n }\n // establish current element\n Object elem = array[i];\n if (elem == null) {\n // element is null\n sb.append(\"null\");\n } else {\n // get the Class of the current element\n Class elemClass = elem.getClass();\n if (elemClass.isArray()) {\n // element is an array type\n\n // get the declared Class of the array (element)\n Class elemElemClass = elemClass.getComponentType();\n if (elemElemClass.isPrimitive()) {\n // element is a primitive array\n if (boolean.class.equals(elemElemClass)) {\n sb.append(toString((boolean[]) elem));\n } else if (byte.class.equals(elemElemClass)) {\n sb.append(toString((byte[]) elem));\n } else if (char.class.equals(elemElemClass)) {\n sb.append(toString((char[]) elem));\n } else if (double.class.equals(elemElemClass)) {\n sb.append(toString((double[]) elem));\n } else if (float.class.equals(elemElemClass)) {\n sb.append(toString((float[]) elem));\n } else if (int.class.equals(elemElemClass)) {\n sb.append(toString((int[]) elem));\n } else if (long.class.equals(elemElemClass)) {\n sb.append(toString((long[]) elem));\n } else if (short.class.equals(elemElemClass)) {\n sb.append(toString((short[]) elem));\n } else {\n // no other possible primitives, so we assert that\n throw new AssertionError();\n }\n } else {\n // element is an Object[], so we assert that\n assert elem instanceof Object[];\n if (deepToStringImplContains(origArrays, elem)) {\n sb.append(\"[...]\");\n } else {\n Object[] newArray = (Object[]) elem;\n Object[] newOrigArrays = new Object[origArrays.length + 1];\n System.arraycopy(origArrays, 0, newOrigArrays, 0,\n origArrays.length);\n newOrigArrays[origArrays.length] = newArray;\n // make the recursive call to this method\n deepToStringImpl(newArray, newOrigArrays, sb);\n }\n }\n } else { // element is NOT an array, just an Object\n sb.append(array[i]);\n }\n }\n }\n sb.append(']');\n }\n\n /**\n * Utility method used to assist the implementation of\n * {@link #deepToString(Object[])}.\n *\n * @param origArrays\n * An array of Object[] references.\n * @param array\n * An Object[] reference to look for in {@code origArrays}.\n * @return A value of {@code true} if {@code array} is an\n * element in {@code origArrays}.\n */\n private static boolean deepToStringImplContains(Object[] origArrays,\n Object array) {\n if (origArrays == null || origArrays.length == 0) {\n return false;\n }\n for (Object element : origArrays) {\n if (element == array) {\n return true;\n }\n }\n return false;\n }\n\n /**\n * Copies {@code newLength} elements from {@code original} into a new array.\n * If {@code newLength} is greater than {@code original.length}, the result is padded\n * with the value {@code false}.\n *\n * @param original the original array\n * @param newLength the length of the new array\n * @return the new array\n * @throws NegativeArraySizeException if {@code newLength < 0}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static boolean[] copyOf(boolean[] original, int newLength) {\n if (newLength < 0) {\n throw new NegativeArraySizeException();\n }\n return copyOfRange(original, 0, newLength);\n }\n\n /**\n * Copies {@code newLength} elements from {@code original} into a new array.\n * If {@code newLength} is greater than {@code original.length}, the result is padded\n * with the value {@code (byte) 0}.\n *\n * @param original the original array\n * @param newLength the length of the new array\n * @return the new array\n * @throws NegativeArraySizeException if {@code newLength < 0}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static byte[] copyOf(byte[] original, int newLength) {\n if (newLength < 0) {\n throw new NegativeArraySizeException();\n }\n return copyOfRange(original, 0, newLength);\n }\n\n /**\n * Copies {@code newLength} elements from {@code original} into a new array.\n * If {@code newLength} is greater than {@code original.length}, the result is padded\n * with the value {@code '\\\\u0000'}.\n *\n * @param original the original array\n * @param newLength the length of the new array\n * @return the new array\n * @throws NegativeArraySizeException if {@code newLength < 0}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static char[] copyOf(char[] original, int newLength) {\n if (newLength < 0) {\n throw new NegativeArraySizeException();\n }\n return copyOfRange(original, 0, newLength);\n }\n\n /**\n * Copies {@code newLength} elements from {@code original} into a new array.\n * If {@code newLength} is greater than {@code original.length}, the result is padded\n * with the value {@code 0.0d}.\n *\n * @param original the original array\n * @param newLength the length of the new array\n * @return the new array\n * @throws NegativeArraySizeException if {@code newLength < 0}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static double[] copyOf(double[] original, int newLength) {\n if (newLength < 0) {\n throw new NegativeArraySizeException();\n }\n return copyOfRange(original, 0, newLength);\n }\n\n /**\n * Copies {@code newLength} elements from {@code original} into a new array.\n * If {@code newLength} is greater than {@code original.length}, the result is padded\n * with the value {@code 0.0f}.\n *\n * @param original the original array\n * @param newLength the length of the new array\n * @return the new array\n * @throws NegativeArraySizeException if {@code newLength < 0}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static float[] copyOf(float[] original, int newLength) {\n if (newLength < 0) {\n throw new NegativeArraySizeException();\n }\n return copyOfRange(original, 0, newLength);\n }\n\n /**\n * Copies {@code newLength} elements from {@code original} into a new array.\n * If {@code newLength} is greater than {@code original.length}, the result is padded\n * with the value {@code 0}.\n *\n * @param original the original array\n * @param newLength the length of the new array\n * @return the new array\n * @throws NegativeArraySizeException if {@code newLength < 0}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static int[] copyOf(int[] original, int newLength) {\n if (newLength < 0) {\n throw new NegativeArraySizeException();\n }\n return copyOfRange(original, 0, newLength);\n }\n\n /**\n * Copies {@code newLength} elements from {@code original} into a new array.\n * If {@code newLength} is greater than {@code original.length}, the result is padded\n * with the value {@code 0L}.\n *\n * @param original the original array\n * @param newLength the length of the new array\n * @return the new array\n * @throws NegativeArraySizeException if {@code newLength < 0}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static long[] copyOf(long[] original, int newLength) {\n if (newLength < 0) {\n throw new NegativeArraySizeException();\n }\n return copyOfRange(original, 0, newLength);\n }\n\n /**\n * Copies {@code newLength} elements from {@code original} into a new array.\n * If {@code newLength} is greater than {@code original.length}, the result is padded\n * with the value {@code (short) 0}.\n *\n * @param original the original array\n * @param newLength the length of the new array\n * @return the new array\n * @throws NegativeArraySizeException if {@code newLength < 0}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static short[] copyOf(short[] original, int newLength) {\n if (newLength < 0) {\n throw new NegativeArraySizeException();\n }\n return copyOfRange(original, 0, newLength);\n }\n\n /**\n * Copies {@code newLength} elements from {@code original} into a new array.\n * If {@code newLength} is greater than {@code original.length}, the result is padded\n * with the value {@code null}.\n *\n * @param original the original array\n * @param newLength the length of the new array\n * @return the new array\n * @throws NegativeArraySizeException if {@code newLength < 0}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static T[] copyOf(T[] original, int newLength) {\n if (original == null) {\n throw new NullPointerException();\n }\n if (newLength < 0) {\n throw new NegativeArraySizeException();\n }\n return copyOfRange(original, 0, newLength);\n }\n\n /**\n * Copies {@code newLength} elements from {@code original} into a new array.\n * If {@code newLength} is greater than {@code original.length}, the result is padded\n * with the value {@code null}.\n *\n * @param original the original array\n * @param newLength the length of the new array\n * @param newType the class of the new array\n * @return the new array\n * @throws NegativeArraySizeException if {@code newLength < 0}\n * @throws NullPointerException if {@code original == null}\n * @throws ArrayStoreException if a value in {@code original} is incompatible with T\n * @since 1.6\n */\n public static T[] copyOf(U[] original, int newLength, Class newType) {\n // We use the null pointer check in copyOfRange for exception priority compatibility.\n if (newLength < 0) {\n throw new NegativeArraySizeException();\n }\n return copyOfRange(original, 0, newLength, newType);\n }\n\n /**\n * Copies elements from {@code original} into a new array, from indexes start (inclusive) to\n * end (exclusive). The original order of elements is preserved.\n * If {@code end} is greater than {@code original.length}, the result is padded\n * with the value {@code false}.\n *\n * @param original the original array\n * @param start the start index, inclusive\n * @param end the end index, exclusive\n * @return the new array\n * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length}\n * @throws IllegalArgumentException if {@code start > end}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static boolean[] copyOfRange(boolean[] original, int start, int end) {\n if (start > end) {\n throw new IllegalArgumentException();\n }\n int originalLength = original.length;\n if (start < 0 || start > originalLength) {\n throw new ArrayIndexOutOfBoundsException();\n }\n int resultLength = end - start;\n int copyLength = Math.min(resultLength, originalLength - start);\n boolean[] result = new boolean[resultLength];\n System.arraycopy(original, start, result, 0, copyLength);\n return result;\n }\n\n /**\n * Copies elements from {@code original} into a new array, from indexes start (inclusive) to\n * end (exclusive). The original order of elements is preserved.\n * If {@code end} is greater than {@code original.length}, the result is padded\n * with the value {@code (byte) 0}.\n *\n * @param original the original array\n * @param start the start index, inclusive\n * @param end the end index, exclusive\n * @return the new array\n * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length}\n * @throws IllegalArgumentException if {@code start > end}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static byte[] copyOfRange(byte[] original, int start, int end) {\n if (start > end) {\n throw new IllegalArgumentException();\n }\n int originalLength = original.length;\n if (start < 0 || start > originalLength) {\n throw new ArrayIndexOutOfBoundsException();\n }\n int resultLength = end - start;\n int copyLength = Math.min(resultLength, originalLength - start);\n byte[] result = new byte[resultLength];\n System.arraycopy(original, start, result, 0, copyLength);\n return result;\n }\n\n /**\n * Copies elements from {@code original} into a new array, from indexes start (inclusive) to\n * end (exclusive). The original order of elements is preserved.\n * If {@code end} is greater than {@code original.length}, the result is padded\n * with the value {@code '\\\\u0000'}.\n *\n * @param original the original array\n * @param start the start index, inclusive\n * @param end the end index, exclusive\n * @return the new array\n * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length}\n * @throws IllegalArgumentException if {@code start > end}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static char[] copyOfRange(char[] original, int start, int end) {\n if (start > end) {\n throw new IllegalArgumentException();\n }\n int originalLength = original.length;\n if (start < 0 || start > originalLength) {\n throw new ArrayIndexOutOfBoundsException();\n }\n int resultLength = end - start;\n int copyLength = Math.min(resultLength, originalLength - start);\n char[] result = new char[resultLength];\n System.arraycopy(original, start, result, 0, copyLength);\n return result;\n }\n\n /**\n * Copies elements from {@code original} into a new array, from indexes start (inclusive) to\n * end (exclusive). The original order of elements is preserved.\n * If {@code end} is greater than {@code original.length}, the result is padded\n * with the value {@code 0.0d}.\n *\n * @param original the original array\n * @param start the start index, inclusive\n * @param end the end index, exclusive\n * @return the new array\n * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length}\n * @throws IllegalArgumentException if {@code start > end}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static double[] copyOfRange(double[] original, int start, int end) {\n if (start > end) {\n throw new IllegalArgumentException();\n }\n int originalLength = original.length;\n if (start < 0 || start > originalLength) {\n throw new ArrayIndexOutOfBoundsException();\n }\n int resultLength = end - start;\n int copyLength = Math.min(resultLength, originalLength - start);\n double[] result = new double[resultLength];\n System.arraycopy(original, start, result, 0, copyLength);\n return result;\n }\n\n /**\n * Copies elements from {@code original} into a new array, from indexes start (inclusive) to\n * end (exclusive). The original order of elements is preserved.\n * If {@code end} is greater than {@code original.length}, the result is padded\n * with the value {@code 0.0f}.\n *\n * @param original the original array\n * @param start the start index, inclusive\n * @param end the end index, exclusive\n * @return the new array\n * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length}\n * @throws IllegalArgumentException if {@code start > end}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static float[] copyOfRange(float[] original, int start, int end) {\n if (start > end) {\n throw new IllegalArgumentException();\n }\n int originalLength = original.length;\n if (start < 0 || start > originalLength) {\n throw new ArrayIndexOutOfBoundsException();\n }\n int resultLength = end - start;\n int copyLength = Math.min(resultLength, originalLength - start);\n float[] result = new float[resultLength];\n System.arraycopy(original, start, result, 0, copyLength);\n return result;\n }\n\n /**\n * Copies elements from {@code original} into a new array, from indexes start (inclusive) to\n * end (exclusive). The original order of elements is preserved.\n * If {@code end} is greater than {@code original.length}, the result is padded\n * with the value {@code 0}.\n *\n * @param original the original array\n * @param start the start index, inclusive\n * @param end the end index, exclusive\n * @return the new array\n * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length}\n * @throws IllegalArgumentException if {@code start > end}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static int[] copyOfRange(int[] original, int start, int end) {\n if (start > end) {\n throw new IllegalArgumentException();\n }\n int originalLength = original.length;\n if (start < 0 || start > originalLength) {\n throw new ArrayIndexOutOfBoundsException();\n }\n int resultLength = end - start;\n int copyLength = Math.min(resultLength, originalLength - start);\n int[] result = new int[resultLength];\n System.arraycopy(original, start, result, 0, copyLength);\n return result;\n }\n\n /**\n * Copies elements from {@code original} into a new array, from indexes start (inclusive) to\n * end (exclusive). The original order of elements is preserved.\n * If {@code end} is greater than {@code original.length}, the result is padded\n * with the value {@code 0L}.\n *\n * @param original the original array\n * @param start the start index, inclusive\n * @param end the end index, exclusive\n * @return the new array\n * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length}\n * @throws IllegalArgumentException if {@code start > end}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static long[] copyOfRange(long[] original, int start, int end) {\n if (start > end) {\n throw new IllegalArgumentException();\n }\n int originalLength = original.length;\n if (start < 0 || start > originalLength) {\n throw new ArrayIndexOutOfBoundsException();\n }\n int resultLength = end - start;\n int copyLength = Math.min(resultLength, originalLength - start);\n long[] result = new long[resultLength];\n System.arraycopy(original, start, result, 0, copyLength);\n return result;\n }\n\n /**\n * Copies elements from {@code original} into a new array, from indexes start (inclusive) to\n * end (exclusive). The original order of elements is preserved.\n * If {@code end} is greater than {@code original.length}, the result is padded\n * with the value {@code (short) 0}.\n *\n * @param original the original array\n * @param start the start index, inclusive\n * @param end the end index, exclusive\n * @return the new array\n * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length}\n * @throws IllegalArgumentException if {@code start > end}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n public static short[] copyOfRange(short[] original, int start, int end) {\n if (start > end) {\n throw new IllegalArgumentException();\n }\n int originalLength = original.length;\n if (start < 0 || start > originalLength) {\n throw new ArrayIndexOutOfBoundsException();\n }\n int resultLength = end - start;\n int copyLength = Math.min(resultLength, originalLength - start);\n short[] result = new short[resultLength];\n System.arraycopy(original, start, result, 0, copyLength);\n return result;\n }\n\n /**\n * Copies elements from {@code original} into a new array, from indexes start (inclusive) to\n * end (exclusive). The original order of elements is preserved.\n * If {@code end} is greater than {@code original.length}, the result is padded\n * with the value {@code null}.\n *\n * @param original the original array\n * @param start the start index, inclusive\n * @param end the end index, exclusive\n * @return the new array\n * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length}\n * @throws IllegalArgumentException if {@code start > end}\n * @throws NullPointerException if {@code original == null}\n * @since 1.6\n */\n @SuppressWarnings(\"unchecked\")\n public static T[] copyOfRange(T[] original, int start, int end) {\n int originalLength = original.length; // For exception priority compatibility.\n if (start > end) {\n throw new IllegalArgumentException();\n }\n if (start < 0 || start > originalLength) {\n throw new ArrayIndexOutOfBoundsException();\n }\n int resultLength = end - start;\n int copyLength = Math.min(resultLength, originalLength - start);\n T[] result = (T[]) Array.newInstance(original.getClass().getComponentType(), resultLength);\n System.arraycopy(original, start, result, 0, copyLength);\n return result;\n }\n\n /**\n * Copies elements from {@code original} into a new array, from indexes start (inclusive) to\n * end (exclusive). The original order of elements is preserved.\n * If {@code end} is greater than {@code original.length}, the result is padded\n * with the value {@code null}.\n *\n * @param original the original array\n * @param start the start index, inclusive\n * @param end the end index, exclusive\n * @return the new array\n * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length}\n * @throws IllegalArgumentException if {@code start > end}\n * @throws NullPointerException if {@code original == null}\n * @throws ArrayStoreException if a value in {@code original} is incompatible with T\n * @since 1.6\n */\n @SuppressWarnings(\"unchecked\")\n public static T[] copyOfRange(U[] original, int start, int end, Class newType) {\n if (start > end) {\n throw new IllegalArgumentException();\n }\n int originalLength = original.length;\n if (start < 0 || start > originalLength) {\n throw new ArrayIndexOutOfBoundsException();\n }\n int resultLength = end - start;\n int copyLength = Math.min(resultLength, originalLength - start);\n T[] result = (T[]) Array.newInstance(newType.getComponentType(), resultLength);\n System.arraycopy(original, start, result, 0, copyLength);\n return result;\n }\n}\n"
},
{
"path": "orm-library/src/main/java/net/tsz/afinal/core/AsyncTask.java",
"content": "package net.tsz.afinal.core;\n\nimport android.os.Handler;\nimport android.os.Message;\nimport android.os.Process;\n\nimport java.util.concurrent.BlockingQueue;\nimport java.util.concurrent.Callable;\nimport java.util.concurrent.CancellationException;\nimport java.util.concurrent.Executor;\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.Executors;\nimport java.util.concurrent.FutureTask;\nimport java.util.concurrent.LinkedBlockingQueue;\nimport java.util.concurrent.ThreadFactory;\nimport java.util.concurrent.ThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.TimeoutException;\nimport java.util.concurrent.atomic.AtomicBoolean;\nimport java.util.concurrent.atomic.AtomicInteger;\n\n/**\n * 拷贝 https://android.googlesource.com/platform/frameworks/base/+/jb-release/\n * core/java/android/os/AsyncTask.java\n * 修改了线程池属性，让并发线程按顺序执行\n * @author michael\n *\n * @param \n * @param
![](\"./screenshot/S50603-103314.jpg\")
\n![](\"./screenshot/S50605-164248.jpg\")
\n\n![](\"./screenshot/S50605-164615.jpg\")
\n![](\"./screenshot/S50611-163425.jpg\")
\n\n![](\"./screenshot/S50611-163752.jpg\")
\n![](\"./screenshot/S50611-164132.jpg\")
\n\n![](\"./screenshot/S50611-164146.jpg\")
\n\n#1.1.2\n- 增加了多款彩色主题的选择\n- 增加了关于界面的分享功能\n- 修复了笔记过长的显示问题\n- 修复了SwipeRefreshLayout和RecyclerView的组合问题\n- 优化界面的一些细节，修复已知的小bug\n\n#1.1.0\n- 增加了笔记列表的卡片式的布局，可在设置里面切换\n- 增加了下拉同步笔记的组件\n- 增加编辑笔记时点击返回询问是否保存\n- 使用了Snackbar代替了Toast的提示\n- 去除了编辑笔记内容的下划线\n- 修改了笔记列表的显示时间方式\n- 修复了小米2s 5.0上CardView的显示问题\n\n#1.0.2\n- Material Design风格，采用抽屉式菜单，悬浮滑动按钮，点击控件时的水波纹效果，状态栏透明使得与应用融为一体，用户即使在Android L系统以下的手机也能感受到良好的用户体验\n- 用文字记录身边随时发生的事情，或者你的待办事项\n- 同步，同步需要你在手机设置里面添加一个邮箱，并作为你的同步账号，提交到服务器\n\n#License\n```\nCopyright 2015 Liaoguipeng\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n```\n"
},
{
"path": "app/.gitignore",
"content": "/build\n"
},
{
"path": "app/app.iml",
"content": "\n