java集合：线性表

MyList

public interface MyList<E> {
/** Add a new element at the end of this list */
public void add(E e);

/** Add a new element at the specified index in this list */
public void add(int index, E e);

/** Clear the list */
public void clear();

/** Return true if this list contains the element */
public boolean contains(E e);

/** Return the element from this list at the specified index */
public E get(int index);

/** Return the index of the first matching element in this list.
*  Return -1 if no match. */
public int indexOf(E e);

/** Return true if this list contains no elements */
public boolean isEmpty();

/** Return the index of the last matching element in this list
*  Return -1 if no match. */
public int lastIndexOf(E e);

/** Remove the first occurrence of the element o from this list.
*  Shift any subsequent elements to the left.
*  Return true if the element is removed. */
public boolean remove(E e);

/** Remove the element at the specified position in this list
*  Shift any subsequent elements to the left.
*  Return the element that was removed from the list. */
public E remove(int index);

/** Replace the element at the specified position in this list
*  with the specified element and returns the new set. */
public Object set(int index, E e);

/** Return the number of elements in this list */
public int size();
}

public abstract class MyAbstractList<E> implements MyList<E> {
protected int size = 0; // The size of the list

/** Create a default list */
protected MyAbstractList() {
}

/** Create a list from an array of objects */
protected MyAbstractList(E[] objects) {
for (int i = 0; i < objects.length; i++)
add(objects[i]);
}

/** Add a new element at the end of this list */
public void add(E e) {
add(size, e);
}

/** Return true if this list contains no elements */
public boolean isEmpty() {
return size == 0;
}

/** Return the number of elements in this list */
public int size() {
return size;
}

/** Remove the first occurrence of the element o from this list.
*  Shift any subsequent elements to the left.
*  Return true if the element is removed. */
public boolean remove(E e) {
if (indexOf(e) >= 0) {
remove(indexOf(e));
return true;
}
else
return false;
}
}

public class MyArrayList<E> extends MyAbstractList<E> {
public static final int INITIAL_CAPACITY = 16;
private E[] data = (E[])new Object[INITIAL_CAPACITY];

/** Create a default list */
public MyArrayList() {
}

/** Create a list from an array of objects */
public MyArrayList(E[] objects) {
for (int i = 0; i < objects.length; i++)
add(objects[i]); // Warning: don抰 use super(objects)!
}

/** Add a new element at the specified index in this list */
public void add(int index, E e) {
ensureCapacity();

// Move the elements to the right after the specified index
for (int i = size - 1; i >= index; i--)
data[i + 1] = data[i];

// Insert new element to data[index]
data[index] = e;

// Increase size by 1
size++;
}

/** Create a new larger array, double the current size */
private void ensureCapacity() {
if (size >= data.length) {
E[] newData = (E[])(new Object[size * 2 + 1]);
System.arraycopy(data, 0, newData, 0, size);
data = newData;
}
}

/** Clear the list */
public void clear() {
data = (E[])new Object[INITIAL_CAPACITY];
size = 0;
}

/** Return true if this list contains the element */
public boolean contains(E e) {
for (int i = 0; i < size; i++)
if (e.equals(data[i])) return true;

return false;
}

/** Return the element from this list at the specified index */
public E get(int index) {
return data[index];
}

/** Return the index of the first matching element in this list.
*  Return -1 if no match. */
public int indexOf(E e) {
for (int i = 0; i < size; i++)
if (e.equals(data[i])) return i;

return -1;
}

/** Return the index of the last matching element in this list
*  Return -1 if no match. */
public int lastIndexOf(E e) {
for (int i = size - 1; i >= 0; i--)
if (e.equals(data[i])) return i;

return -1;
}

/** Remove the element at the specified position in this list
*  Shift any subsequent elements to the left.
*  Return the element that was removed from the list. */
public E remove(int index) {
E e = data[index];

// Shift data to the left
for (int j = index; j < size - 1; j++)
data[j] = data[j + 1];

data[size - 1] = null; // This element is now null

// Decrement size
size--;

return e;
}

/** Replace the element at the specified position in this list
*  with the specified element. */
public E set(int index, E e) {
E old = data[index];
data[index] = e;
return old;
}

/** Override toString() to return elements in the list */
public String toString() {
StringBuilder result = new StringBuilder("[");

for (int i = 0; i < size; i++) {
result.append(data[i]);
if (i < size - 1) result.append(", ");
}

return result.toString() + "]";
}

/** Trims the capacity to current size */
public void trimToSize() {
if (size != data.length) { // If size == capacity, no need to trim
E[] newData = (E[])(new Object[size]);
System.arraycopy(data, 0, newData, 0, size);
data = newData;
}
}
}

public class TestList {
public static void main(String[] args) {
// Create a list
MyList<String> list = new MyArrayList<String>();

// Add elements to the list
list.add("America"); // Add it to the list
System.out.println("(1) " + list);

list.add(0, "Canada"); // Add it to the beginning of the list
System.out.println("(2) " + list);

list.add("Russia"); // Add it to the end of the list
System.out.println("(3) " + list);

list.add("France"); // Add it to the end of the list
System.out.println("(4) " + list);

list.add(2, "Germany"); // Add it to the list at index 2
System.out.println("(5) " + list);

list.add(5, "Norway"); // Add it to the list at index 5
System.out.println("(6) " + list);

// Remove elements from the list
list.remove("Canada"); // Same as list.remove(0) in this case
System.out.println("(7) " + list);

list.remove(2); // Remove the element at index 2
System.out.println("(8) " + list);

list.remove(list.size() - 1); // Remove the last element
System.out.println("(9) " + list);
}
}