Back to Collections Lists: Sets Maps ArrayList LinkedList No duplicates No order (TreeSets happen to have an order) Maps Mapping a key to a value E.g., our soccer players: map each player to a position Each player is unique, each position doesn’t have to be The player’s name should bring up their position

Map The Map interface maps unique keys to values. A key is an object that you use to retrieve a value at a later date. Given a key and a value, you can store the value in a Map object. After the value is stored, you can retrieve it by using its key. Examples: web page url (key) -> web page content (value) Word (key) -> count of word in document (value) Word(key)-> List of words that follow that word (value) Student name (key) -> class schedule (value) ClassID(key)->roster(list) of students (value)

Map Methods void clear( ) - Removes all key/value pairs from the map. Maps keys to values No duplicate keys Each key maps to a value Methods: void clear( ) - Removes all key/value pairs from the map. boolean containsKey(Object k) - Returns true if the invoking map contains k as a key. Otherwise, returns false. boolean containsValue(Object v) - Returns true if the map contains v as a value. Otherwise, returns false. Set entrySet( ) - Returns a Set that contains the entries in the map. In essence, this is turning the Map into a set (with each key-value pair as an object) Object get(Object k) - Returns the value associated with the key k. boolean isEmpty( ) - Returns true if the invoking map is empty. Otherwise, returns false. Set keySet( ) - Returns a Set that contains the keys from the map Object put(Object k, Object v) - Puts an entry in the map, overwriting any previous value associated with the key. The key and value are k and v, respectively. Returns null if the key did not already exist. Otherwise, the previous value linked to the key is returned. void putAll(Map m) - Puts all the entries from m into this map. Object remove(Object k) - Removes the entry whose key equals k. int size( ) - Returns the number of key/value pairs in the map.

Map Implementations HashMap (uses hashing function on keys) Fast TreeMap (orders keys) Sorted ordering Key-ordered iteration LinkedHashMap (guess) Insertion-order iteration

Declaring Maps Declare types for both keys and values Class HashMap<K,V> HashMap<String, ArrayList<String>> map = new HashMap(); What type is the key? What type is the value?

HashMap<Integer, String> map = new HashMap(); map HashMap<Integer, String> map = new HashMap(); map.put(21, "Twenty One"); // which is the key, and which is the value? //map.put(21.0, "Twenty One"); //this will throw an error because 21.0 is not integer Integer key = 21; String value = map.get(key); // gets value associated with key System.out.println("Key: " + key +" value: "+ value); map.put(31, "Thirty One"); System.out.println("Size of Map: " + map.size()); System.out.println("Does HashMap contains 21 as key: " + map.containsKey(21)); System.out.println("Does HashMap contains 21 as value: " + map.containsValue(21)); System.out.println("Does HashMap contains Twenty One as value: " + map.containsValue("Twenty One")); map.put(41, "Thirty One"); System.out.println("Unsorted HashMap: " + map); TreeMap sortedHashMap = new TreeMap(map); // cool stuff System.out.println("Sorted HashMap: " + sortedHashMap); map.clear(); //clears hashmap , removes all element System.out.println("Is HashMap is empty: " + map.isEmpty());

Looping through map: How could this go wrong? More than one way: for (Integer key : map.keySet()) { … //code goes here System.out.println("Key : " + key.toString() + " Value : "+ map.get(key)); } How could this go wrong? we should use an Iterator

Traversing Collections (1) For-each loop: for (Object o : collection) System.out.println(o); Equivalent to: for (Iterator i = collection.iterator(); i.hasNext();) { Object o = i.next(); } Everything that inherits from Collections Interface has an iterator We should usually use the iterator: more efficient and better way to traverse the objects in a collection

How to use an iterator: Iterator enables you to cycle through a collection obtaining or removing elements ListIterator extends Iterator to allow bidirectional traversal of a list Can go backwards and forward in list. To use an iterator: Obtain an iterator (pointer) to the start of the collection call the collection's iterator( ) method. Set up a loop that makes a call to hasNext( ) Have the loop iterate as long as hasNext( ) returns true. Within the loop, obtain each element by calling next( ).

Traversing Collections: Iterators Java Interface Object next() get the next element boolean hasNext() are there more elements? void remove() removes the previous element Only safe way to remove elements during iteration

public static void main(String args[]) { ArrayList al = new ArrayList(); // Create an array list al.add("C"); // add elements to the array list al.add("A"); al.add("E"); al.add("B"); al.add("D"); al.add("F"); System.out.print("Original contents of al: "); Iterator itr = al.iterator(); // Use iterator to display contents of al while(itr.hasNext()) { Object element = itr.next(); System.out.print(element + " "); } System.out.println(); ListIterator litr = al.listIterator(); while(litr.hasNext()) { // Modify objects being iterated Object element = litr.next(); litr.set(element + "+"); // concatenates “+” to each String System.out.print("Modified contents of al: "); itr = al.iterator(); // sets itr to initial address of ArrayList (i.e., first element in list) System.out.print("Modified list backwards: "); while(litr.hasPrevious()) { // Now, display the list backwards Object element = litr.previous();

ListIterator methods: void add(Object obj) Inserts obj into the list in front of the element that will be returned by the next call to next( ). boolean hasNext( ) Returns true if there is a next element. Otherwise, returns false. boolean hasPrevious( ) Returns true if there is a previous element. Otherwise, returns false. Object next( ) Returns the next element. A NoSuchElementException is thrown if there is not a next element. int nextIndex( ) Returns the index of the next element. If there is not a next element, returns the size of the list. Object previous( ) Returns the previous element. A NoSuchElementException is thrown if there is not a previous element. int previousIndex( ) Returns the index of the previous element. If there is not a previous element, returns -1. void remove( ) Removes the current element from the list. An IllegalStateException is thrown if remove( ) is called before next( ) or previous( ) is invoked. void set(Object obj) Assigns obj to the current element. This is the element last returned by a call to either next( ) or previous( ).

Filter Algorithm void filter(Collection c) { Iterator i = c.iterator(); while( i.hasNext() ) { // if the next element does not // adhere to the condition, remove it if (!cond(i.next())) { i.remove(); }

TreeSets: How do TreeSets work? What makes TreeSets unique compared to HashSets? What if we put student objects into the tree? How about car objects?

Comparable Remember toString() method? Write it for every class You decide what should be the string representation of the object you are creating Java assumes a toString method in printing Every object has a built-in toString method Remember System.out.println(myObject); // gives you: 2@2a139a55 You overrode the built in toString method by writing your own toString method for the classes you were creating. Then everywhere you need a String representation of the object, the string returned from the toString method will be used

Comparables You now get to do something similar for comparing objects: You decide what will make one object greater than, less than, or equal to another object of the same class. So you decide if you want to compare students by last name, by lab score, by total score, or whatever you want.

public class Student2 implements Comparable<Student2> { String f,l; int g1,g2,g3; int total; public Student2(String f1, String l1, int g11, int g21, int g31) { f = f1; l = l1; g1 = g11; g2 = g21; g3 = g31; total = getTotal(); } public int compareTo(Student2 s2) { System.out.println(total + " " + s2.getTotal()); if (total > s2.getTotal()) { return 1; else if (total < s2.getTotal()) { return -1; else { return 0; } } private int getTotal() { return(g1 + g2 + g3); } public String toString() { String s = ""; s += l + " "+f+": "+total; return(s);

A couple of comments… The comparable interface only has one method – compareTo() All primitive wrapper classes implement the comparable interface Wrapper classes = Integer, Double, Character Our way of making objects out of primitive types CompareTo should return an int: 1 when comparing x to y, x is greater -1 when comparing x to y, y is greater 0 when x and y are considered equal You must write compareTo for every class with which you want to use Arrays.sort or any of the Collections sort method.

public static void main(String[] args) { Student2 s = new Student2("Harry","Jones",20,20,20); Student2 s2 = new Student2("Anne","Rivers",50,50,50); if (s.compareTo(s2)==1) { System.out.println("s is greater "); } else if (s.compareTo(s2)==-1) { System.out.println("s2 is greater"); else { System.out.println("equal"); } 60 150 s2 is greater

public static void main(String[] args) { Student2 s = new Student2("Harry","Jones",20,20,20); Student2 s2 = new Student2("Anne","Rivers",50,50,50); Student2 s3 = new Student2("Bill","Young",30,30,30); Student2 s4 = new Student2("Lisa","Smith",40,40,40); Student2 s5 = new Student2("Joe","Banks",10,10,10); TreeSet<Student2> tree = new TreeSet(); tree.add(s); tree.add(s2); tree.add(s3); tree.add(s4); tree.add(s5); System.out.println(tree); [Banks Joe: 30, Jones Harry: 60, Young Bill: 90, Smith Lisa: 120, Rivers Anne: 150]

public class Student2 implements Comparable<Student2> { String f,l; int g1,g2,g3; int total; public Student2(String f1, String l1, int g11, int g21, int g31) { f = f1; l = l1; g1 = g11; g2 = g21; g3 = g31; total = getTotal(); } public int compareTo(Student2 s2) { return(l.compareTo(s2.l)); private int getTotal() { return(g1 + g2 + g3); } public String toString() { String s = ""; s += l + " "+f+": "+total; return(s); } }

public static void main(String[] args) { Student2 s = new Student2("Harry","Jones",20,20,20); Student2 s2 = new Student2("Anne","Rivers",50,50,50); Student2 s3 = new Student2("Bill","Young",30,30,30); Student2 s4 = new Student2("Lisa","Smith",40,40,40); Student2 s5 = new Student2("Joe","Banks",10,10,10); TreeSet<Student2> tree = new TreeSet(); tree.add(s); tree.add(s2); tree.add(s3); tree.add(s4); tree.add(s5); System.out.println(tree); [Banks Joe: 30, Jones Harry: 60, Rivers Anne: 150, Smith Lisa: 120, Young Bill: 90]

Equals Why can’t we do: When will this be equal? Student2 s = new Student2("Harry","Jones",20,20,20); Student2 sa = new Student2("Harry","Jones",20,20,20); if (s == sa) { System.out.println("They're equal"); } else { System.out.println("Not equal"); When will this be equal?

Equals You can use the compareTo method to determine equality compareTo should return 0 when what you’ve determined to be equality is encountered We often write equals as well. Like toString There’s a built-in equals, but it always compares the actual object In other words, if they’re not literally the same object, they won’t be considered equal. We can override the built-in equals.

public class Student2 implements Comparable<Student2> { String f,l; int g1, g2, g3, total; public Student2(String f1, String l1, int g11, int g21, int g31) { f = f1; l = l1; g1 = g11; g2 = g21; g3 = g31; total = getTotal(); } public boolean equals(Student2 s2) { return(f.equals(s2.f)&&l.equals(s2.l) &&g1==s2.g1 && g2==s2.g2 && g3==s2.g3); public int compareTo(Student2 s2) { System.out.println(total + " " + s2.getTotal()); return(l.compareTo(s2.l)); private int getTotal() { int t = g1 + g2 + g3; return(t); public String toString() { String s = ""; s += l + " "+f+": "+total; return(s); } }

public static void main(String[] args) { Student2 s = new Student2("Harry","Jones",20,20,20); Student2 sa = new Student2("Harry","Jones",20,20,20); if (s == sa) { System.out.println("They're equal"); } else { System.out.println("Not equal"); if (s.equals(sa)) { System.out.println("they're equal"); System.out.println("nope"); Not equal they're equal

As a general rule In general, it is considered good coding practice to make equals and compareTo compare equally. It just makes sense… People expect it… So the compareTo function should’ve been:

compareTo and equals public boolean equals(Student2 s2) { return (f.equals(s2.f)&&l.equals(s2.l) && g1==s2.g1 && g2==s2.g2 && g3==s2.g3); } public int compareTo(Student2 s2) { if (total > s2.getTotal()) { return 1; } else if (total < s2.getTotal()) { return -1; else { if (l.compareTo(s2.l) != 0) { return l.compareTo(s2.l); else if (f.compareTo(s2.f) != 0){ return f.compareTo(s2.f); else if (g1>s2.g1) { return 1; } else if (g1 < s2.g1) {return -1; } else if (g2>s2.g2) { return 1; } else if (g2 < s2.g2) {return -1; } else if (g3>s2.g3) { return 1; } else if (g3 < s2.g3) {return -1; } else { return 0; }