Wizard pour la création d'une liste dynamique d'objets

Ce Wizard génère une liste dynamique d'objets implémentée sous forme d'un tableau dont la taille peut varier.
Depuis la version 1.1, vous pouvez aussi générer un tableau de types de base (int, float, double ...).
Depuis la version 1.2, vous pouvez choisir l'implémentation de liste entre : [Internal], ArrayList, Vector, LinkedList, Stack.
Contrairement à une ArrayList, à un Vector, ect .., on ne peut pas mélanger les types insérés dans cette liste.

La liste construite n'est pas une java.util.List. Le nom des méthodes y resemble mais elle n'est pas polymorphique.
Pour générer une liste dynamique typée il faut :

Préciser le nom de la liste

Préciser le type des objets qui sont à placer dans la liste. Ou, depuis la version 1.1, un type de base comme int, float, boolean, long, short, byte, double, char.

Depuis la version 1.2 : Préciser le type de liste à utiliser. Vous avez le choix entre [Internal], ArrayList, Vector, LinkedList, Stack. Dans les 4 derniers cas, si vous placez un type de base dans la liste se dernier sera wrappé dans sa classe Object correspondante (int->Integer, float->Float ...).

Voici un exemple d'une classe Java générée par le plugin, il s'agit d'une liste dynamique de java.lang.String utilisant le model [Internal]:

public class StringList {

  /** This is the list of object. */
  protected String[] itsList;

  /** The occuped size. */
  protected int occupedSize;

  /**
   * Constructor of the object. <br>  
   */
  public StringList() {
    this(10);
  }

  /**
   * Constructor of the object. <br>  
   * 
   * @param aSize fixed length of the list
   */
  public StringList(int aSize) {
    super();
    if (aSize < 0) {
      throw new IllegalArgumentException("Size must be >=0");
    }
    this.itsList = new String[aSize];
    this.occupedSize = 0;
  }

  /**
   * Constructor of the object. <br>  
   * 
   * @param aList a list that will be used for the initialization of this array
   * @param doCopy if true will make a copy of the array given in parameter
   */
  public StringList(String[] aList, boolean doCopy) {
    super();
    this.itsList = new String[aList.length];
    if (doCopy) {
      System.arraycopy(aList, 0, this.itsList, 0, aList.length);
    } else {
      for (int i = 0; i < aList.length; i++) {
        this.itsList[i] = aList[i];
      }
    }
    this.occupedSize = aList.length;
  }

  /**
   * Gives a string representation of this object. <br>  
   * 
   * @return a String representation of this object
   */
  public String toString() {
    StringBuffer sb = new StringBuffer(128);
    sb.append('{');
    for (int i = 0; i < this.occupedSize; i++) {
      sb.append(this.itsList[i]);
      sb.append(", ");
    }
    if (this.occupedSize > 0) {
      sb.delete(sb.length() - 2, sb.length());
    }
    sb.append('}');
    return sb.toString();
  }

  /**
   * Validates the index value. <br>  
   * 
   * @param anIndex index of the object to find
   * @return true if the index is valid, false if not
   */
  public boolean check(int anIndex) {
    return ((anIndex >= 0) && (anIndex < occupedSize));
  }

  /**
   * Gives an element in the list. <br>  
   * 
   * @param anIndex index of the object to find
   * @return the object available at the given index
   */
  public String get(int anIndex) {
    if (check(anIndex)) {
      return this.itsList[anIndex];
    }
    throw new IndexOutOfBoundsException("Invalid index");
  }

  /**
   * Sets the element in the list at the given index. <br>  
   * 
   * Warning: No copy or clone of the element is made.
   * 
   * @param anIndex where to add the object
   * @param anElm the object to add
   */
  public void set(String anElm, int anIndex) {
    if (check(anIndex)) {
      this.itsList[anIndex] = anElm;
    }
    throw new IndexOutOfBoundsException("Invalid index");
  }

  /**
   * Sorts the list.
   */
  public void sort() {
    Arrays.sort(this.itsList);
  }
		
  /**
   * Sorts the lis with the help of a comparator.
   *
   * @param aComparator object that tells how to compare objets
   */
  public void sort(Comparator aComparator) {
    Arrays.sort(this.itsList, aComparator);
  }

  /**
   * Gives the first place of the given element. <br>  
   * 
   * @param anElm the object to find
   * @return the index value of this element, or -1 if it is not present
   */
  public int indexOf(String anElm) {
    return this.indexOf(anElm, 0);
  }

  /**
   * Gives the last place of the given element. <br>  
   * 
   * @param anElm the object to find
   * @return the last index value of this element, or -1 if it is not present
   */
  public int lastIndexOf(String anElm) {
    int res = -1;
    for (int i = 0; i < this.occupedSize; i++) {
      if (anElm == this.itsList[i]
        || (anElm != null && anElm.equals(this.itsList[i]))) {
        res = i;
      }
    }
    return res;
  }

  /**
   * Gives the first place of the given element starting from a given position. <br>  
   * 
   * @param anElm the object to find
   * @param aStartIndex where to start searching
   * @return the index value of this element, or -1 if it is not present
   */
  public int indexOf(String anElm, int aStartIndex) {
    int res = -1;
    for (int i = aStartIndex; i < this.occupedSize && res == -1; i++) {
      if (anElm == this.itsList[i]
        || (anElm != null && anElm.equals(this.itsList[i]))) {
        res = i;
      }
    }
    return res;
  }

  /**
   * Clears the array.
   * 
   * Puts null in each place of the array
   */
  public void clear() {
    for (int i = 0; i < this.occupedSize; i++) {
      this.itsList[i] = null;
    }
    this.occupedSize = 0;
  }

  /**
   * Indicates if the list is empty or not.
   * 
   * @return true if the list is empty, false if not
   */
  public boolean isEmpty() {
    return this.occupedSize == 0;
  }

  /**
   * Deletes the array.
   * 
   * Use this method for memory leak, the list will not be useable anymore
   */
  public void delete() {
    this.clear();
    this.itsList = null;
  }

  /**
   * Returns the number of element in the list.
   * 
   * @return the number of element in the list
   */
  public int size() {
    return this.occupedSize;
  }

  /**
   * Tests equality between two list.
   * 
   * @param anObject the object compared to this
   * @return true if this is equals to the other object, false if not
   */
  public boolean equals(Object anObject) {
    if (this == anObject)
      return true;
    if (null == anObject)
      return false;
    if (anObject instanceof StringList) {
      StringList o = (StringList) anObject;
      if (o.size() != this.size())
        return false;
      for (int i = 0; i < this.occupedSize; i++) {
        if (this.itsList[i] == o.itsList[i]
          || (this.itsList[i] != null
            && this.itsList[i].equals(o.itsList[i]))) {
          continue;
        } else {
          return false;
        }
      }
      return true;
    }
    return false;
  }

  /**
   * Tests if an element is present or not. <br>  
   * 
   * @param anElm the object to find
   * @return true if the element is present, false if not present
   */
  public boolean contains(String anElm) {
    return indexOf(anElm) != -1;
  }

  /**
   * Makes a clone of this object. <br>  
   * 
   * @return a clone of the object
   */
  public Object clone() {
    return new StringList(this.itsList, true);
  }

  /**
   * Ensures the capacity of the dynamic list. <br>  
   *
   * Use this for peformance. <br>  
   *
   * @param aCapacity the minimum capacity that should have the list
   */
  public void ensureCapacity(int aCapacity) {
    int oldCapacity = this.itsList.length;
    if (aCapacity > oldCapacity) {
      if (aCapacity - this.itsList.length > 0) {
        String[] newData = new String[aCapacity + aCapacity / 10];
        System.arraycopy(this.itsList, 0, newData, 0, this.occupedSize);
        this.itsList = newData;
      }
    }
  }

  /**
   * Adds an element to the list. <br>  
   *
   * The element is put at the end of the list. <br>  
   *
   * @param anElm the new element to add
   */
  public void add(String anElm) {
    this.ensureCapacity(this.occupedSize + 1);
    this.itsList[this.occupedSize] = anElm;
    this.occupedSize++;
  }

  /**
   * Inserts the specified element at the specified position in this
   * list. Shift the element currently at that position (if any) and
   * any subsequent elements to the right (adds one to their indices).
   *
   * @param anIndex index at which the specified element is to be inserted.
   * @param aString element to be inserted.
   * @throws    IndexOutOfBoundsException if index is out of range
   *      <tt>(index < 0 || index > size())</tt>.
   */
  public void add(int anIndex, String anElm) {
    if (this.check(anIndex)) {
      this.ensureCapacity(this.occupedSize + 1);
      System.arraycopy(this.itsList, anIndex, this.itsList,
        anIndex + 1, this.occupedSize - anIndex);
      this.itsList[anIndex] = anElm;
      this.occupedSize++;
    } else {
      throw new IndexOutOfBoundsException("Invalid index");
    }
  }

  /**
   * Removes the element at the specified position in this list.
   * Shifts any subsequent elements to the left (subtracts one from their
   * indices).
   *
   * @param anIndex the index of the element to removed.
   * @return the element that was removed from the list.
   * @throws    IndexOutOfBoundsException if index out of range <tt>(index
   *      < 0 || index >= size())</tt>.
   */
  public String remove(int anIndex) {
    if (this.check(anIndex)) {
      String oldValue = this.itsList[anIndex];
      int numMoved = this.occupedSize - anIndex - 1;
      if (numMoved > 0) {
        System.arraycopy(this.itsList, anIndex + 1,
          this.itsList, anIndex, numMoved);
      }
      this.itsList[--this.occupedSize] = null;
      return oldValue;
    } else {
      throw new IndexOutOfBoundsException("Invalid index");
    }
  }

  /**
   * Builds an array with the list. <br>  
   *
   * @return an array representation of the list. <br>  
   */
  public String[] toArray() {
    String[] resu = new String[this.occupedSize];
    System.arraycopy(this.itsList, 0, resu, 0, this.occupedSize);
    return resu;
  }

  /**
   * Builds an array with the list. <br>  
   *
   * @param anArray where to put the array representation of the list
   *
   * @return an array representation of the list. <br>  
   */
  public String[] toArray(String[] anArray) {
    if (anArray.length < this.occupedSize) {
      anArray = new String[this.occupedSize];
    }
    System.arraycopy(this.itsList, 0, anArray, 0, this.occupedSize);
    return anArray;
  }

  /**
   * The main method. 
   * 
   * @param args arguments
   */
  public static void main(String[] args) {
    /*
    StringList aList = new StringList(5);
    for(int i=0; i<10; i++) {
      aList.add(new String());
    }
    System.out.println(aList);
    */
  }
}

Voici un autre exemple d'une classe Java générée par le plugin, il s'agit d'une liste dynamique d'entiers (int) utilisant le model java.util.ArrayList. Dans ce cas, les types simples sont wrappés dans leur Object respectif ( java.lang.Integer ici). Attention cependant la classe générée n'est toujours pas une java.util.List même si elle y resemble beaucoup.

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class IntArrayList {

  /** The list. */
  protected List itsList;
  
  /**
   * Constructor of the object.
   */
  public IntArrayList() {
    super();
    this.itsList = new ArrayList();
  }

  /**
   * Constructor of the object.
   * 
   * @param aSize default size of the object
   */
  public IntArrayList(int aSize) {
    super();
    this.itsList = new ArrayList(aSize);
  }

  /**
   * Returns the number of elements in this list.  If this list contains
   * more than <tt>Integer.MAX_VALUE</tt> elements, returns
   * <tt>Integer.MAX_VALUE</tt>.
   *
   * @return the number of elements in this list.
   */
  public int size() {
    return this.itsList.size();
  }

  /**
   * Returns <tt>true</tt> if this list contains no elements.
   *
   * @return <tt>true</tt> if this list contains no elements.
   */
  public boolean isEmpty() {
    return this.itsList.isEmpty();
  }

  /**
   * Returns an iterator over the elements in this list in proper sequence.
   *
   * @return an iterator over the elements in this list in proper sequence.
   */
  public Iterator iterator() {
    return this.itsList.iterator();
  }

  /**
   * Returns <tt>true</tt> if this list contains all of the 
   * elements of the specified collection.
   *
   * @param aCollection collection to be checked for containment in this list.
   * @return <tt>true</tt> if this list contains all of the 
   * elements of the specified collection.
   * 
   */
  public boolean containsAll(Collection aCollection) {
    return this.itsList.containsAll(aCollection);
  }

  /**
   * Appends all of the elements in the specified collection to the end of
   * this list, in the order that they are returned by the specified
   * collection's iterator.  The behavior of this
   * operation is unspecified if the specified collection is modified while
   * the operation is in progress.  (Note that this will occur if the
   * specified collection is this list, and it's nonempty.)
   *
   * @param aCollection collection whose elements are to be added to this list.
   * @return <tt>true</tt> if this list changed as a result of the 
   * call.
   * 
   * @throws UnsupportedOperationException if the <tt>addAll</tt> 
   * method is not supported by this list.
   * @throws ClassCastException if the class of an element in the specified 
   * collection prevents it from being added to this list.
   * @throws IllegalArgumentException if some aspect of an element in the 
   * specified collection prevents it from being added to this list.
   */
  public boolean addAll(Collection aCollection) {
    return this.itsList.addAll(aCollection);
  }

  /**
   * Inserts all of the elements in the specified collection into this
   * list at the specified position.  Shifts the
   * element currently at that position (if any) and any subsequent
   * elements to the right (increases their indices).  The new elements
   * will appear in this list in the order that they are returned by the
   * specified collection's iterator.  The behavior of this operation is
   * unspecified if the specified collection is modified while the
   * operation is in progress.  (Note that this will occur if the specified
   * collection is this list, and it's nonempty.)
   *
   * @param anIndex index at which to insert first element from the specified 
   * collection.
   * @param aCollection elements to be inserted into this list.
   * @return <tt>true</tt> if this list changed as a result of the 
   * call.
   * 
   * @throws UnsupportedOperationException if the <tt>addAll</tt> 
   * method is not supported by this list.
   * @throws ClassCastException if the class of one of elements of the specified 
   * collection prevents it from being added to this list.
   * @throws IllegalArgumentException if some aspect of one of elements of the 
   * specified collection prevents it from being added to this list.
   * @throws IndexOutOfBoundsException if the index is out of range (index < 
   * 0 || index > size()).
   */
  public boolean addAll(int anIndex, Collection aCollection) {
    return this.itsList.addAll(anIndex, aCollection);
  }

  /**
   * Removes from this list all the elements that are contained in the
   * specified collection.
   *
   * @param aCollection collection that defines which elements will be removed 
   * from this list.
   * @return <tt>true</tt> if this list changed as a result of the 
   * call.
   * 
   * @throws UnsupportedOperationException if the <tt>removeAll</tt> 
   * method is not supported by this list.
   */
  public boolean removeAll(Collection aCollection) {
    return this.itsList.removeAll(aCollection);
  }

  /**
   * Retains only the elements in this list that are contained in the
   * specified collection.  In other words, removes
   * from this list all the elements that are not contained in the specified
   * collection.
   *
   * @param aCollection collection that defines which elements this set will 
   * retain.
   * 
   * @return <tt>true</tt> if this list changed as a result of the 
   * call.
   * 
   * @throws UnsupportedOperationException if the <tt>retainAll</tt> 
   * method is not supported by this list.
   */
  public boolean retainAll(Collection aCollection) {
    return this.itsList.retainAll(aCollection);
  }

  /**
   * Removes all of the elements from this list. This
   * list will be empty after this call returns (unless it throws an
   * exception).
   *
   * @throws UnsupportedOperationException if the <tt>clear</tt> 
   * method is not supported by this list.
   */
  public void clear() {
    this.itsList.clear();
  }

  /**
   * Deletes the object. 
   *
   * The object will become unuseable.
   */
  public void delete() {
    this.itsList.clear();
    this.itsList=null;
  }

  /**
   * Returns a list iterator of the elements in this list (in proper sequence).
   *
   * @return a list iterator of the elements in this list (in proper sequence).
   */
  public ListIterator listIterator() {
    return this.itsList.listIterator();
  }

  /**
   * Returns a list iterator of the elements in this list (in proper
   * sequence), starting at the specified position in this list.  The
   * specified index indicates the first element that would be returned by
   * an initial call to the <tt>next</tt> method.  An initial call 
   * to the <tt>previous</tt> method would return the element with 
   * the specified index minus one.
   *
   * @param anIndex index of first element to be returned from the list iterator 
   * (by a call to the <tt>next</tt> method).
   * 
   * @return a list iterator of the elements in this list (in proper sequence), 
   * starting at the specified position in this list.
   * 
   * @throws IndexOutOfBoundsException if the index is out of range (index < 
   * 0 || index > size()).
   */
  public ListIterator listIterator(int anIndex) {
    return this.itsList.listIterator(anIndex);
  }

  /**
   * Returns a view of the portion of this list between the specified
   * <tt>fromIndex</tt>, inclusive, and <tt>toIndex</tt>, 
   * exclusive.  (If <tt>fromIndex</tt> and <tt>toIndex<
   * /tt> are equal, the returned list is empty.)  The returned list is 
   * backed by this list, so changes in the returned list are reflected in 
   * this list, and vice-versa.  The returned list supports all of the optional 
   * list operations supported by this list.<p>
   *
   * This method eliminates the need for explicit range operations (of
   * the sort that commonly exist for arrays).   Any operation that expects
   * a list can be used as a range operation by passing a subList view
   * instead of a whole list.  For example, the following idiom
   * removes a range of elements from a list:
   * <pre>
   *      list.subList(from, to).clear();
   * </pre>
   * Similar idioms may be constructed for <tt>indexOf</tt> and
   * <tt>lastIndexOf</tt>, and all of the algorithms in the
   * <tt>Collections</tt> class can be applied to a subList.<p>
   *
   * The semantics of this list returned by this method become undefined if
   * the backing list (i.e., this list) is <i>structurally modified<
   * /i> in any way other than via the returned list.  (Structural 
   * modifications are those that change the size of this list, or otherwise 
   * perturb it in such a fashion that iterations in progress may yield 
   * incorrect results.)
   *
   * @param fromIndex low endpoint (inclusive) of the subList.
   * @param toIndex high endpoint (exclusive) of the subList.
   * @return a view of the specified range within this list.
   * 
   * @throws IndexOutOfBoundsException for an illegal endpoint index value 
   * (fromIndex < 0 || toIndex > size || fromIndex > toIndex).
   */
  public IntArrayList subList(int fromIndex, int toIndex) {
    if (toIndex - fromIndex >= 0) {
      IntArrayList res = new IntArrayList(toIndex - fromIndex);
      res.itsList.addAll(this.itsList.subList(fromIndex, toIndex));
      return res;
    }
    throw new IndexOutOfBoundsException(" toIndex - fromIndex < 0 ");
  }

  /**
   * Returns a string representation of the object. In general, the 
   * <code>toString</code> method returns a string that 
   * " textually represents " this object.
   *
   * @return  a string representation of the object.
   */
  public String toString() {
    return this.itsList.toString();
  }

  /**
   * Compares the specified object with this list for equality.  Returns
   * <tt>true</tt> if and only if the specified object is also a 
   * list, both lists have the same size, and all corresponding pairs of 
   * elements in the two lists are <i>equal</i>.  (Two elements 
   * <tt>e1< /tt> and <tt>e2</tt> are <i>
   * equal</i> if <tt>(e1==null ? e2==null :
   * e1.equals(e2))</tt>.)  In other words, two lists are defined to be
   * equal if they contain the same elements in the same order.  This
   * definition ensures that the equals method works properly across
   * different implementations of the <tt>List</tt> interface.
   *
   * @param anObject the object to be compared for equality with this list.
   * @return <tt>true</tt> if the specified object is equal to this 
   * list.
   */
  public boolean equals(Object anObject) {
    if (anObject == null)
      return false;
    if (anObject == this)
      return true;
    if (anObject instanceof List) {
      return this.itsList.equals(anObject);
    }
    return false;
  }

  /**
   * Creates and returns a copy of this object.  The precise meaning 
   * of " copy " may depend on the class of the object. 
   * 
   * @return a clone of this instance.
   * @exception CloneNotSupportedException  if the object's class does not 
   * support the <code>Cloneable</code> interface. Subclasses that 
   * override the <code>clone</code> method can also throw this 
   * exception to indicate that an instance cannot be cloned.
   * @exception OutOfMemoryError if there is not enough memory.
   */
  public Object clone() {
    IntArrayList res = new IntArrayList(this.itsList.size());
    res.addAll(this.itsList);
    return res;
  }

  /**
   * Sorts the list.
   */
  public void sort() {
    Collections.sort(this.itsList);
  }

  /**
   * Sorts the lis with the help of a comparator.
   * 
   * @param aComparator object that tells how to compare objets
   */
  public void sort(Comparator aComparator) {
    Collections.sort(this.itsList, aComparator);
  }

  /**
   * Returns <tt>true</tt> if this list contains the specified 
   * element.
   * More formally, returns <tt>true</tt> if and only if this list 
   * contains
   * at least one element <tt>e</tt> such that
   * <tt>(o==null ? e==null : o.equals(e))</tt>.
   *
   * @param anElement element whose presence in this list is to be tested.
   * @return <tt>true</tt> if this list contains the specified 
   * element.
   */
  public boolean contains(int anElement) {
    return this.itsList.contains(new Integer(anElement));
  }

  /**
   * Returns an array containing all of the elements in this list in proper
   * sequence.  Obeys the general contract of the
   * <tt>Collection.toArray</tt> method.
   *
   * @return an array containing all of the elements in this list in proper 
   * sequence.
   */
  public int[] toArray() {
    int[] res = new int[this.itsList.size()];
    for (int i = 0; i < this.itsList.size(); i++) {
      res[i] = ((Integer) this.itsList.get(i)).intValue();
    }
    return res;
  }

  /**
   * Returns an array containing all of the elements in this list in proper
   * sequence; the runtime type of the returned array is that of the
   * specified array.  Obeys the general contract of the
   * <tt>Collection.toArray(Object[])</tt> method.
   *
   * @param someObjects the array into which the elements of this list are to 
   * be stored, if it is big enough; otherwise, a new array of the same runtime 
   * type is allocated for this purpose.
   * @return  an array containing the elements of this list.
   * 
   * @throws ArrayStoreException if the runtime type of the specified array is 
   * not a supertype of the runtime type of every element in this list.
   */
  public int[] toArray(int[] someObjects) {
    int[] res = new int[this.itsList.size()];
    System.arraycopy(someObjects, 0, res, 0, this.itsList.size());
    for (int i = 0; i < this.itsList.size(); i++) {
      res[i] = ((Integer) this.itsList.get(i)).intValue();
    }
    return res;
  }

  /**
   * Appends the specified element to the end of this list (optional
   * operation). <p>
   *
   * Lists that support this operation may place limitations on what
   * elements may be added to this list.  In particular, some
   * lists will refuse to add null elements, and others will impose
   * restrictions on the type of elements that may be added.  List
   * classes should clearly specify in their documentation any restrictions
   * on what elements may be added.
   *
   * @param anElement element to be appended to this list.
   * @return <tt>true</tt> (as per the general contract of the 
   * <tt>Collection.add</tt> method).
   * 
   * @throws UnsupportedOperationException if the <tt>add</tt> 
   * method is not supported by this list.
   * @throws ClassCastException if the class of the specified element prevents 
   * it from being added to this list.
   * @throws IllegalArgumentException if some aspect of this element prevents 
   * it from being added to this collection.
   */
  public boolean add(int anElement) {
    return this.itsList.add(new Integer(anElement));
  }

  /**
   * Removes the first occurrence in this list of the specified element. If 
   * this list does not contain the element, it is
   * unchanged.  More formally, removes the element with the lowest index i
   * such that <tt>(anElement==null ? get(i)==null : anElement.equals(
   * get(i)))</tt> (if such an element exists).
   *
   * @param anElement element to be removed from this list, if present.
   * @return <tt>true</tt> if this list contained the specified 
   * element.
   * 
   * @throws UnsupportedOperationException if the <tt>remove</tt> 
   * method is not supported by this list.
   */
  public boolean remove(int anElement) {
    return this.itsList.remove(new Integer(anElement));
  }

  /**
   * Returns the element at the specified position in this list.
   *
   * @param anIndex index of element to return.
   * @return the element at the specified position in this list.
   * 
   * @throws IndexOutOfBoundsException if the index is out of range (index < 
   * 0 || index >= size()).
   */
  public int get(int anIndex) {
    Integer res = (Integer) this.itsList.get(anIndex);
    return res.intValue();
  }

  /**
   * Replaces the element at the specified position in this list with the
   * specified element.
   *
   * @param anIndex index of element to replace.
   * @param anElement element to be stored at the specified position.
   * @return the element previously at the specified position.
   * 
   * @throws UnsupportedOperationException if the <tt>set</tt> 
   * method is not supported by this list.
   * @throws ClassCastException if the class of the specified element prevents 
   * it from being added to this list.
   * @throws IllegalArgumentException if some aspect of the specified element 
   * prevents it from being added to this list.
   * @throws IndexOutOfBoundsException if the index is out of range (index 
   * < 0 || index >= size()).  
   */
  public int set(int anIndex, int anElement) {
    Integer res =
      (Integer) this.itsList.set(anIndex, new Integer(anElement));
    if (res != null) {
      return res.intValue();
    } else {
      return Integer.MAX_VALUE;
    }
  }

  /**
   * 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 anIndex index at which the specified element is to be inserted.
   * @param anElement element to be inserted.
   * 
   * @throws UnsupportedOperationException if the <tt>add</tt> 
   * method is not supported by this list.
   * @throws ClassCastException if the class of the specified element prevents 
   * it from being added to this list.
   * @throws IllegalArgumentException if some aspect of the specified element 
   * prevents it from being added to this list.
   * @throws IndexOutOfBoundsException if the index is out of range (index < 
   * 0 || index > size()).
   */
  public void add(int anIndex, int anElement) {
    this.itsList.add(anIndex, new Integer(anElement));
  }

  /**
   * Removes the element at the specified position in this list. 
   * Shifts any subsequent elements to the left (subtracts one
   * from their indices).  Returns the element that was removed from the
   * list.
   *
   * @param anIndex the index of the element to removed.
   * @return the element previously at the specified position.
   * 
   * @throws UnsupportedOperationException if the <tt>remove</tt> 
   * method is not supported by this list.
   * @throws IndexOutOfBoundsException if the index is out of range (index < 
   * 0 || index >= size()).
   */
  public int removeAt(int anIndex) {
    Integer res = (Integer) this.itsList.remove(anIndex);
    if (res != null) {
      return res.intValue();
    } else {
      return Integer.MAX_VALUE;
    }
  }

  /**
   * Returns the index in this list of the first occurrence of the specified
   * element, or -1 if this list does not contain this element.
   * More formally, returns the lowest index <tt>i</tt> such that
   * <tt>(anObject==null ? get(i)==null : anObject.equals(get(i)))</tt
   * >, or -1 if there is no such index.
   *
   * @param anElement element to search for.
   * @return the index in this list of the first occurrence of the specified 
   * element, or -1 if this list does not contain this element.
   */
  public int indexOf(int anElement) {
    return this.itsList.indexOf(new Integer(anElement));
  }

  /**
   * Returns the index in this list of the last occurrence of the specified
   * element, or -1 if this list does not contain this element.
   * More formally, returns the highest index <tt>i</tt> such that
   * <tt>(anObject==null ? get(i)==null : anObject.equals(get(i)))</
   * tt>, or -1 if there is no such index.
   *
   * @param anElement element to search for.
   * @return the index in this list of the last occurrence of the specified 
   * element, or -1 if this list does not contain this element.
   */
  public int lastIndexOf(int anElement) {
    return this.itsList.lastIndexOf(new Integer(anElement));
  }

  /**
   * The main method. 
   * 
   * @param args arguments
   */
  public static void main(String[] args) {
    /*
    IntArrayList aList = new IntArrayList();
    // Add your element here
    System.out.println(aList);
    */
  }
}

Remarques :

L'avantage de ce type de classe c'est qu'il n'y a pas de cast à faire quand on souhaite récupérer un objet.
Un autre avantage est la garantie que dans cette liste, il n'y a qu'un seul type d'objet.
Par contre, il y a perte du polymorphisme offert part l'interface java.util.List.
Il n'y a pas de java.util.Iterator utilisable sur la liste générée, il n'y a donc pas de sécurite quant à l'intégrité de la liste pendant son parcourt.
La méthode delete, qui peut faire hurler les puristes optimistes qui gobent tout ce que dit Sun, sert a indiquer explicitement que l'objet n'est plus utilisable. Elle permet d'apréhender la cycle de vie de son objet, ou si vous préferrez : na pas perdre les bonnes habitudes d'un développement avec allocation/désallocation mémoire.

Pour toutes remarques, commentaires idées, bugs :