// Copyright (c) 2003-2009, Jodd Team (jodd.org). All Rights Reserved.
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.IOException;
/**
* ArrayList of boolean primitives.
*/
public class BooleanArrayList implements Serializable {
private boolean[] array;
private int size;
public static int initialCapacity = 10;
/**
* Constructs an empty list with an initial capacity.
*/
public BooleanArrayList() {
this(initialCapacity);
}
/**
* Constructs an empty list with the specified initial capacity.
*/
public BooleanArrayList(int initialCapacity) {
if (initialCapacity < 0) {
throw new IllegalArgumentException("Capacity can't be negative: " + initialCapacity);
}
array = new boolean[initialCapacity];
size = 0;
}
/**
* Constructs a list containing the elements of the specified array.
* The list instance has an initial capacity of 110% the size of the specified array.
*/
public BooleanArrayList(boolean[] data) {
array = new boolean[(int) (data.length * 1.1) + 1];
size = data.length;
System.arraycopy(data, 0, array, 0, size);
}
// ---------------------------------------------------------------- conversion
/**
* Returns an array containing all of the elements in this list in the correct order.
*/
public boolean[] toArray() {
boolean[] result = new boolean[size];
System.arraycopy(array, 0, result, 0, size);
return result;
}
// ---------------------------------------------------------------- methods
/**
* Returns the element at the specified position in this list.
*/
public boolean get(int index) {
checkRange(index);
return array[index];
}
/**
* Returns the number of elements in this list.
*/
public int size() {
return size;
}
/**
* Removes the element at the specified position in this list.
* Shifts any subsequent elements to the left (subtracts
* one from their indices).
*
* @param index the index of the element to remove
* @return the value of the element that was removed
* @throws UnsupportedOperationException when this operation is not
* supported
* @throws IndexOutOfBoundsException if the specified index is out of range
*/
public boolean remove(int index) {
checkRange(index);
boolean oldval = array[index];
int numtomove = size - index - 1;
if (numtomove > 0) {
System.arraycopy(array, index + 1, array, index, numtomove);
}
size--;
return oldval;
}
/**
* Removes from this list all of the elements whose index is between fromIndex,
* inclusive and toIndex, exclusive. Shifts any succeeding elements to the left (reduces their index).
*/
public void removeRange(int fromIndex, int toIndex) {
checkRange(fromIndex);
checkRange(toIndex);
if (fromIndex >= toIndex) {
return;
}
int numtomove = size - toIndex;
if (numtomove > 0) {
System.arraycopy(array, toIndex, array, fromIndex, numtomove);
}
size -= (toIndex - fromIndex);
}
/**
* Replaces the element at the specified position in this list with the specified element.
*
* @param index the index of the element to change
* @param element the value to be stored at the specified position
* @return the value previously stored at the specified position
*/
public boolean set(int index, boolean element) {
checkRange(index);
boolean oldval = array[index];
array[index] = element;
return oldval;
}
/**
* Appends the specified element to the end of this list.
*/
public void add(boolean element) {
ensureCapacity(size + 1);
array[size++] = element;
}
/**
* Inserts the specified element at the specified position in this list.
* Shifts the element currently at that position (if any) and any subsequent
* elements to the right (adds one to their indices).
*
* @param index the index at which to insert the element
* @param element the value to insert
*/
public void add(int index, boolean element) {
checkRangeIncludingEndpoint(index);
ensureCapacity(size + 1);
int numtomove = size - index;
System.arraycopy(array, index, array, index + 1, numtomove);
array[index] = element;
size++;
}
/**
* Appends all of the elements in the specified array to the end of this list.
*/
public void addAll(boolean[] data) {
int dataLen = data.length;
if (dataLen == 0) {
return;
}
int newcap = size + (int) (dataLen * 1.1) + 1;
ensureCapacity(newcap);
System.arraycopy(data, 0, array, size, dataLen);
size += dataLen;
}
/**
* Appends all of the elements in the specified array at the specified position in this list.
*/
public void addAll(int index, boolean[] data) {
int dataLen = data.length;
if (dataLen == 0) {
return;
}
int newcap = size + (int) (dataLen * 1.1) + 1;
ensureCapacity(newcap);
System.arraycopy(array, index, array, index + dataLen, size - index);
System.arraycopy(data, 0, array, index, dataLen);
size += dataLen;
}
/**
* Removes all of the elements from this list.
* The list will be empty after this call returns.
*/
public void clear() {
size = 0;
}
// ---------------------------------------------------------------- search
/**
* Returns true if this list contains the specified element.
*/
public boolean contains(boolean data) {
for (int i = 0; i < size; i++) {
if (array[i] == data) {
return true;
}
}
return false;
}
/**
* Searches for the first occurence of the given argument.
*/
public int indexOf(boolean data) {
for (int i = 0; i < size; i++) {
if (array[i] == data) {
return i;
}
}
return -1;
}
/**
* Returns the index of the last occurrence of the specified object in this list.
*/
public int lastIndexOf(boolean data) {
for (int i = size - 1; i >= 0; i--) {
if (array[i] == data) {
return i;
}
}
return -1;
}
/**
* Tests if this list has no elements.
*/
public boolean isEmpty() {
return size == 0;
}
// ---------------------------------------------------------------- capacity
/**
* Increases the capacity of this ArrayList instance, if necessary,
* to ensure that it can hold at least the number of elements specified by
* the minimum capacity argument.
*/
public void ensureCapacity(int mincap) {
if (mincap > array.length) {
int newcap = ((array.length * 3) >> 1) + 1;
boolean[] olddata = array;
array = new boolean[newcap < mincap ? mincap : newcap];
System.arraycopy(olddata, 0, array, 0, size);
}
}
/**
* Trims the capacity of this instance to be the list's current size.
* An application can use this operation to minimize the storage of some instance.
*/
public void trimToSize() {
if (size < array.length) {
boolean[] olddata = array;
array = new boolean[size];
System.arraycopy(olddata, 0, array, 0, size);
}
}
// ---------------------------------------------------------------- serializable
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(array.length);
for (int i = 0; i < size; i++) {
out.writeBoolean(array[i]);
}
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
array = new boolean[in.readInt()];
for (int i = 0; i < size; i++) {
array[i] = in.readBoolean();
}
}
// ---------------------------------------------------------------- privates
private void checkRange(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index should be at least 0 and less than " + size + ", found " + index);
}
}
private void checkRangeIncludingEndpoint(int index) {
if (index < 0 || index > size) {
throw new IndexOutOfBoundsException("Index should be at least 0 and at most " + size + ", found " + index);
}
}
}
|