Can I have someone verify my collections for the SCJP Exam

I've been studying for the SCJP, now Oracle Certified Professional Java SE Programmer exam.

I've had a difficult time wrapping my head around all the different collections and when to use them. I'm also fond of flash cards. So I tried to create a set of classes that are essentially the same except which collection they're using. I'll have to identify how the output would come out and what the primary "features" are of each collection.

Unfortunately I don't trust myself. I would like to have someone confirm that all the information is accurate or if any is missing. Then after some feedback/corrections I think it'll make a great exercise for anyone else trying to understand Java collections.

The collections covered are: HashMap, Hashtable, TreeMap, LinkedHashMap, HashSet, TreeSet, LinkedHashSet, ArrayList, Vector, LinkedList, PriorityQueue.

I also have all the files separated out, they can be downloaded here: http://www.allgo.com/personal/MyCollections.zip

Thanks in advance

import java.util.*;
import java.lang.*;
class MyItem implements Comparable{
    private String name;
    MyItem(String n){ name = n; }
    public String toString(){return name;}
    public String getName(){return name;}

    public boolean equals(Object obj){
        if(this==obj) return true;
        else if(obj==null) return false;
        else if(getName() != ((MyItem)obj).getName()) return false;
        else return true;
    }
    public int hashCode(){ return 5; }
    public int compareTo(MyItem b){return b.getName().compareTo(getName());}

}
public class MyCollections{
    public static void main(String[] args){
        MyHashMap.main(args);           System.out.println("HashMap: Hash=Unsorted, Unordered. Map=key/value pair\n##\n");
        MyHashtable.main(args);         System.out.println("Hashtable: Thread Safe. Hash=Unsorted, Unordered. Map=key/value pair\n##\n");
        MyTreeMap.main(args);           System.out.println("TreeMap: Tree=sorted. Map=key/value.\n##\n");
        MyLinkedHashMap.main(args);     System.out.println("LinkedHashMap: Linked=Maintains Insertion Order. Hash=unsorted, unordered. Map=key/value pair.\n##\n");
        MyHashSet.main(args);           System.out.println("HashSet: Hash=Unsorted, Unordered. Set=Unique. Define=equals/hashCode\n##\n");
        MyTreeSet.main(args);           System.out.println("TreeSet: Tree=Sorted. Set=Unique. Define=Comparable/Comparator\n##\n");
        MyLinkedHashSet.main(args);     S开发者_开发问答ystem.out.println("LinkedHashSet: Liniked=Maintains Insertion Order. Hash=Unsorted. Set=Unique. Define=equals/hashCode\n##\n");
        MyArrayList.main(args);         System.out.println("ArrayList: List=Queue. Maintains insertion order, Allowed duplicates\n##\n");
        MyVector.main(args);            System.out.println("Vector: Thread Safe. ArrayList. Maintains Insertion Order, Allows duplicates\n##\n");
        MyLinkedList.main(args);        System.out.println("LinkedList: Linked=Maintaines Insertion Order. List=Queue. Advanced ArrayList with more methods.\n##\n");
        MyPriorityQueue.main(args);     System.out.println("PriorityQueue: Define=Comparable/comparator\n##\n");
    }
}
class MyHashMap{
    public static void main(String[] args){
        HashMap c = new HashMap();
        MyItem Eight = new MyItem("Eight");
        c.put(5, new MyItem("Five")); c.put(1, new MyItem("One")); c.put(8, Eight); c.put(3, new MyItem("Three"));
        c.put(4, new MyItem("Four")); c.put(1, new MyItem("1")); c.put(8, Eight); c.put(9, new MyItem("Nine"));
        c.remove(3); c.put(7, new MyItem("Seven"));
        System.out.println(c);//output?
    }
}
class MyHashtable{
    public static void main(String[] args){
        Hashtable c = new Hashtable();
        MyItem Eight = new MyItem("Eight");
        c.put(5, new MyItem("Five")); c.put(1, new MyItem("One")); c.put(8, Eight); c.put(3, new MyItem("Three"));
        c.put(4, new MyItem("Four")); c.put(1, new MyItem("1")); c.put(8, Eight); c.put(9, new MyItem("Nine"));
        c.remove(3); c.put(7, new MyItem("Seven"));
        System.out.println(c);//output?
    }
}
class MyTreeMap{
    public static void main(String[] args){
        TreeMap c = new TreeMap();
        MyItem Eight = new MyItem("Eight");
        c.put(5, new MyItem("Five")); c.put(1, new MyItem("One")); c.put(8, Eight); c.put(3, new MyItem("Three"));
        c.put(4, new MyItem("Four")); c.put(1, new MyItem("1")); c.put(8, Eight); c.put(9, new MyItem("Nine"));
        c.remove(3); c.put(7, new MyItem("Seven"));
        System.out.println(c);//output?
    }
}
class MyLinkedHashMap{
    public static void main(String[] args){
        LinkedHashMap c = new LinkedHashMap();
        MyItem Eight = new MyItem("Eight");
        c.put(5, new MyItem("Five")); c.put(1, new MyItem("One")); c.put(8, Eight); c.put(3, new MyItem("Three"));
        c.put(4, new MyItem("Four")); c.put(1, new MyItem("1")); c.put(8, Eight); c.put(9, new MyItem("Nine"));
        c.remove(3); c.put(7, new MyItem("Seven"));
        System.out.println(c);//output?
    }
}
class MyHashSet{
    public static void main(String[] args){
        HashSet c = new HashSet();
        MyItem Eight = new MyItem("Eight");
        c.add(new MyItem("Five")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Three"));
        c.add(new MyItem("Four")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Nine"));
        c.remove(3); c.add(new MyItem("Seven"));
        System.out.println(c);//output?
    }
}

class MyTreeSet{
    public static void main(String[] args){
        TreeSet c = new TreeSet();
        MyItem Eight = new MyItem("Eight");
        c.add(new MyItem("Five")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Three"));
        c.add(new MyItem("Four")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Nine"));
        c.remove(Eight); c.add(new MyItem("Seven"));
        System.out.println(c);//output?
    }
}
class MyLinkedHashSet{
    public static void main(String[] args){
        LinkedHashSet c = new LinkedHashSet();
        MyItem Eight = new MyItem("Eight");
        c.add(new MyItem("Five")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Three"));
        c.add(new MyItem("Four")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Nine"));
        c.remove(3); c.add(new MyItem("Seven"));
        System.out.println(c);//output?
    }
}
class MyArrayList{
    public static void main(String[] args){
        ArrayList c = new ArrayList();
        MyItem Eight = new MyItem("Eight");
        c.add(new MyItem("Five")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Three"));
        c.add(new MyItem("Four")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Nine"));
        c.remove(3); c.add(new MyItem("Seven"));
        System.out.println(c);//output?
    }
}
class MyVector{
    public static void main(String[] args){
        Vector c = new Vector();
        MyItem Eight = new MyItem("Eight");
        c.add(new MyItem("Five")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Three"));
        c.add(new MyItem("Four")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Nine"));
        c.remove(3); c.add(new MyItem("Seven"));
        System.out.println(c);//output?
    }
}
class MyLinkedList{
    public static void main(String[] args){
        LinkedList c = new LinkedList();
        MyItem Eight = new MyItem("Eight");
        c.add(new MyItem("Five")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Three"));
        c.add(new MyItem("Four")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Nine"));
        c.remove(3); c.add(new MyItem("Seven"));
        System.out.println(c);//output?
    }
}
class MyPriorityQueue{
    public static void main(String[] args){
        PriorityQueue c = new PriorityQueue();
        MyItem Eight = new MyItem("Eight");
        c.offer(new MyItem("Five")); c.offer(new MyItem("One")); c.offer(Eight); c.offer(new MyItem("Three"));
        c.offer(new MyItem("Four")); c.offer(new MyItem("One")); c.offer(Eight); c.offer(new MyItem("Nine"));
        System.out.println(c.peek());
        System.out.println(c.poll());
        c.offer(new MyItem("Seven"));
        System.out.println(c);//output?
    }
}

For starters, you should refactor your code. Basically, everywhere you used "copy paste", don't.

Create a method like this:

private static void fill(Collection c) {
    MyItem Eight = new MyItem("Eight");
    c.add(new MyItem("Five")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Three"));
    c.add(new MyItem("Four")); c.add(new MyItem("One")); c.add(Eight); c.add(new MyItem("Nine"));
    c.remove(3); c.add(new MyItem("Seven"));
    System.out.println(c);//output?
}

Then instead of the method you have, do this:

class MyVector{
    public static void main(String[] args){
        Vector c = new Vector();
        fill(c);
    }
}

And do that for all the collections you have.

Next, do a similar thing for your maps:

private static void fill(Map<?,?> map) {
    MyItem Eight = new MyItem("Eight");
    map.put(5, new MyItem("Five")); map.put(1, new MyItem("One")); map.put(8, Eight); map.put(3, new MyItem("Three"));
    map.put(4, new MyItem("Four")); map.put(1, new MyItem("1")); map.put(8, Eight); map.put(9, new MyItem("Nine"));
    map.remove(3); map.put(7, new MyItem("Seven"));
    System.out.println(map);//output?
}

Your code will shrink, be readable and may even one day become usable.

Not an answer to do with your implementaiton, rather help on memorizing the classes. I tried this as a comment but lack of formatting really hurt.

I would break them into categories to remember them, and understand the implementations.

First get the legacy stuff out of the way: Hashtable legacy synchronized hashmap Vector legacy synchronized ArrayList

For the rest you have hints on implementation and hints on how they are used.

the hints on how they are used: List, Map, Set

A list is an ordered list of values, a set is an unordered list, a map is a k->v mapping (a pair of values, dictionary).

The implementation part can be: Linked, Hash, Tree, Array and Heap. These are the ones you want to understand.

Array is a large block of memory holding the entire list. If you have to re-arrange it, you end up moving around a LOT of stuff. to expand it you often have to copy it (Not always). Because it takes advantage of the order, it has very low memory overhead.

Linked is where memory is allocated for each element and each element contains a pointer to the next. This is expensive and awkward, but if you need to insert a new element it's super cheap! Some sorts work better on this kind of structure. It's inherently ordered because of the way you step through the elements.

Hash is where you take each element and calculate a unique number (hash) for it, then you can use those hashes to very quickly look up an element. Inherently unsorted, very fast to look up a value. This is a good structure to read up on if any of this is news to you.

LinkedHash: Eliminates the disadvantages! The LinkedList makes a hash ordered, the hash makes the Linked quick!

Tree: Inherently sorted whenever you add a new entry. I think these are the only inherently sorted collections. It sorts by keeping an internal tree and only having to make a fraction of the number of comparisions of another structure to insert it in the correct order.

PriorityQueue(Heap): A heap is a really cool structure--Basically with minimal resorting it will always give you it's smallest value extremely quickly (Like just a straight read) and adding is also extremely fast.

I suggest reading up on any of these that are interesting and as you understand better how they are implemented, it'll become obvious which you'd use for a given situation.

Sorry about the too long and indirect answer, but I think it would be useful to you.