Java_集合_PriorityQueue(5)

1，储存方式

PriorityQueue的储存方式和ArrayList相同，都是通过 变长数组实现的。

唯一不同的则是，每次储存数据都会进行一次排序，从而保证储存内容是有序的

ArrayList储存方式：http://blog.youkuaiyun.com/u014803950/article/details/79613885

2，自增方式

    public boolean add(E e) {
        return offer(e);
    }
	
    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;
    }
	
    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));
			
        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;
    }
	
    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;
    }
	
    @SuppressWarnings("unchecked")
    private void siftUpUsingComparator(int k, E x) {
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (comparator.compare(x, (E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = x;
    }

1）每次增加数据之前，实现“容量不足时，扩容”+“排序”

这一篇，没什么内容，之所以作为一篇，看中的是一种思想：在储存数据之前，可以对数据进行处理，从而保证在使用时的方便。