Do lab 9, rearrange lab 6 stuff

4 files changed, 139 insertions, 0 deletions

diff --git a/csci1913/Java/lab6/Polygon.java b/csci1913/Java/lab6/lab6/Polygon.java
index 7f025fe..7f025fe 100644
--- a/csci1913/Java/lab6/Polygon.java
+++ b/csci1913/Java/lab6/lab6/Polygon.java
diff --git a/csci1913/Java/lab6/lab6_strap012.java b/csci1913/Java/lab6/lab6/lab6_strap012.java
index feecbe1..feecbe1 100644
--- a/csci1913/Java/lab6/lab6_strap012.java
+++ b/csci1913/Java/lab6/lab6/lab6_strap012.java
diff --git a/csci1913/Java/lab6/tests6.java b/csci1913/Java/lab6/lab6/tests6.java
index fc98648..fc98648 100644
--- a/csci1913/Java/lab6/tests6.java
+++ b/csci1913/Java/lab6/lab6/tests6.java
diff --git a/csci1913/Java/lab9_strap012.java b/csci1913/Java/lab9_strap012.java
new file mode 100644
index 0000000..94a003c
--- /dev/null
+++ b/csci1913/Java/lab9_strap012.java
@@ -0,0 +1,139 @@
+import java.util.Iterator;
+
+//  ARRAY QUEUE. A fixed length queue implemented as a circular array.
+
+class ArrayQueue<Base> {
+    private int front; // Index of front object in BASES.
+    private int rear; // Index of rear object in BASES.
+    private Base[] bases; // The BASEs in the queue.
+
+    // Constructor. Make a new empty queue that can hold SIZE - 1 elements.
+
+    public ArrayQueue(int size) {
+        if (size >= 1) {
+            front = 0;
+            rear = 0;
+            bases = (Base[]) new Object[size];
+        } else {
+            throw new IllegalArgumentException("Size must be at least 1.");
+        }
+    }
+
+    // DEQUEUE. Remove a BASE from the front of the queue and return it.
+
+    public Base dequeue() {
+        if (isEmpty()) {
+            throw new IllegalStateException("Queue is empty.");
+        } else {
+            front = (front + 1) % bases.length;
+            Base temp = bases[front];
+            bases[front] = null;
+            return temp;
+        }
+    }
+
+    // ENQUEUE. Add BASE to the rear of the queue.
+
+    public void enqueue(Base base) {
+        int nextRear = (rear + 1) % bases.length;
+        if (front == nextRear) {
+            throw new IllegalStateException("Queue is full.");
+        } else {
+            rear = nextRear;
+            bases[rear] = base;
+        }
+    }
+
+    // IS EMPTY. Test if the queue is empty.
+
+    public boolean isEmpty() {
+        return front == rear;
+    }
+
+    // IS FULL. Test if the queue can hold no more elements.
+
+    public boolean isFull() {
+        return front == (rear + 1) % bases.length;
+    }
+
+    private class ArrayQueueIterator implements Iterator<Base> {
+        private int where;
+        private ArrayQueueIterator() {
+            where = (front + 1) % bases.length;
+        }
+        public boolean hasNext() {
+            return where != (rear + 1 ) % bases.length;
+        }
+        public Base next() {
+            if (hasNext()){
+                Base temp = bases[where];
+                where = (where + 1) % bases.length;
+                return temp;
+            } else {
+                throw new IllegalStateException("Queues at its end.");
+            }
+        }
+        public void remove() {
+            //Do nothing
+        }
+    }
+    public Iterator<Base> iterator() {
+        return new ArrayQueueIterator();
+    }
+}
+
+
+// QUEUETERATOR. Test ARRAY QUEUE's iterator. It's worth 20 points.
+
+class Queueterator {
+
+    // MAIN. Start execution here.
+
+    public static void main(String[] args) {
+
+        // Make an ARRAY QUEUE and enqueue some STRINGs. It can hold at most three.
+
+        ArrayQueue<String> queue = new ArrayQueue<String>(4);
+
+        queue.enqueue("A");
+        queue.enqueue("B");
+        queue.enqueue("C");
+
+        // Make a FIRST iterator for QUEUE and use it to visit QUEUE's elements.
+
+        Iterator<String> first = queue.iterator();
+        while (first.hasNext()) {
+            System.out.println(first.next()); // A B C one per line 5 pts.
+        }
+
+        // Make sure FIRST hasn't changed QUEUE.
+
+        System.out.println(queue.isEmpty()); // false 1 pt.
+        System.out.println(queue.dequeue()); // A 1 pt.
+        System.out.println(queue.dequeue()); // B 1 pt.
+        System.out.println(queue.dequeue()); // C 1 pt.
+        System.out.println(queue.isEmpty()); // true 1 pt.
+
+        // Let's enqueue more three more things to QUEUE.
+
+        queue.enqueue("X");
+        queue.enqueue("Y");
+        queue.enqueue("Z");
+
+        // Now make a SECOND iterator for QUEUE. The FIRST one does not work any more,
+        // because QUEUE has changed. Use SECOND to visit QUEUE's new elements.
+
+        Iterator<String> second = queue.iterator();
+        while (second.hasNext()) {
+            System.out.println(second.next()); // X Y Z one per line 5 pts.
+        }
+
+        // The new iterator hasn't changed QUEUE either.
+
+        System.out.println(queue.isEmpty()); // false 1 pt.
+        System.out.println(queue.dequeue()); // X 1 pt.
+        System.out.println(queue.dequeue()); // Y 1 pt.
+        System.out.println(queue.dequeue()); // Z 1 pt.
+        System.out.println(queue.isEmpty()); // true 1 pt.
+    }
+}
\ No newline at end of file