assignments

assignments/AssigmentS4/AList.java

@@ -0,0 +1,181 @@
+import java.util.Arrays;
+
+/**
+ * A class that implements a list of objects by using an array.
+ * Entries in a list have positions that begin with 1.
+ * Duplicate entries are allowed.
+ * @author Frank M. Carrano
+ */
+public class AList<T> implements ListInterface<T> {
+    private T[] list; // Array of list entries; ignore list[0]
+    private int numberOfEntries;
+    private boolean initialized = false;
+    private static final int DEFAULT_CAPACITY = 25;
+    private static final int MAX_CAPACITY = 10000;
+
+    public AList() {
+        this(DEFAULT_CAPACITY); // Call next constructor
+    } // end default constructor
+
+    public AList(int initialCapacity) {
+        // Is initialCapacity too small?
+        if (initialCapacity < DEFAULT_CAPACITY)
+            initialCapacity = DEFAULT_CAPACITY;
+        else // Is initialCapacity too big?
+            checkCapacity(initialCapacity);
+
+        // The cast is safe because the new array contains null entries
+        @SuppressWarnings("unchecked")
+        T[] tempList = (T[]) new Object[initialCapacity + 1];
+        list = tempList;
+        numberOfEntries = 0;
+        initialized = true;
+    } // end constructor
+
+    public void add(T newEntry) {
+        checkInitialization();
+        list[numberOfEntries + 1] = newEntry;
+        numberOfEntries++;
+        ensureCapacity();
+    } // end add
+
+    public void add(int newPosition, T newEntry) {
+        checkInitialization();
+        if ((newPosition >= 1) && (newPosition <= numberOfEntries + 1)) {
+            if (newPosition <= numberOfEntries) {
+                makeRoom(newPosition);
+            }
+            list[newPosition] = newEntry;
+            numberOfEntries++;
+            ensureCapacity();
+        } else {
+            throw new IndexOutOfBoundsException("Given position of add's new entry is out of bounds.");
+        }
+    } // end add
+
+    public T remove(int givenPosition) {
+        checkInitialization();
+        if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) {
+            T result = list[givenPosition];
+            if (givenPosition < numberOfEntries) {
+                removeGap(givenPosition);
+            }
+            list[numberOfEntries] = null;
+            numberOfEntries--;
+            return result;
+        } else {
+            throw new IndexOutOfBoundsException("Illegal position given to remove operation.");
+        }
+    } // end remove
+
+    public void clear() {
+        while (!isEmpty()) {
+            remove(numberOfEntries);
+        }
+    } // end clear
+
+    public T replace(int givenPosition, T newEntry) {
+        checkInitialization();
+        if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) {
+            T originalEntry = list[givenPosition];
+            list[givenPosition] = newEntry;
+            return originalEntry;
+        } else {
+            throw new IndexOutOfBoundsException("Illegal position given to replace operation.");
+        }
+    } // end replace
+
+    public T getEntry(int givenPosition) {
+        checkInitialization();
+        if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) {
+            return list[givenPosition];
+        } else {
+            throw new IndexOutOfBoundsException("Illegal position given to getEntry operation.");
+        }
+    } // end getEntry
+
+    public T[] toArray() {
+        checkInitialization();
+
+        // The cast is safe because the new array contains null entries
+        @SuppressWarnings("unchecked")
+        T[] result = (T[]) new Object[numberOfEntries];
+        for (int index = 0; index < numberOfEntries; index++) {
+            result[index] = list[index + 1];
+        } // end for
+
+        return result;
+    } // end toArray
+
+    public boolean contains(T anEntry) {
+        checkInitialization();
+        boolean found = false;
+        int index = 1;
+        while (!found && (index <= numberOfEntries)) {
+            if (anEntry.equals(list[index])) {
+                found = true;
+            }
+            index++;
+        } // end while
+        return found;
+    } // end contains
+
+    public int getLength() {
+        return numberOfEntries;
+    } // end getLength
+
+    public boolean isEmpty() {
+        return numberOfEntries == 0; // Or getLength() == 0
+    } // end isEmpty
+
+    // Doubles the capacity of the array list if it is full.
+    // Precondition: checkInitialization has been called.
+    private void ensureCapacity() {
+        int capacity = list.length - 1;
+        if (numberOfEntries >= capacity) {
+            int newCapacity = 2 * capacity;
+            checkCapacity(newCapacity); // Is capacity too big?
+            list = Arrays.copyOf(list, newCapacity + 1);
+        } // end if
+    } // end ensureCapacity
+
+    // Throws an exception if the client requests a capacity that is too large.
+    private void checkCapacity(int capacity) {
+        if (capacity > MAX_CAPACITY)
+            throw new IllegalStateException("Attempt to create a list whose capacity exceeds " +
+                    "allowed maximum of " + MAX_CAPACITY);
+    } // end checkCapacity
+
+    // Throws an exception if receiving object is not initialized.
+    private void checkInitialization() {
+        if (!initialized)
+            throw new SecurityException("AList object is not initialized properly.");
+    } // end checkInitialization
+
+    // Makes room for a new entry at newPosition.
+    // Precondition: 1 <= newPosition <= numberOfEntries + 1;
+    // numberOfEntries is list's length before addition;
+    // checkInitialization has been called.
+    private void makeRoom(int newPosition) {
+        int newIndex = newPosition;
+        int lastIndex = numberOfEntries;
+
+        for (int index = lastIndex; index >= newIndex; index--) {
+            list[index + 1] = list[index];
+        }
+    } // end makeRoom
+
+    // Shifts entries that are beyond the entry to be removed to the
+    // next lower position.
+    // Precondition: 1 <= givenPosition < numberOfEntries;
+    // numberOfEntries is list's length before removal;
+    // checkInitialization has been called.
+    private void removeGap(int givenPosition) {
+        int removedIndex = givenPosition;
+        int lastIndex = numberOfEntries;
+
+        for (int index = removedIndex; index < lastIndex; index++) {
+            list[index] = list[index + 1];
+        }
+    } // end removeGap
+} // end AList

assignments/AssigmentS4/ListClient.java

@@ -0,0 +1,26 @@
+import java.util.Arrays;
+
+public class ListClient {
+    public static void main(String[] args) {
+        // Create an instance of AList
+        AList<String> list = new AList<>();
+
+        // Test isEmpty() on a new list
+        System.out.println("Is the list empty? " + list.isEmpty()); // Expected: true
+
+        // Test add(T newEntry)
+        list.add("Apple");
+        list.add("Banana");
+        list.add("Cherry");
+        System.out.println("After adding 3 items: " + Arrays.toString(list.toArray())); // Expected: [Apple, Banana, Cherry]
+
+        list.add(2, "Peach");
+        System.out.println(list.getEntry(2));
+        System.out.println("New List: "+ Arrays.toString(list.toArray()));
+        list.remove(2);
+        System.out.println("New List: "+ Arrays.toString(list.toArray()));
+        System.out.println("Changed item:"+list.replace(2, "Orange"));
+        System.out.println("New List: "+ Arrays.toString(list.toArray()));
+        System.out.println(list.contains("Apple"));
+    }
+}

assignments/AssigmentS4/ListInterface.java

@@ -0,0 +1,70 @@
+public interface ListInterface<T> {
+    /**
+     * Adds a new entry to the end of the list.
+     * @param newEntry The object to be added as a new entry.
+     */
+    void add(T newEntry);
+
+    /**
+     * Adds a new entry at a specified position within the list.
+     * @param newPosition An integer that specifies the desired position of the new entry.
+     * @param newEntry The object to be added as a new entry.
+     * @throws IndexOutOfBoundsException if newPosition is out of bounds.
+     */
+    void add(int newPosition, T newEntry);
+
+    /**
+     * Removes the entry at a given position from the list.
+     * @param givenPosition An integer that indicates the position of the entry to be removed.
+     * @return A reference to the removed entry.
+     * @throws IndexOutOfBoundsException if givenPosition is out of bounds.
+     */
+    T remove(int givenPosition);
+
+    /**
+     * Removes all entries from the list.
+     */
+    void clear();
+
+    /**
+     * Replaces the entry at a given position in the list.
+     * @param givenPosition An integer that indicates the position of the entry to be replaced.
+     * @param newEntry The object that will replace the entry at the given position.
+     * @return The original entry that was replaced.
+     * @throws IndexOutOfBoundsException if givenPosition is out of bounds.
+     */
+    T replace(int givenPosition, T newEntry);
+
+    /**
+     * Retrieves the entry at a given position in the list.
+     * @param givenPosition An integer that indicates the position of the desired entry.
+     * @return A reference to the indicated entry.
+     * @throws IndexOutOfBoundsException if givenPosition is out of bounds.
+     */
+    T getEntry(int givenPosition);
+
+    /**
+     * Retrieves all entries that are in this list in the order in which they occur in the list.
+     * @return An array of all the entries in the list.
+     */
+    T[] toArray();
+
+    /**
+     * Determines whether the list contains a given entry.
+     * @param anEntry The object that is the desired entry.
+     * @return True if the list contains anEntry, or false if not.
+     */
+    boolean contains(T anEntry);
+
+    /**
+     * Gets the length of this list.
+     * @return The integer number of entries currently in the list.
+     */
+    int getLength();
+
+    /**
+     * Determines whether this list is empty.
+     * @return True if the list is empty, or false if not.
+     */
+    boolean isEmpty();
+}