Add Ex_27.10

Author: jsquared21

Exercise_27/Exercise_27_10/.smbdeleteAAA01884.4

@@ -0,0 +1,15 @@
+/*********************************************************************************
+* (Compare MyHashSet and MyArrayList) MyArrayList is defined in Listing 24.3.    *
+* Write a program that generates 1000000 random double values between 0 and      *
+* 999999 and stores them in a MyArrayList and in a MyHashSet. Generate a list of *
+* 1000000 random double values between 0 and 1999999. For each number in the     *
+* list, test if it is in the array list and in the hash set. Run your program to *
+* display the total test time for the array list and for the hash set.           *
+*********************************************************************************/
+public class Exercise_27_10 {
+	public static void main(String[] args) {
+		// Create a MyHashSet
+		MySet<Integer> set = new MyHashSet<>();
+		set.add();
+	}
+}

Exercise_27/Exercise_27_10/Exercise_27_10.class

@@ -0,0 +1,53 @@
+/*********************************************************************************
+* (Compare MyHashSet and MyArrayList) MyArrayList is defined in Listing 24.3.    *
+* Write a program that generates 1000000 random double values between 0 and      *
+* 999999 and stores them in a MyArrayList and in a MyHashSet. Generate a list of *
+* 1000000 random double values between 0 and 999999. For each number in the     *
+* list, test if it is in the array list and in the hash set. Run your program to *
+* display the total test time for the array list and for the hash set.           *
+*********************************************************************************/
+public class Exercise_27_10 {
+	static final int VALUES = 1000000;
+
+	public static void main(String[] args) {
+		MySet<Double> set = new MyHashSet<>(); // Create a MyHashSet
+		MyList<Double> arrayList = new MyArrayList<>(); // Create a MyArrayList
+
+		// Generate 1000000 random double values between 0 and 999999
+		for (int i = 0; i < VALUES; i++) {
+			double randomDouble = Math.random() * VALUES;
+			set.add(randomDouble);
+			arrayList.add(randomDouble);
+		}
+		
+		// Create a list
+		double[] list = new double[VALUES];
+		for (int i = 0; i < list.length; i++) {
+			list[i] = Math.random() * VALUES;
+		}
+
+		System.out.println("Total time for the hash set: " +
+			testTimeSet(list, set) + " milliseconds");
+
+		System.out.println("Total time for the array list: " +
+			testTimeArray(list, arrayList) + " milliseconds");
+	}
+
+	/** Return total test time for the hash set */
+	public static long testTimeSet(double[] list, MySet<Double> set) {
+		long startTime = System.currentTimeMillis();
+		for (int i = 0; i < VALUES; i++) {
+			set.contains(list[i]);
+		}
+		return System.currentTimeMillis() - startTime;
+	}
+
+	/** Return total test time for the array list */
+	public static long testTimeArray(double[] list, MyList<Double> array) {
+		long startTime = System.currentTimeMillis();
+		for (int i = 0; i < VALUES; i++) {
+			array.contains(list[i]);
+		}
+		return System.currentTimeMillis() - startTime;
+	}
+}

Exercise_27/Exercise_27_10/Exercise_27_10.java

@@ -0,0 +1,40 @@
+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]);
+	}
+
+	@Override /** Add a new element at the end of this list */
+	public void add(E e) {
+		add(size, e);
+	}
+
+	@Override /** Return true if this list doen't contain any elements */
+	public boolean isEmpty() {
+		return size == 0;
+	}
+
+	@Override /** Return the number of elements in this list */
+	public int size() {
+		return size;
+	}
+
+	@Override /** Remove the first occurence of the element e
+		* 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;
+	}
+}

Exercise_27/Exercise_27_10/MyAbstractList.class

@@ -0,0 +1,156 @@
+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]);
+	}
+
+	@Override /** Add a new element at the specified index */
+	public void add(int index, E e) {
+		ensureCapacity();
+
+		// Move the elements to the right after the speciied 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 + 1 */
+	private void ensureCapacity() {
+		if (size >= data.length) {
+			E[] newData = (E[])(new Object[size * 2 + 1]);
+			System.arraycopy(data, 0, newData, 0, size);
+			data = newData;
+		}
+	}
+
+	@Override /** Clear the list */
+	public void clear() {
+		data = (E[])new Object[INITIAL_CAPACITY];
+		size = 0;
+	}
+
+	@Override /** 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;
+	}
+
+	@Override /** Return the element at the specified index */
+	public E get(int index) {
+		checkIndex(index);
+		return data[index];
+	}
+
+	private void checkIndex(int index) {
+		if (index < 0 || index >= size)
+			throw new IndexOutOfBoundsException("index" + index + " out of bounds");
+	}
+
+	@Override /** 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;
+	}
+
+	@Override /** 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;
+	}
+
+	@Override /** 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) {
+		checkIndex(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;
+	}
+
+	@Override /** Replace the element at the specified position
+		*	in this list with the specified element. */
+	public E set(int index, E e) {
+		checkIndex(index);
+		E old = data[index];
+		data[index] = e;
+		return old;
+	}
+
+	@Override 
+	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) {
+			E[] newData = (E[])(new Object[size]);
+			System.arraycopy(data, 0, newData, 0, size);
+			data = newData;
+		} // If size == capacity, no need to trim
+	}
+
+	@Override /** Override iterator() defined in Iterable */
+	public java.util.Iterator<E> iterator() {
+		return new ArrayListIterator();
+	}
+
+	private class ArrayListIterator
+			implements java.util.Iterator<E> {
+		private int current = 0; // Current index
+
+		@Override
+		public boolean hasNext() {
+			return (current < size);
+		}
+
+		@Override
+		public E next() {
+			return data[current++];
+		}
+
+		@Override
+		public void remove() {
+			MyArrayList.this.remove(current);
+		}
+	}
+}