1. import java.util.ArrayList;
    2. import java.util.Iterator;
    3. import java.util.List;
    5. public class ArraySet<T> implements Iterable<T> {
    6.     private int size; // the next item to be added will be at position size
    7.     private T[] items;
    9.     public ArraySet() {
    10.         items = (T[]) new Object[100];
    11.         size = 0;
    12.     }
    14.     /*
    15.      * Returns true if this map contains a mapping for the specified key.
    16.      */
    17.     public boolean contains(T x) {
    18.         for (int i = 0; i < size; i += 1) {
    19.             if (items[i].equals(x)) {
    20.                 return true;
    21.             }
    22.         }
    23.         return false;
    24.     }
    26.     /*
    27.      * Associates the specified value with the specified key in this map.
    28.      * Throws an IllegalArgumentException if the key is null.
    29.      */
    30.     public void add(T x) {
    31.         if (x == null) {
    32.             throw new IllegalArgumentException("can't add null");
    33.         }
    34.         if (contains(x)) {
    35.             return;
    36.         }
    37.         items[size] = x;
    38.         size += 1;
    39.     }
    41.     /* Returns the number of key-value mappings in this map. */
    42.     public int size() {
    43.         System.out.println(this);
    44.         return size;
    45.     }
    47.     /** returns an iterator (a.k.a. seer) into ME */
    48.     public Iterator<T> iterator() {
    49.         return new ArraySetIterator();
    50.     }
    52.     private class ArraySetIterator implements Iterator<T> {
    53.         private int wizPos;
    55.         public ArraySetIterator() {
    56.             wizPos = 0;
    57.         }
    59.         public boolean hasNext() {
    60.             return wizPos < size;
    61.         }
    63.         public T next() {
    64.             T returnItem = items[wizPos];
    65.             wizPos += 1;
    66.             return returnItem;
    67.         }
    68.     }
    70.     @Override
    71.     public String toString() {
    72.         List<String> list = new ArrayList<>();
    73.         for (T t : this) {
    74.             list.add(t.toString());
    75.         }
    76.         return String.join(", ", list);
    77.     }
    79.     public static <E> ArraySet<E> of(E... e) {
    80.         ArraySet<E> returnSet = new ArraySet<>();
    81.         for (E x : e) {
    82.             returnSet.add(x);
    83.         }
    84.         return returnSet;
    85.     }
    87.     @Override
    88.     public boolean equals(Object other) {
    89.         if (this == other)
    90.             return true;
    91.         if (other == null)
    92.             return false;
    93.         if (this.getClass() != other.getClass())
    94.             return false;
    95.         ArraySet<T> o = (ArraySet<T>) other;
    96.         if (o.size != this.size)
    97.             return false;
    98.         for (T x : this) {
    99.             if (!o.contains(x))
    100.                 return false;
    101.         }
    102.         return true;
    103.     }
    105.     public static void main(String[] args) {
    106.         ArraySet<Integer> aset = new ArraySet<>();
    107.         aset.add(5);
    108.         aset.add(23);
    109.         aset.add(42);
    111.         // iteration
    112.         for (int i : aset) {
    113.             System.out.println(i);
    114.         }
    116.         // toString
    117.         System.out.println(aset);
    119.         // equals
    120.         ArraySet<Integer> aset2 = new ArraySet<>();
    121.         aset2.add(5);
    122.         aset2.add(23);
    123.         aset2.add(42);
    125.         System.out.println(aset.equals(aset2));
    126.         System.out.println(aset.equals(null));
    127.         System.out.println(aset.equals("fish"));
    128.         System.out.println(aset.equals(aset));
    130.         System.out.println(ArraySet.of("Hi", "I'm", "zdkk"));
    131.     }
    132. }