文档添加关于字符串、字节和void数据类型的说明

在NumPy文档中，常规介绍部分现在包含了关于字符串、字节和void数据类型的信息，以及现有的数值类型。

pom.xml

@@ -18,6 +18,13 @@
 	<dependencies>
 
 
+		<!--spring-->
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-context</artifactId>
+			<version>5.3.18</version>
+		</dependency>
+
 		<dependency>
 			<groupId>cglib</groupId>
 			<artifactId>cglib</artifactId>

src/main/java/cn/whaifree/dataStructure/PriorityQueue.java

@@ -0,0 +1,842 @@
+package cn.whaifree.dataStructure;/*
+ * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+import java.util.*;
+
+/**
+ * An unbounded priority {@linkplain Queue queue} based on a priority heap.
+ * The elements of the priority queue are ordered according to their
+ * {@linkplain Comparable natural ordering}, or by a {@link Comparator}
+ * provided at queue construction time, depending on which constructor is
+ * used.  A priority queue does not permit {@code null} elements.
+ * A priority queue relying on natural ordering also does not permit
+ * insertion of non-comparable objects (doing so may result in
+ * {@code ClassCastException}).
+ *
+ * <p>The <em>head</em> of this queue is the <em>least</em> element
+ * with respect to the specified ordering.  If multiple elements are
+ * tied for least value, the head is one of those elements -- ties are
+ * broken arbitrarily.  The queue retrieval operations {@code poll},
+ * {@code remove}, {@code peek}, and {@code element} access the
+ * element at the head of the queue.
+ *
+ * <p>A priority queue is unbounded, but has an internal
+ * <i>capacity</i> governing the size of an array used to store the
+ * elements on the queue.  It is always at least as large as the queue
+ * size.  As elements are added to a priority queue, its capacity
+ * grows automatically.  The details of the growth policy are not
+ * specified.
+ *
+ * <p>This class and its iterator implement all of the
+ * <em>optional</em> methods of the {@link Collection} and {@link
+ * Iterator} interfaces.  The Iterator provided in method {@link
+ * #iterator()} is <em>not</em> guaranteed to traverse the elements of
+ * the priority queue in any particular order. If you need ordered
+ * traversal, consider using {@code Arrays.sort(pq.toArray())}.
+ *
+ * <p><strong>Note that this implementation is not synchronized.</strong>
+ * Multiple threads should not access a {@code PriorityQueue}
+ * instance concurrently if any of the threads modifies the queue.
+ * Instead, use the thread-safe {@link
+ * java.util.concurrent.PriorityBlockingQueue} class.
+ *
+ * <p>Implementation note: this implementation provides
+ * O(log(n)) time for the enqueuing and dequeuing methods
+ * ({@code offer}, {@code poll}, {@code remove()} and {@code add});
+ * linear time for the {@code remove(Object)} and {@code contains(Object)}
+ * methods; and constant time for the retrieval methods
+ * ({@code peek}, {@code element}, and {@code size}).
+ *
+ * <p>This class is a member of the
+ * <a href="{@docRoot}/../technotes/guides/collections/index.html">
+ * Java Collections Framework</a>.
+ *
+ * @since 1.5
+ * @author Josh Bloch, Doug Lea
+ * @param <E> the type of elements held in this collection
+ */
+class PriorityQueue<E> extends AbstractQueue<E>
+        implements java.io.Serializable {
+
+    /**
+     * Inserts the specified element into this priority queue.
+     *
+     * @return {@code true} (as specified by {@link Collection#add})
+     * @throws ClassCastException if the specified element cannot be
+     *         compared with elements currently in this priority queue
+     *         according to the priority queue's ordering
+     * @throws NullPointerException if the specified element is null
+     */
+    public boolean add(E e) {
+        return offer(e);
+    }
+
+    /**
+     * Inserts the specified element into this priority queue.
+     *
+     * @return {@code true} (as specified by {@link Queue#offer})
+     * @throws ClassCastException if the specified element cannot be
+     *         compared with elements currently in this priority queue
+     *         according to the priority queue's ordering
+     * @throws NullPointerException if the specified element is null
+     */
+    public boolean offer(E e) {
+        if (e == null)
+            throw new NullPointerException();
+        modCount++;
+        int i = size;
+        if (i >= queue.length)
+            grow(i + 1);
+        size = i + 1;
+        if (i == 0)
+            queue[0] = e;
+        else
+            siftUp(i, e);
+        return true;
+    }
+
+    @SuppressWarnings("unchecked")
+    public E peek() {
+        return (size == 0) ? null : (E) queue[0];
+    }
+
+    private int indexOf(Object o) {
+        if (o != null) {
+            for (int i = 0; i < size; i++)
+                if (o.equals(queue[i]))
+                    return i;
+        }
+        return -1;
+    }
+
+    /**
+     * Removes a single instance of the specified element from this queue,
+     * if it is present.  More formally, removes an element {@code e} such
+     * that {@code o.equals(e)}, if this queue contains one or more such
+     * elements.  Returns {@code true} if and only if this queue contained
+     * the specified element (or equivalently, if this queue changed as a
+     * result of the call).
+     *
+     * @param o element to be removed from this queue, if present
+     * @return {@code true} if this queue changed as a result of the call
+     */
+    public boolean remove(Object o) {
+        int i = indexOf(o);
+        if (i == -1)
+            return false;
+        else {
+            removeAt(i);
+            return true;
+        }
+    }
+
+    /**
+     * Version of remove using reference equality, not equals.
+     * Needed by iterator.remove.
+     *
+     * @param o element to be removed from this queue, if present
+     * @return {@code true} if removed
+     */
+    boolean removeEq(Object o) {
+        for (int i = 0; i < size; i++) {
+            if (o == queue[i]) {
+                removeAt(i);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Returns {@code true} if this queue contains the specified element.
+     * More formally, returns {@code true} if and only if this queue contains
+     * at least one element {@code e} such that {@code o.equals(e)}.
+     *
+     * @param o object to be checked for containment in this queue
+     * @return {@code true} if this queue contains the specified element
+     */
+    public boolean contains(Object o) {
+        return indexOf(o) != -1;
+    }
+
+    /**
+     * Returns an array containing all of the elements in this queue.
+     * The elements are in no particular order.
+     *
+     * <p>The returned array will be "safe" in that no references to it are
+     * maintained by this queue.  (In other words, this method must allocate
+     * a new array).  The caller is thus free to modify the returned array.
+     *
+     * <p>This method acts as bridge between array-based and collection-based
+     * APIs.
+     *
+     * @return an array containing all of the elements in this queue
+     */
+    public Object[] toArray() {
+        return Arrays.copyOf(queue, size);
+    }
+
+    /**
+     * Returns an array containing all of the elements in this queue; the
+     * runtime type of the returned array is that of the specified array.
+     * The returned array elements are in no particular order.
+     * If the queue fits in the specified array, it is returned therein.
+     * Otherwise, a new array is allocated with the runtime type of the
+     * specified array and the size of this queue.
+     *
+     * <p>If the queue fits in the specified array with room to spare
+     * (i.e., the array has more elements than the queue), the element in
+     * the array immediately following the end of the collection is set to
+     * {@code null}.
+     *
+     * <p>Like the {@link #toArray()} method, this method acts as bridge between
+     * array-based and collection-based APIs.  Further, this method allows
+     * precise control over the runtime type of the output array, and may,
+     * under certain circumstances, be used to save allocation costs.
+     *
+     * <p>Suppose {@code x} is a queue known to contain only strings.
+     * The following code can be used to dump the queue into a newly
+     * allocated array of {@code String}:
+     *
+     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
+     *
+     * Note that {@code toArray(new Object[0])} is identical in function to
+     * {@code toArray()}.
+     *
+     * @param a the array into which the elements of the queue are to
+     *          be stored, if it is big enough; otherwise, a new array of the
+     *          same runtime type is allocated for this purpose.
+     * @return an array containing all of the elements in this queue
+     * @throws ArrayStoreException if the runtime type of the specified array
+     *         is not a supertype of the runtime type of every element in
+     *         this queue
+     * @throws NullPointerException if the specified array is null
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T[] toArray(T[] a) {
+        final int size = this.size;
+        if (a.length < size)
+            // Make a new array of a's runtime type, but my contents:
+            return (T[]) Arrays.copyOf(queue, size, a.getClass());
+        System.arraycopy(queue, 0, a, 0, size);
+        if (a.length > size)
+            a[size] = null;
+        return a;
+    }
+
+    @SuppressWarnings("unchecked")
+    public E poll() {
+        if (size == 0)
+            return null;
+        int s = --size;
+        modCount++;
+        E result = (E) queue[0];
+        E x = (E) queue[s];
+        queue[s] = null;
+        if (s != 0)
+            siftDown(0, x);
+        return result;
+    }
+
+    /**
+     * Removes the ith element from queue.
+     *
+     * Normally this method leaves the elements at up to i-1,
+     * inclusive, untouched.  Under these circumstances, it returns
+     * null.  Occasionally, in order to maintain the heap invariant,
+     * it must swap a later element of the list with one earlier than
+     * i.  Under these circumstances, this method returns the element
+     * that was previously at the end of the list and is now at some
+     * position before i. This fact is used by iterator.remove so as to
+     * avoid missing traversing elements.
+     */
+    @SuppressWarnings("unchecked")
+    private E removeAt(int i) {
+        // assert i >= 0 && i < size;
+        modCount++;
+        int s = --size;
+        if (s == i) // removed last element
+            queue[i] = null;
+        else {
+            E moved = (E) queue[s];
+            queue[s] = null;
+            siftDown(i, moved);
+            if (queue[i] == moved) {
+                siftUp(i, moved);
+                if (queue[i] != moved)
+                    return moved;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Inserts item x at position k, maintaining heap invariant by
+     * promoting x up the tree until it is greater than or equal to
+     * its parent, or is the root.
+     *
+     * To simplify and speed up coercions and comparisons. the
+     * Comparable and Comparator versions are separated into different
+     * methods that are otherwise identical. (Similarly for siftDown.)
+     *
+     * 在位置 k 处插入项 x，通过在树中向上提升 x 来保持堆不变，直到它大于或等于其父级或成为根。
+     * 简化和加速强制和比较。
+     * Comparable 和 Comparator 版本分为不同的方法，这些方法在其他方面是相同的。（siftDown 也是如此。
+     *
+     * @param k the position to fill
+     * @param x the item to insert
+     */
+    private void siftUp(int k, E x) {
+        if (comparator != null)
+            siftUpUsingComparator(k, x);
+        else
+            siftUpComparable(k, x);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void siftUpComparable(int k, E x) {
+        Comparable<? super E> key = (Comparable<? super E>) x;
+        while (k > 0) {
+            int parent = (k - 1) >>> 1;
+            Object e = queue[parent];
+            if (key.compareTo((E) e) >= 0)
+                break;
+            queue[k] = e;
+            k = parent;
+        }
+        queue[k] = key;
+    }
+
+    /**
+     * 在 k 处的某个元素 x ，让其上升到正确的位置。
+     * @param k
+     * @param x
+     */
+    @SuppressWarnings("unchecked")
+    private void siftUpUsingComparator(int k, E x) {
+        // 不断调整 k，直到找到合适的位置
+        while (k > 0) {
+            int parent = (k - 1) >>> 1; // 父节点 无符号右移动 /2
+            Object e = queue[parent];
+            if (comparator.compare(x, (E) e) >= 0) // 如果优先级比父节点大，直接退出。表示已经到了合适的位置
+                // 如大顶堆中 7 3 4 插入 2 第一次就到了合适的位置 7 3 4 2
+                //  7 3 4 5 --- > 7 5 4 3 (5比父节点大，替换上去)
+                break;
+            queue[k] = e;
+            k = parent;
+        }
+        queue[k] = x; // 将 k 调整到了合适的位置
+    }
+
+    /**
+     * Inserts item x at position k, maintaining heap invariant by
+     * demoting x down the tree repeatedly until it is less than or
+     * equal to its children or is a leaf.
+     *
+     * @param k the position to fill
+     * @param x the item to insert
+     */
+    private void siftDown(int k, E x) {
+        if (comparator != null)
+            siftDownUsingComparator(k, x);
+        else
+            siftDownComparable(k, x);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void siftDownComparable(int k, E x) {
+        Comparable<? super E> key = (Comparable<? super E>)x;
+        int half = size >>> 1;        // loop while a non-leaf
+        while (k < half) {
+            int child = (k << 1) + 1; // assume left child is least
+            Object c = queue[child];
+            int right = child + 1;
+            if (right < size &&
+                    ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
+                c = queue[child = right];
+            if (key.compareTo((E) c) <= 0)
+                break;
+            queue[k] = c;
+            k = child;
+        }
+        queue[k] = key;
+    }
+
+    @SuppressWarnings("unchecked")
+    private void siftDownUsingComparator(int k, E x) {
+        int half = size >>> 1;
+        while (k < half) {
+            int child = (k << 1) + 1;
+            Object c = queue[child];
+            int right = child + 1;
+            if (right < size &&
+                    comparator.compare((E) c, (E) queue[right]) > 0)
+                c = queue[child = right];
+            if (comparator.compare(x, (E) c) <= 0)
+                break;
+            queue[k] = c;
+            k = child;
+        }
+        queue[k] = x;
+    }
+
+    /**
+     * Establishes the heap invariant (described above) in the entire tree,
+     * assuming nothing about the order of the elements prior to the call.
+     */
+    @SuppressWarnings("unchecked")
+    private void heapify() {
+        for (int i = (size >>> 1) - 1; i >= 0; i--)
+            siftDown(i, (E) queue[i]);
+    }
+
+
+    private static final long serialVersionUID = -7720805057305804111L;
+
+    private static final int DEFAULT_INITIAL_CAPACITY = 11;
+
+    transient Object[] queue; // non-private to simplify nested class access
+
+    private int size = 0;
+
+    private final Comparator<? super E> comparator;
+
+    /**
+     * The number of times this priority queue has been
+     * <i>structurally modified</i>.  See AbstractList for gory details.
+     */
+    transient int modCount = 0; // non-private to simplify nested class access
+
+    /**
+     * Creates a {@code PriorityQueue} with the default initial
+     * capacity (11) that orders its elements according to their
+     * {@linkplain Comparable natural ordering}.
+     */
+    public PriorityQueue() {
+        this(DEFAULT_INITIAL_CAPACITY, null);
+    }
+
+    public PriorityQueue(int initialCapacity) {
+        this(initialCapacity, null);
+    }
+
+    public PriorityQueue(Comparator<? super E> comparator) {
+        this(DEFAULT_INITIAL_CAPACITY, comparator);
+    }
+
+    public PriorityQueue(int initialCapacity,
+                         Comparator<? super E> comparator) {
+        // Note: This restriction of at least one is not actually needed,
+        // but continues for 1.5 compatibility
+        if (initialCapacity < 1)
+            throw new IllegalArgumentException();
+        this.queue = new Object[initialCapacity];
+        this.comparator = comparator;
+    }
+
+
+    @SuppressWarnings("unchecked")
+    public PriorityQueue(Collection<? extends E> c) {
+        if (c instanceof SortedSet<?>) {
+            SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
+            this.comparator = (Comparator<? super E>) ss.comparator();
+            initElementsFromCollection(ss);
+        }
+        else if (c instanceof PriorityQueue<?>) {
+            PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
+            this.comparator = (Comparator<? super E>) pq.comparator();
+            initFromPriorityQueue(pq);
+        }
+        else {
+            this.comparator = null;
+            initFromCollection(c);
+        }
+    }
+
+    /**
+     * Creates a {@code PriorityQueue} containing the elements in the
+     * specified priority queue.  This priority queue will be
+     * ordered according to the same ordering as the given priority
+     * queue.
+     *
+     * @param  c the priority queue whose elements are to be placed
+     *         into this priority queue
+     * @throws ClassCastException if elements of {@code c} cannot be
+     *         compared to one another according to {@code c}'s
+     *         ordering
+     * @throws NullPointerException if the specified priority queue or any
+     *         of its elements are null
+     */
+    @SuppressWarnings("unchecked")
+    public PriorityQueue(PriorityQueue<? extends E> c) {
+        this.comparator = (Comparator<? super E>) c.comparator();
+        initFromPriorityQueue(c);
+    }
+
+    @SuppressWarnings("unchecked")
+    public PriorityQueue(SortedSet<? extends E> c) {
+        this.comparator = (Comparator<? super E>) c.comparator();
+        initElementsFromCollection(c);
+    }
+
+    private void initFromPriorityQueue(PriorityQueue<? extends E> c) {
+        if (c.getClass() == PriorityQueue.class) {
+            this.queue = c.toArray();
+            this.size = c.size();
+        } else {
+            initFromCollection(c);
+        }
+    }
+
+    private void initElementsFromCollection(Collection<? extends E> c) {
+        Object[] a = c.toArray();
+        if (c.getClass() != ArrayList.class)
+            a = Arrays.copyOf(a, a.length, Object[].class);
+        int len = a.length;
+        if (len == 1 || this.comparator != null)
+            for (int i = 0; i < len; i++)
+                if (a[i] == null)
+                    throw new NullPointerException();
+        this.queue = a;
+        this.size = a.length;
+    }
+
+    private void initFromCollection(Collection<? extends E> c) {
+        initElementsFromCollection(c);
+        heapify();
+    }
+
+    /**
+     * The maximum size of array to allocate.
+     * Some VMs reserve some header words in an array.
+     * Attempts to allocate larger arrays may result in
+     * OutOfMemoryError: Requested array size exceeds VM limit
+     */
+    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
+
+    /**
+     * Increases the capacity of the array.
+     *
+     * @param minCapacity the desired minimum capacity
+     */
+    private void grow(int minCapacity) {
+        int oldCapacity = queue.length;
+        // Double size if small; else grow by 50%
+        int newCapacity = oldCapacity + ((oldCapacity < 64) ?
+                (oldCapacity + 2) :
+                (oldCapacity >> 1));
+        // overflow-conscious code
+        if (newCapacity - MAX_ARRAY_SIZE > 0)
+            newCapacity = hugeCapacity(minCapacity);
+        queue = Arrays.copyOf(queue, newCapacity);
+    }
+
+    private static int hugeCapacity(int minCapacity) {
+        if (minCapacity < 0) // overflow
+            throw new OutOfMemoryError();
+        return (minCapacity > MAX_ARRAY_SIZE) ?
+                Integer.MAX_VALUE :
+                MAX_ARRAY_SIZE;
+    }
+
+
+
+    /**
+     * Returns an iterator over the elements in this queue. The iterator
+     * does not return the elements in any particular order.
+     *
+     * @return an iterator over the elements in this queue
+     */
+    public Iterator<E> iterator() {
+        return new Itr();
+    }
+
+    private final class Itr implements Iterator<E> {
+        /**
+         * Index (into queue array) of element to be returned by
+         * subsequent call to next.
+         */
+        private int cursor = 0;
+
+        /**
+         * Index of element returned by most recent call to next,
+         * unless that element came from the forgetMeNot list.
+         * Set to -1 if element is deleted by a call to remove.
+         */
+        private int lastRet = -1;
+
+        /**
+         * A queue of elements that were moved from the unvisited portion of
+         * the heap into the visited portion as a result of "unlucky" element
+         * removals during the iteration.  (Unlucky element removals are those
+         * that require a siftup instead of a siftdown.)  We must visit all of
+         * the elements in this list to complete the iteration.  We do this
+         * after we've completed the "normal" iteration.
+         *
+         * We expect that most iterations, even those involving removals,
+         * will not need to store elements in this field.
+         */
+        private ArrayDeque<E> forgetMeNot = null;
+
+        /**
+         * Element returned by the most recent call to next iff that
+         * element was drawn from the forgetMeNot list.
+         */
+        private E lastRetElt = null;
+
+        /**
+         * The modCount value that the iterator believes that the backing
+         * Queue should have.  If this expectation is violated, the iterator
+         * has detected concurrent modification.
+         */
+        private int expectedModCount = modCount;
+
+        public boolean hasNext() {
+            return cursor < size ||
+                    (forgetMeNot != null && !forgetMeNot.isEmpty());
+        }
+
+        @SuppressWarnings("unchecked")
+        public E next() {
+            if (expectedModCount != modCount)
+                throw new ConcurrentModificationException();
+            if (cursor < size)
+                return (E) queue[lastRet = cursor++];
+            if (forgetMeNot != null) {
+                lastRet = -1;
+                lastRetElt = forgetMeNot.poll();
+                if (lastRetElt != null)
+                    return lastRetElt;
+            }
+            throw new NoSuchElementException();
+        }
+
+        public void remove() {
+            if (expectedModCount != modCount)
+                throw new ConcurrentModificationException();
+            if (lastRet != -1) {
+                E moved = PriorityQueue.this.removeAt(lastRet);
+                lastRet = -1;
+                if (moved == null)
+                    cursor--;
+                else {
+                    if (forgetMeNot == null)
+                        forgetMeNot = new ArrayDeque<>();
+                    forgetMeNot.add(moved);
+                }
+            } else if (lastRetElt != null) {
+                PriorityQueue.this.removeEq(lastRetElt);
+                lastRetElt = null;
+            } else {
+                throw new IllegalStateException();
+            }
+            expectedModCount = modCount;
+        }
+    }
+
+    public int size() {
+        return size;
+    }
+
+    /**
+     * Removes all of the elements from this priority queue.
+     * The queue will be empty after this call returns.
+     */
+    public void clear() {
+        modCount++;
+        for (int i = 0; i < size; i++)
+            queue[i] = null;
+        size = 0;
+    }
+
+    /**
+     * Returns the comparator used to order the elements in this
+     * queue, or {@code null} if this queue is sorted according to
+     * the {@linkplain Comparable natural ordering} of its elements.
+     *
+     * @return the comparator used to order this queue, or
+     *         {@code null} if this queue is sorted according to the
+     *         natural ordering of its elements
+     */
+    public Comparator<? super E> comparator() {
+        return comparator;
+    }
+
+    /**
+     * Saves this queue to a stream (that is, serializes it).
+     *
+     * @serialData The length of the array backing the instance is
+     *             emitted (int), followed by all of its elements
+     *             (each an {@code Object}) in the proper order.
+     * @param s the stream
+     */
+    private void writeObject(java.io.ObjectOutputStream s)
+            throws java.io.IOException {
+        // Write out element count, and any hidden stuff
+        s.defaultWriteObject();
+
+        // Write out array length, for compatibility with 1.5 version
+        s.writeInt(Math.max(2, size + 1));
+
+        // Write out all elements in the "proper order".
+        for (int i = 0; i < size; i++)
+            s.writeObject(queue[i]);
+    }
+
+    /**
+     * Reconstitutes the {@code PriorityQueue} instance from a stream
+     * (that is, deserializes it).
+     *
+     * @param s the stream
+     */
+    private void readObject(java.io.ObjectInputStream s)
+            throws java.io.IOException, ClassNotFoundException {
+        // Read in size, and any hidden stuff
+        s.defaultReadObject();
+
+        // Read in (and discard) array length
+        s.readInt();
+
+//        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, size);
+        queue = new Object[size];
+
+        // Read in all elements.
+        for (int i = 0; i < size; i++)
+            queue[i] = s.readObject();
+
+        // Elements are guaranteed to be in "proper order", but the
+        // spec has never explained what that might be.
+        heapify();
+    }
+
+//    /**
+//     * Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>
+//     * and <em>fail-fast</em> {@link Spliterator} over the elements in this
+//     * queue.
+//     *
+//     * <p>The {@code Spliterator} reports {@link Spliterator#SIZED},
+//     * {@link Spliterator#SUBSIZED}, and {@link Spliterator#NONNULL}.
+//     * Overriding implementations should document the reporting of additional
+//     * characteristic values.
+//     *
+//     * @return a {@code Spliterator} over the elements in this queue
+//     * @since 1.8
+//     */
+//    public final Spliterator<E> spliterator() {
+//        return new PriorityQueueSpliterator<E>(this, 0, -1, 0);
+//    }
+
+//    static final class PriorityQueueSpliterator<E> implements Spliterator<E> {
+//        /*
+//         * This is very similar to ArrayList Spliterator, except for
+//         * extra null checks.
+//         */
+//        private final PriorityQueue<E> pq;
+//        private int index;            // current index, modified on advance/split
+//        private int fence;            // -1 until first use
+//        private int expectedModCount; // initialized when fence set
+//
+//        /** Creates new spliterator covering the given range */
+//        PriorityQueueSpliterator(PriorityQueue<E> pq, int origin, int fence,
+//                                 int expectedModCount) {
+//            this.pq = pq;
+//            this.index = origin;
+//            this.fence = fence;
+//            this.expectedModCount = expectedModCount;
+//        }
+//
+//        private int getFence() { // initialize fence to size on first use
+//            int hi;
+//            if ((hi = fence) < 0) {
+//                expectedModCount = pq.modCount;
+//                hi = fence = pq.size;
+//            }
+//            return hi;
+//        }
+//
+//        public PriorityQueueSpliterator<E> trySplit() {
+//            int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
+//            return (lo >= mid) ? null :
+//                    new PriorityQueueSpliterator<E>(pq, lo, index = mid,
+//                            expectedModCount);
+//        }
+//
+//        @SuppressWarnings("unchecked")
+//        public void forEachRemaining(Consumer<? super E> action) {
+//            int i, hi, mc; // hoist accesses and checks from loop
+//            PriorityQueue<E> q; Object[] a;
+//            if (action == null)
+//                throw new NullPointerException();
+//            if ((q = pq) != null && (a = q.queue) != null) {
+//                if ((hi = fence) < 0) {
+//                    mc = q.modCount;
+//                    hi = q.size;
+//                }
+//                else
+//                    mc = expectedModCount;
+//                if ((i = index) >= 0 && (index = hi) <= a.length) {
+//                    for (E e;; ++i) {
+//                        if (i < hi) {
+//                            if ((e = (E) a[i]) == null) // must be CME
+//                                break;
+//                            action.accept(e);
+//                        }
+//                        else if (q.modCount != mc)
+//                            break;
+//                        else
+//                            return;
+//                    }
+//                }
+//            }
+//            throw new ConcurrentModificationException();
+//        }
+//
+//        public boolean tryAdvance(Consumer<? super E> action) {
+//            if (action == null)
+//                throw new NullPointerException();
+//            int hi = getFence(), lo = index;
+//            if (lo >= 0 && lo < hi) {
+//                index = lo + 1;
+//                @SuppressWarnings("unchecked") E e = (E)pq.queue[lo];
+//                if (e == null)
+//                    throw new ConcurrentModificationException();
+//                action.accept(e);
+//                if (pq.modCount != expectedModCount)
+//                    throw new ConcurrentModificationException();
+//                return true;
+//            }
+//            return false;
+//        }
+//
+//        public long estimateSize() {
+//            return (long) (getFence() - index);
+//        }
+//
+//        public int characteristics() {
+//            return Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.NONNULL;
+//        }
+//    }
+}

src/main/java/cn/whaifree/designPattern/StrategyPattern.java

@@ -1,5 +1,10 @@
 package cn.whaifree.designPattern;
 
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.concurrent.ConcurrentHashMap;
+
 public class StrategyPattern {
 
     enum PayType{
@@ -64,3 +69,127 @@ public class StrategyPattern {
         new PayService().pay(2);
     }
 }
+
+
+/**
+ * 在 springboot 中使用策略模式
+ *
+ * 1. 使用 Map<String,OprImpl>将接口转为 Map<Opr,OprImpl>
+ * 2. 根据 Opr 在 Context 中操作
+ *
+ * 优点：新增操作只要加 类、操作（开闭，扩展开、修改闭），而不用修改原始代码 ifelse 这样
+ *      每个操作独立，不影响其他操作
+ *
+ */
+@Component
+class Opr{
+    @Autowired
+    private OperationContext context;
+
+
+    enum OprEnum{
+        FAVOR(1),
+        COMMENT(2),
+        ;
+        int oprNum = 0;
+
+        OprEnum(int oprNum) {
+            this.oprNum = oprNum;
+        }
+    }
+
+    interface BlogOperation{
+        void operation(String data);
+    }
+
+    @Component
+    static class FavorOperation implements  BlogOperation{
+        @Override
+        public void operation(String data) {
+            // 操作数据库
+            System.out.println("点赞" + data);
+        }
+    }
+
+    @Component
+    static class CommentOperation implements  BlogOperation{
+        @Override
+        public void operation(String data) {
+            // 操作数据库
+            System.out.println("评论" + data);
+        }
+    }
+
+    @Component
+    static class OperationContext{
+        private ConcurrentHashMap<OprEnum, BlogOperation> map = null;
+
+        /**
+         *
+         * @param blogOperationConcurrentHashMap
+         */
+        @Autowired
+        public OperationContext(ConcurrentHashMap<String, BlogOperation> blogOperationConcurrentHashMap) {
+            map = new ConcurrentHashMap<>();
+            map.put(OprEnum.FAVOR, blogOperationConcurrentHashMap.get("favorOperation"));
+            map.put(OprEnum.COMMENT, blogOperationConcurrentHashMap.get("commentOperation"));
+        }
+
+        public void opr(BlogOperation blogOperation, String data) {
+            BlogOperation opr = map.get(blogOperation);
+            opr.operation(data);
+        }
+
+    }
+
+
+}
+
+enum OperationEnum{
+
+    FAVOUR(1, "点赞", new Operation() {
+        @Override
+        public Object action(OperationEnum operationEnum) {
+
+            return null;
+        }
+    }),
+    COMMENT(2,"评论", new Operation() {
+        @Override
+        public Object action(OperationEnum operationEnum) {
+            return null;
+        }
+    });
+
+
+    int code;
+    String oprName;
+    Operation oprExecution;
+
+
+    OperationEnum(int code, String oprName, Operation operation) {
+        this.code = code;
+        this.oprName = oprName;
+        this.oprExecution = operation;
+    }
+
+
+}
+
+interface Operation{
+    Object action(OperationEnum operationEnum);
+}
+
+
+
+class HiShareStrategyPattern{
+
+
+
+    public static void main(String[] args) {
+
+    }
+}
+
+
+

src/main/java/cn/whaifree/leetCode/Array/LeetCode215.java

@@ -12,11 +12,16 @@ public class LeetCode215 {
     @Test
     public void main()
     {
-        int[] nums = {3,2,1,5,6,4};
+        int i = 0;
-        int k = 2;
+        while (true) {
-        Solution solution = new Solution();
+            i++;
-        int i = solution.findKthLargest(nums, k);
+        }
-        System.out.println(i);
+//
+//        int[] nums = {3,2,1,5,6,4};
+//        int k = 2;
+//        Solution solution = new Solution();
+//        int i = solution.findKthLargest(nums, k);
+//        System.out.println(i);
     }
 
     class Solution {

src/main/java/cn/whaifree/test/hashDB.java

@@ -1,5 +1,9 @@
 package cn.whaifree.test;
 
+import java.util.ArrayList;
+import java.util.ConcurrentModificationException;
+import java.util.ListIterator;
+
 /**
  * @version 1.0
  * @Author whai文海
@@ -41,3 +45,42 @@ public class hashDB {
 
 
 }
+
+class test{
+
+    public static void main(String[] args) {
+        ArrayList<String> sharedList= new ArrayList<>();
+
+        new Thread(() -> {
+            try {
+                for (int i = 0; i < 10; i++) {
+                    sharedList.add("Item " + i);
+                    // 模拟一些工作时间
+                    Thread.sleep(50);
+                }
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                System.out.println("Thread was interrupted.");
+            }
+        }).start();
+
+
+        new Thread(() -> {
+            try {
+                ListIterator<String> iterator = sharedList.listIterator();
+                while (iterator.hasNext()) {
+                    System.out.println(iterator.next());
+                    // 模拟一些工作时间
+                    Thread.sleep(100);
+                }
+            } catch (ConcurrentModificationException e) {
+                System.out.println("Caught ConcurrentModificationException during iteration.");
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                System.out.println("Thread was interrupted.");
+            }
+        }).start();
+
+
+    }
+}