array.java

java 的源代码

package com.reddragon2046.base.utilities.data;

import java.util.*;

// Referenced classes of package com.reddragon2046.base.utilities.data:
//            AbstractSequence, SequenceIterator, ForwardIterator, InputIterator,
//            Algos

public class Array extends AbstractSequence
{

    public Array()
    {
        clear();
    }

    public Array(int size)
    {
        if(size < 0)
        {
            throw new IllegalArgumentException("Attempt to create an Array with a negative size");
        } else
        {
            myLength = size;
            myStorage = new Object[myLength];
            return;
        }
    }

    public Array(int size, Object object)
    {
        this(size);
        for(int i = 0; i < myLength; i++)
            myStorage[i] = object;

    }

    public Array(Object array[])
    {
        myLength = array.length;
        myStorage = new Object[myLength];
        System.arraycopy(((Object) (array)), 0, ((Object) (myStorage)), 0, myLength);
    }

    public Array(Collection c)
    {
        myStorage = new Object[c.size()];
        myLength = 0;
        addAll(c);
    }

    public Object clone()
    {
        return new Array(this);
    }

    public String toString()
    {
        return Algos.toString(this, "Array");
    }

    public int size()
    {
        return myLength;
    }

    public void clear()
    {
        myStorage = new Object[10];
        myLength = 0;
    }

    public SequenceIterator begin()
    {
        return new SequenceIterator(this, 0);
    }

    public ForwardIterator start()
    {
        return begin();
    }

    public SequenceIterator end()
    {
        return new SequenceIterator(this, myLength);
    }

    public ForwardIterator finish()
    {
        return end();
    }

    public Iterator iterator()
    {
        return begin();
    }

    public void add(int index, Object object)
    {
        checkIndex(index, myLength + 1);
        if(myLength != myStorage.length)
        {
            if(index != myLength)
                System.arraycopy(((Object) (myStorage)), index, ((Object) (myStorage)), index + 1, myLength - index);
        } else
        {
            Object tmp[] = getNextStorage(1);
            System.arraycopy(((Object) (myStorage)), 0, ((Object) (tmp)), 0, index);
            System.arraycopy(((Object) (myStorage)), index, ((Object) (tmp)), index + 1, myLength - index);
            myStorage = tmp;
        }
        myStorage[index] = object;
        myLength++;
    }

    public boolean contains(Object object)
    {
        return indexOf(object) != -1;
    }

    public boolean remove(Object object)
    {
        return remove(object, 1) == 1;
    }

    public Object get(int index)
    {
        checkIndex(index, myLength);
        return myStorage[index];
    }

    public int indexOf(Object object)
    {
        return indexOf(object, 0, myLength - 1);
    }

    public int indexOf(Object object, int index)
    {
        return indexOf(object, index, myLength - 1);
    }

    public int indexOf(Object object, int first, int last)
    {
        if(last < first)
        {
            return -1;
        } else
        {
            checkRange(first, last, myLength);
            int index = ((SequenceIterator)Algos.find(new SequenceIterator(this, first), new SequenceIterator(this, last + 1), object)).index();
            return index != last + 1 ? index : -1;
        }
    }

    public int lastIndexOf(Object object)
    {
        return lastIndexOf(object, 0, myLength - 1);
    }

    public int lastIndexOf(Object object, int index)
    {
        return lastIndexOf(object, index, myLength - 1);
    }

    public int lastIndexOf(Object object, int first, int last)
    {
        if(last < first)
        {
            return -1;
        } else
        {
            checkRange(first, last, myLength);
            int index = ((SequenceIterator)Algos.lastFind(new SequenceIterator(this, first), new SequenceIterator(this, last + 1), object)).index();
            return index != last + 1 ? index : -1;
        }
    }

    public Object remove(int index)
    {
        checkIndex(index, myLength);
        Object retval = myStorage[index];
        System.arraycopy(((Object) (myStorage)), index + 1, ((Object) (myStorage)), index, myLength - index - 1);
        myStorage[--myLength] = null;
        return retval;
    }

    public Object set(int index, Object object)
    {
        checkIndex(index, myLength);
        Object retval = myStorage[index];
        myStorage[index] = object;
        return retval;
    }

    public boolean containsAll(Collection c)
    {
        return this != c ? super.containsAll(c) : true;
    }

    public boolean addAll(Collection c)
    {
        return this != c ? super.addAll(c) : false;
    }

    public boolean addAll(int index, Collection c)
    {
        if(this != c)
            return super.addAll(index, c);
        if(myLength == 0)
        {
            return false;
        } else
        {
            super.addAll(index, new Array(c));
            return true;
        }
    }

    public boolean removeAll(Collection c)
    {
        if(this == c)
        {
            clear();
            return true;
        } else
        {
            return super.removeAll(c);
        }
    }

    public boolean retainAll(Collection c)
    {
        return this != c ? super.retainAll(c) : false;
    }

    public void copy(Collection c)
    {
        if(this == c)
            return;
        if(c instanceof Array)
        {
            Array array = (Array)c;
            if(array.myLength > myStorage.length)
            {
                myStorage = new Object[array.myLength];
                System.arraycopy(((Object) (array.myStorage)), 0, ((Object) (myStorage)), 0, array.myLength);
            } else
            if(myLength > array.myLength)
            {
                System.arraycopy(((Object) (array.myStorage)), 0, ((Object) (myStorage)), 0, array.myLength);
                for(int i = array.myLength; i < myLength; i++)
                    myStorage[i] = null;

            } else
            {
                System.arraycopy(((Object) (array.myStorage)), 0, ((Object) (myStorage)), 0, array.myLength);
            }
        } else
        {
            clear();
            super.addAll(c);
        }
    }

    public void copyTo(Object array[])
    {
        if(myLength < array.length)
            System.arraycopy(((Object) (myStorage)), 0, ((Object) (array)), 0, myLength);
        else
            System.arraycopy(((Object) (myStorage)), 0, ((Object) (array)), 0, array.length);
    }

    public int capacity()
    {
        return myStorage.length;
    }

    public void insert(SequenceIterator pos, int n, Object object)
    {
        if(pos.getCollection() != this)
        {
            throw new IllegalArgumentException("Iterator not for this Array");
        } else
        {
            insert(pos.index(), n, object);
            return;
        }
    }

    public void insert(SequenceIterator pos, Object object)
    {
        insert(pos, 1, object);
    }

    public void insert(int index, int n, Object object)
    {
        if(n < 0)
            throw new IllegalArgumentException("Attempt to insert a negative number of objects.");
        checkIndex(index, myLength + 1);
        if(n == 0)
            return;
        if(myStorage.length - myLength >= n)
        {
            System.arraycopy(((Object) (myStorage)), index, ((Object) (myStorage)), index + n, myLength - index);
        } else
        {
            Object tmp[] = getNextStorage(n);
            System.arraycopy(((Object) (myStorage)), 0, ((Object) (tmp)), 0, index);
            System.arraycopy(((Object) (myStorage)), index, ((Object) (tmp)), index + n, myLength - index);
            myStorage = tmp;
        }
        for(int i = index; i < index + n; i++)
            myStorage[i] = object;

        myLength += n;
    }

    public void insert(SequenceIterator pos, InputIterator first, InputIterator last)
    {
        if(pos.getCollection() != this)
        {
            throw new IllegalArgumentException("Iterator not for this Array");
        } else
        {
            insert(pos.index(), first, last);
            return;
        }
    }

    public void insert(SequenceIterator pos, ForwardIterator first, ForwardIterator last)
    {
        if(pos.getCollection() != this)
        {
            throw new IllegalArgumentException("Iterator not for this Array");
        } else
        {
            insert(pos.index(), first, last);
            return;
        }
    }

    public void insert(int index, InputIterator first, InputIterator last)
    {
        if(!first.isCompatibleWith(last))
            throw new IllegalArgumentException("iterators not compatible");
        checkIndex(index, myLength + 1);
        if((first instanceof ForwardIterator) && (last instanceof ForwardIterator))
        {
            insert(index, (ForwardIterator)first, (ForwardIterator)last);
            return;
        }
        SequenceIterator pos = new SequenceIterator(this, index);
        for(InputIterator firstx = (InputIterator)first.clone(); !firstx.equals(last); pos.advance())
            pos.add(firstx.next());

    }

    public void insert(int index, ForwardIterator first, ForwardIterator last)
    {
        if(!first.isCompatibleWith(last))
            throw new IllegalArgumentException("iterators not compatible");
        checkIndex(index, myLength + 1);
        int n = first.distance(last);
        if(n == 0)
            return;
        ForwardIterator firstx = (ForwardIterator)first.clone();
        if(myStorage.length - myLength >= n)
        {
            System.arraycopy(((Object) (myStorage)), index, ((Object) (myStorage)), index + n, myLength - index);
        } else
        {
            Object tmp[] = getNextStorage(n);
            System.arraycopy(((Object) (myStorage)), 0, ((Object) (tmp)), 0, index);
            System.arraycopy(((Object) (myStorage)), index, ((Object) (tmp)), index + n, myLength - index);
            myStorage = tmp;
        }
        for(int i = index; i < index + n; i++)
            myStorage[i] = firstx.next();

        myLength += n;
    }

    public void swap(Array array)
    {
        int oldSize = myLength;
        Object oldStorage[] = myStorage;
        myLength = array.myLength;
        myStorage = array.myStorage;
        array.myLength = oldSize;
        array.myStorage = oldStorage;
    }

    public boolean add(Object object)
    {
        if(myLength == myStorage.length)
        {
            Object tmp[] = getNextStorage(1);
            System.arraycopy(((Object) (myStorage)), 0, ((Object) (tmp)), 0, myLength);
            myStorage = tmp;
        }
        myStorage[myLength++] = object;
        return true;
    }

    public void trimToSize()
    {
        if(myLength < myStorage.length)
        {
            Object oldData[] = myStorage;
            myStorage = new Object[myLength];
            System.arraycopy(((Object) (oldData)), 0, ((Object) (myStorage)), 0, myLength);
        }
    }

    public void ensureCapacity(int n)
    {
        if(n < 0)
            throw new IllegalArgumentException("Attempt to reserve a negative size.");
        if(myStorage.length < n)
        {
            Object tmp[] = new Object[n];
            if(myLength > 0)
                System.arraycopy(((Object) (myStorage)), 0, ((Object) (tmp)), 0, myLength);
            myStorage = tmp;
        }
    }

    public void setSize(int newSize)
    {
        if(newSize < 0)
            throw new IllegalArgumentException("Attempt to become a negative size.");
        if(myLength > newSize)
            removeRange(newSize, myLength - 1);
        else
        if(myLength < newSize)
            insert(myLength, newSize - myLength, null);
    }

    protected static final void checkIndex(int i, int size)
    {
        if(i < 0 || i >= size)
            throw new IndexOutOfBoundsException("Attempt to access index " + i + "; valid range is 0.." + (size - 1));
        else
            return;
    }

    protected static final void checkRange(int lo, int hi, int size)
    {
        checkIndex(lo, size);
        checkIndex(hi, size);
    }

    static final int getNextSize(int cursize)
    {
        int newSize = cursize <= 2000 ? cursize * 2 : cursize + 2000;
        return Math.max(1, newSize);
    }

    private Object[] getNextStorage(int n)
    {
        int newSize = Math.max(getNextSize(myLength), myLength + n);
        Object tmp[] = new Object[newSize];
        return tmp;
    }

    Object myStorage[];
    int myLength;
    static final int DEFAULT_SIZE = 10;
    static final int THRESHOLD = 2000;
    static final int MULTIPLIER = 2;
    static final long serialVersionUID = 0x24165f7afb64190cL;
}