cern.colt.list.tlong.SimpleLongArrayList Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of parallelcolt Show documentation
Parallel Colt is a multithreaded version of Colt - a library for high performance scientific computing in Java. It contains efficient algorithms for data analysis, linear algebra, multi-dimensional arrays, Fourier transforms, statistics and histogramming.
The newest version!
/*
Copyright (C) 1999 CERN - European Organization for Nuclear Research.
Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose 
is hereby granted without fee, provided that the above copyright notice appear in all copies and 
that both that copyright notice and this permission notice appear in supporting documentation. 
CERN makes no representations about the suitability of this software for any purpose. 
It is provided "as is" without expressed or implied warranty.
 */
package cern.colt.list.tlong;

/**
 * Resizable list holding long elements; implemented with arrays;
 * not efficient; just to demonstrate which methods you must override to
 * implement a fully functional list. First see the package summary and javadoc tree view to get the broad picture.
 */
public class SimpleLongArrayList extends AbstractLongList {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    /**
     * The array buffer into which the elements of the list are stored. The
     * capacity of the list is the length of this array buffer.
     * 
     * @serial
     */
    protected long[] elements;

    /**
     * The size of the list.
     * 
     * @serial
     */
    protected int size;

    /**
     * Constructs an empty list.
     */
    public SimpleLongArrayList() {
        this(10);
    }

    /**
     * Constructs a list containing the specified elements. The initial size and
     * capacity of the list is the length of the array.
     * 
     * WARNING: For efficiency reasons and to keep memory usage low,
     * the array is not copied. So if subsequently you modify the
     * specified array directly via the [] operator, be sure you know what
     * you're doing.
     * 
     * @param elements
     *            the array to be backed by the the constructed list
     */
    public SimpleLongArrayList(long[] elements) {
        elements(elements);
    }

    /**
     * Constructs an empty list with the specified initial capacity.
     * 
     * @param initialCapacity
     *            the number of elements the receiver can hold without
     *            auto-expanding itself by allocating new internal memory.
     */
    public SimpleLongArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);

        this.elements(new long[initialCapacity]);
        size = 0;
    }

    /**
     * Ensures that the receiver can hold at least the specified number of
     * elements without needing to allocate new internal memory. If necessary,
     * allocates new internal memory and increases the capacity of the receiver.
     * 
     * @param minCapacity
     *            the desired minimum capacity.
     */

    public void ensureCapacity(int minCapacity) {
        elements = cern.colt.Arrays.ensureCapacity(elements, minCapacity);
    }

    /**
     * Returns the element at the specified position in the receiver;
     * WARNING: Does not check preconditions. Provided with invalid
     * parameters this method may return invalid elements without throwing any
     * exception! You should only use this method when you are absolutely
     * sure that the index is within bounds. Precondition (unchecked):
     * index >= 0 && index < size().
     * 
     * @param index
     *            index of element to return.
     */

    protected long getQuick(int index) {
        return elements[index];
    }

    /**
     * Replaces the element at the specified position in the receiver with the
     * specified element; WARNING: Does not check preconditions. Provided
     * with invalid parameters this method may access invalid indexes without
     * throwing any exception! You should only use this method when you are
     * absolutely sure that the index is within bounds. Precondition
     * (unchecked): index >= 0 && index < size().
     * 
     * @param index
     *            index of element to replace.
     * @param element
     *            element to be stored at the specified position.
     */

    protected void setQuick(int index, long element) {
        elements[index] = element;
    }

    /**
     * Trims the capacity of the receiver to be the receiver's current size. An
     * application can use this operation to minimize the storage of the
     * receiver.
     */

    public void trimToSize() {
        elements = cern.colt.Arrays.trimToCapacity(elements, size());
    }
}