Create a Char Array List in Java

Description

The following code shows how to create a Char Array List.

Example


/*  w w  w.j  a  v a  2  s . c o  m*/
// 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 char primitives.
 */
public class CharArrayList implements Serializable {

  private char[] array;
  private int size;

  public static int initialCapacity = 10;

  /**
   * Constructs an empty list with an initial capacity.
   */
  public CharArrayList() {
    this(initialCapacity);
  }

  /**
   * Constructs an empty list with the specified initial capacity.
   */
  public CharArrayList(int initialCapacity) {
    if (initialCapacity < 0) {
      throw new IllegalArgumentException("Capacity can't be negative: " + initialCapacity);
    }
    array = new char[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 CharArrayList(char[] data) {
    array = new char[(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 char[] toArray() {
    char[] result = new char[size];
    System.arraycopy(array, 0, result, 0, size);
    return result;
  }

  // ---------------------------------------------------------------- methods

  /**
   * Returns the element at the specified position in this list.
   */
  public char 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 char remove(int index) {
    checkRange(index);
    char 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 char set(int index, char element) {
    checkRange(index);
    char oldval = array[index];
    array[index] = element;
    return oldval;
  }

  /**
   * Appends the specified element to the end of this list.
   */
  public void add(char 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, char 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(char[] 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, char[] 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(char 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(char 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(char 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;
      char[] olddata = array;
      array = new char[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) {
      char[] olddata = array;
      array = new char[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.writeChar(array[i]);
    }
  }

  private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    in.defaultReadObject();
    array = new char[in.readInt()];
    for (int i = 0; i < size; i++) {
      array[i] = in.readChar();
    }
  }

  // ---------------------------------------------------------------- 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);
    }
  }

}




















Home »
  Java Tutorial »
    Java Collection »




Java ArrayList
Java Collection
Java Comparable
Java Comparator
Java HashMap
Java HashSet
Java Iterator
Java LinkedHashMap
Java LinkedHashSet
Java LinkedList
Java List
Java ListIterator
Java Map
Queue
Java Set
Stack
Java TreeMap
TreeSet