Containers Data Structures Container object data Structure An

Containers (Data Structures)

Container object: data Structure • An object that groups things. We group things so we can store, retrieve, and manipulate data. • Containers: • Automatically grow in size • Only contain objects • No primitive types (e. g. , int, float, double) • Have a bunch of convenient methods written for us • E. g. , add

Why containers? • What’s wrong with arrays?

Methods of Containers (collections): • Containers store data and provide methods that you’d use with stored data • • • Add(object) Remove(object) Size Contains Equals Iterator (we’ll talk about this one later) • One type of container: Lists

Array. Lists: • Container: used to store a list of some objects • Remember arrays? Student[] classroom = new Student[60]; • Why is this a pain? Do you see any difficulties with this array? • How do you add a 61 st student? • What if students drop?

Array. Lists: • The Array. List class has the following methods: • • • • • add(o) appends the new object o to the end of the list add(i, o) adds the object o at the index i (an int) add. All(Collection<? > c) adds everythin from collection c to the Array. List (at the end) clear() removes all elements from the list contains(o) returns true if the list contains the object o get(i) returns the element located at index i in the list index. Of(o) returns the index of the object o in the list is. Empty() returns true if the list contains no elements last. Index. Of(o) returns the index of the last matching element in the list remove(index) removes the element at index and returns it from the list remove(object) removes the object from the list and returns true if successful, false otherwise remove. All(Collection<? > c) remove from this list all the elements in the collection list remove. Range(fromindex, toindex) removes everything in the list from the fromindex to the toindex (excluding the toindex) retain. All(Collection<? > c) keeps in the list only objects in the collection set(index, o) sets the element at the index to the object o size() returns the number of elements in the list sub. List(fromindex, toindex) returns a list from the from index to the toindex.

Array. Lists: • import java. util. Array. List; • Array. List al = new Array. List(); // this works… • What type is al? • This is a container: what does it contain?

Array. Lists • Work on Generic Types (we’ll discuss this more shortly) • We don’t have to specify the type for the methods in Array. List to work • But we can… • And then we can use the methods and values associated with the class type: • Array. List<Dog> al = new Array. List<Dog>(); • Or the shortcut: • Array. List<Dog> a. I= new Array. List(); // this is better!

Example: public static void main(String[] args) { Array. List<Dog> Dog. Show. Winners = new Array. List(); Dog. Show. Winners. add(new Dog("Spot")); Dog. Show. Winners. add(new Dog("Fang")); Dog. Show. Winners. add(new Dog("Puppy")); Dog. Show. Winners. add(new Dog("Bernice")); Dog. Show. Winners. add(new Dog("Sandy")); System. out. println("List size? "+Dog. Show. Winners. size()); Dog. Show. Winners. add(2, new Dog("Prince")); for (Dog x: Dog. Show. Winners) { System. out. println(x. get. Name()); } } List size? 5 Spot Fang Prince Puppy Bernice Sandy

Using dog methods? public static void main(String[] args) { Array. List<Dog> Dog. Show. Winners = new Array. List(); Dog. Show. Winners. add(new Dog("Spot")); Dog. Show. Winners. add(new Dog("Fang")); Dog. Show. Winners. add(new Dog("Puppy")); Dog. Show. Winners. add(new Dog("Bernice")); Dog. Show. Winners. add(new Dog("Sandy")); System. out. println("List size? "+Dog. Show. Winners. size()); Dog. Show. Winners. add(2, new Dog("Prince")); } • System. out. println(Dog. Show. Winners. get(3). get. Name());

Diff between arrays and Array. Lists Operation Array. List Creating String[] a = new String[10] Array. List<String> list = new Array. List(); Accessing a[index] list. get(index); Updating a[index] = “London”; list. set(index, ”London”); Getting Size a. length list. size(); Adding a new element list. add(“London”); Insertnig a new element list. add(index, ”London”); Removing an element list. remove(“index”); Removing all elements list. clear();

Array. Lists: Can’t do: • Array. List<int> x = new Array. List(); (Can’t use primitive types, must use object types) Instead: • Array. List<Integer> x = new Array. List(); • Array. List<Character> • Array. List<Double> • Array. List<Boolean>

Behind the scenes: • We create a relatively long array that can resize dynamically • This means that if we add an object, we move everything from where we added it down by one • If we’re adding to the end, how many operations do we need to do? • If we add to the beginning of the list? • Removing an object – how many operations will we need to remove the object from the array?

Linked Lists • Another type of list in our containers • Does a lot of what Array. Lists do: • Trying to find ways of being efficient (we’ll talk about this more later)

Linked List methods: • The Linked. List class has the following methods: • • • • add(o) appends the new object o to the end of the list add(i, o) adds the object o at the index i (an int) add. All(Conllection<? > c) adds all of the elements in c to the end of the linked list clear() removes all elements from the list contains(o) returns true if the list contains the object o get(i) returns the element located at index i in the list index. Of(o) returns the index of the object o in the list is. Empty() returns true if the list contains no elements last. Index. Of(o) returns the index of the last matching element in the list remove(index) removes the element at index and returns it from the list remove(object) removes the object from the list and returns true if successful, false otherwise remove. All(Collection<? > c) remove from this list all the elements in the collection list retain. All(Collection<? > c) keeps in the list only objects in the collection set(index, o) sets the element at the index to the object o size() returns the number of elements in the list

Why so many methods in common with Array. Lists? • Both Array. Lists and Linked. Lists inherit from the Collection Interface • What does this mean? • What are the implications?

Collection Interface • • • • add(? x) //? Is the type – type varies add. All(Collection<? > c) clear() contains(? x) contains. All(Collection<? > c) equals(? x) hash. Code() is. Empty() remove(? x) remove. All(Collection<? > c) retain. All(Collection<? > c) Size() to. Array() Anything that

Back to Linked Lists Linked. List<String> x = new Linked. List(); x. add(“cat”); x. add(“dog”); x. add(“bunny”); x. remove(“dog”); Array. List<String> q = new Array. List(); q. add(“cat”); q. add(“puppy”); q. add(“bunny”); q. add(“cow”); if (q. contains. All(x) ) { System. out. println(“all the animals are in the list”); }

So why do we have Linked. Lists and Array. Lists? • Because of how they work…

Linked Lists (behind the scenes): • Linked Lists are a series of single objects, with each object having a pointer (a link) to the next object. • Each element (node) consists of 2 things: data and a pointer to another node. • The first node is the head, and the last is the tail (pointing to null) • This is a representation of a singly linked list (meaning each node points to the next node in the list).

Singly Linked List class: public class Node<Any. Type> { public Any. Type data; public Node<Any. Type> next; public Node(Any. Type data, Node<Any. Type> next) { this. data = data; this. next = next; } public Node(Any. Type data) { this. data = data; this. next = Null; } }

Linked. Lists vs Array. Lists For Array. List<E> • get(int index) is O(1) //main benefit of Array. List<E> • add(E element) is O(n) worst-case (since the array must be resized and copied) • add(int index, E element) is O(n) worst-case (as above) • remove(int index) is O(n - index) (i. e. removing last is O(1)) For Linked. List<E> • get(int index) is O(n) • add(E element) is O(1) // main benefit of Linked. List<E> • add(int index, E element) is O(n) • remove(int index) is O(n)

Back to Collections • Lists: • Array. List • Linked. List • Sets • No duplicates • No order (Tree. Sets happen to have an order) • Maps (more to come) • 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

Sets • Uses the Collection interface • So has to implement the method signatures in the Collection interface • E. g. , add, remove, contains, • In this case, the add method must not only add the object to the set, it must check to see if the object is already in the set and only add it if it is not already in the set) • Note that we don’t have a get method (does Collection interface have a get signature? ) • Get doesn’t make sense with sets: • Set. get(index) • There’s no order to a set • Tree. Set/Hash. Set • Both sets implemented by java using the Collection interface

Hash Set • Used more frequently • Faster than Tree. Set for contains, add, remove • Generally faster than lists too! (but not the same as lists) • No ordering • Idea: we take an object that we want to place into the set, then use a “hashing function” on the object to get a unique index (hopefully). The object is then placed at that unique index in an array. • E. g. , a ridiculously simple hashing function (that no one would ever use) is to take the numeric equivalent of all the characters in an object’s fields, add them together, and then take that number modulus the length of the array into which we are placing the object.

Hash. Sets • Idea: Use a “hashing function” on an object to get a unique index and place the object at that unique index in an array. • Issues to think about : • What if more than one object generates the same index? What do we want to do then? • How big should we make the original array? Is this wasteful? • How do we make sure the hash function doesn’t generate index values outside of the range of the array? • Goal: to be able to locate objects quickly • The hash function should generate the same index for all objects that are equal

Methods: • • • • add(o) appends the new object o to the set add. All(Collection<? > c) adds everything from collection c to the Hash. Set (at the end) clear() removes all elements from the set contains(o) returns true if the set contains the object o contains. All(Collection<? > c) returns true if the set contains all the elements in the collection set equals(Collection<? > c) checks if the collection c and the hashset have the same set of objects is. Empty() returns true if the set contains no elements remove(object) removes the object from the set and returns true if successful, false otherwise remove. All(Collection<? > c) remove from this set all the elements in the collection set retain. All(Collection<? > c) keeps in the set only objects in the collection size() returns the number of elements in the set to. Array() to. String()

Hash. Set<String> hs = new Hash. Set(); // add elements to the hash set hs. add("B"); hs. add("A"); hs. clear(); hs. add("D"); hs. add("E"); hs. add("C"); hs. add("F"); hs. remove(1); hs. add("D"); hs. add(1, "U"); hs. add ("K"); System. out. println(hs); // What does this give you?

Tree. Set • Tree • Faster than Hash. Set for subset • Ordered! • Theoretically should be pretty quick for adding, removing, and contains (log n time), even while maintaining sorted order

Idea: Add 51? Add 15?

Methods: • • • • • • • add(o) appends the new object o to the set add. All(Collection<? > c) adds everything from collection c to the Hash. Set (at the end) ceiling(? 0) Returns the least element in this set greater than or equal to the given element, or null if there is no such element. clear() removes all elements from the set contains(o) returns true if the set contains the object o contains. All(Collection<? > c) returns true if the set contains all the elements in the collection set descending. Set() – returns a reverse order view of the set equals(Collection<? > c) checks if the collection c and the hashset have the same set of objects first() returns the smallest element in the set floor(? o) returns the greatest element in the set less than o headset (? o) returns a view of the set up to the object o higher(? o) retuns the first element after o in the set is. Empty() returns true if the set contains no elements last() – returns the last object in the set lower(? o) – returns the greatest object in the set that is less than the object o poll. First() – removes and returns the first object in the set poll. Last() – removes and returns the last object in the set remove(object) removes the object from the set and returns true if successful, false otherwise remove. All(Collection<? > c) remove from this set all the elements in the collection set retain. All(Collection<? > c) keeps in the set only objects in the collection size() returns the number of elements in the set subset(? o 1 ? o 2) – returns a view of the set of objects that range from the first object (inclusive) to the last object (exclusive) tail. Set(? o) – returns a view of the set whose elements are greater than or equal to the object to. Array() to. String()

Tree. Set<Integer> tree = new Tree. Set(); tree. add(12); tree. add(63); tree. add(34); tree. add(45); tree. add(16); tree. add(22); tree. add(54); for (Integer x: tree) { System. out. print(x + " "); } System. out. println(); System. out. println(tree. sub. Set(22, 54)); if (tree. is. Empty()) { System. out. print("Tree Set is empty. "); } else { System. out. println("Tree Set size: " + tree. size()); } System. out. println("First data: " + tree. first()); System. out. println("Last data: " + tree. last()); if (tree. remove(45)) { System. out. println("Data is removed from tree set"); } else { System. out. println("Data doesn't exist!"); } tree. clear(); if (tree. is. Empty()) { System. out. print("Tree Set is empty. "); } else { System. out. println("Tree Set size: " + tree. size()); } Tree. Set

public class Tree { Node root; public void add. Node(int key) { Node new. Node = new Node(key); // Create a new Node and initialize if (root == null) { // If there is no root this becomes root = new. Node; } else { // Set root as the Node we will start with as we traverse the tree Node focus. Node = root; Node parent; // Future parent for our new Node while (true) { parent = focus. Node; // root is the top parent so we start the if (key < focus. Node. key) { // Check if the new node should go on the left side of the parent nod focus. Node = focus. Node. left. Child; // Switch focus to the left child if (focus. Node == null) { // If the left child has no children parent. left. Child = new. Node; // then place the new node on the left of it return; // All Done } } else if (key > focus. Node. key){ // If we get here put the node on the right focus. Node = focus. Node. right. Child; if (focus. Node == null) { // If the right child has no children parent. right. Child = new. Node; // then place the new node on the right of it return; // All Done } } else { //already in tree return; } } public Node find. Node(int key) { Node focus. Node = root; // Start at the top of the tree while (focus. Node. key != key) { // While we haven't found the Node keep looking if (key < focus. Node. key) { // If we should search to the left focus. Node = focus. Node. left. Child; // Shift the focus Node to the left child } else { focus. Node = focus. Node. right. Child; // Shift the focus Node to the right child } if (focus. Node == null) { // The node wasn't found return null; } } return focus. Node; } public void Print. Tree(Node focus. Node) { // Recursion is used to go to one node and then go to its child nodes and so forth if (focus. Node != null) { Print. Tree(focus. Node. left. Child); // Traverse the left nod System. out. print(focus. Node + " "); // Visit the currently focused on node Print. Tree(focus. Node. right. Child); // Traverse the right node } } public class Node { int key; Node left. Child; Node right. Child; public Node(int key) { this. key = key; } public String to. String() { String str = ""; str += key + " "; return str; } } public static void main(String[] args) { Tree the. Tree = new Tree(); the. Tree. add. Node(50); the. Tree. add. Node(30); the. Tree. add. Node(15); the. Tree. add. Node(30); the. Tree. Print. Tree(the. Tree. root); System. out. println(the. Tree. find. Node(30)); System. out. println(the. Tree. find. Node(15)); }

Back to Collections • Lists: • Array. List • Linked. List • Sets • No duplicates • No order (Tree. Sets happen to have an order) • Maps (more to come) • 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

• 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) • Student name (key) -> class schedule (value)

Map Methods • Maps keys to values • No duplicate keys Ø Each key maps to a value Methods: • • • • void clear( ) Removes all key/value pairs from the invoking map. boolean contains. Key(Object k) Returns true if the invoking map contains k as a key. Otherwise, returns false. boolean contains. Value(Object v) Returns true if the map contains v as a value. Otherwise, returns false. Set entry. Set( ) Returns a Set that contains the entries in the map. The set contains objects of type Map. Entry. This method provides a set-view of the invoking map. boolean equals(Object obj) Returns true if obj Object get(Object k) Returns the value associated with the key k. is a Map and contains the same entries. Otherwise, returns false. boolean is. Empty( ) Returns true if the invoking map is empty. Otherwise, returns false. Set key. Set( ) Returns a Set that contains the keys in the invoking map. This method provides a set-view of the keys in the invoking map. Object put(Object k, Object v) Puts an entry in the invoking 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 put. All(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. Collection values( ) Returns a collection containing the values in the map. This method provides a collection-view of the values in the map.

Map Implementations • Hash. Map (uses hashing function on keys) ØFast • Tree. Map (orders keys) ØSorted ordering ØKey-ordered iteration • Linked. Hash. Map (guess) ØFast ØInsertion-order iteration

Declaring Maps • Declare types for both keys and values • Class Hash. Map<K, V> Hash. Map<String, Array. List<String>> map = new(); Keys are Strings Values are Lists of Strings

Hash. Map<Integer, String> map = new Hash. Map(); 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 k = 21; String value = map. get(k); // 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 Hash. Map contains 21 as key: " + map. contains. Key(21)); System. out. println("Does Hash. Map contains 21 as value: " + map. contains. Value(21)); System. out. println("Does Hash. Map contains Twenty One as value: " + map. contains. Value("Twenty One")); map. put(41, "Thirty One"); System. out. println("Unsorted Hash. Map: " + map); Tree. Map sorted. Hash. Map = new Tree. Map(map); // cool stuff System. out. println("Sorted Hash. Map: " + sorted. Hash. Map); map. clear(); //clears hashmap , removes all element System. out. println("Is Hash. Map is empty: " + map. is. Empty()); System. out. println("Size of Map: " + map. size());

Looping through map: • More than one way: for (Integer key : map. key. Set()) { System. out. println("Key : " + key. to. String() + " Value : "+ map. get(key)); } Or we could 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. has. Next(); ) { Object o = i. next(); System. out. println(o); } Everything that inherits from Collections Interface has an iterator In most cases, the iterator is the 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 • List. Iterator 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 has. Next( ) • Have the loop iterate as long as has. Next( ) returns true. • Within the loop, obtain each element by calling next( ).

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

List. Iterator 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 has. Next( ) Returns true if there is a next element. Otherwise, returns false. • boolean has. Previous( ) Returns true if there is a previous element. Otherwise, returns false. • Object next( ) Returns the next element. A No. Such. Element. Exception is thrown if there is not a next element. • int next. Index( ) 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 No. Such. Element. Exception is thrown if there is not a previous element. • int previous. Index( ) 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 Illegal. State. Exception 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( ).

public class Iterator. Demo { public static void main(String args[]) { // Create an array list Array. List al = new Array. List(); // add elements to the array list al. add("C"); al. add("A"); al. add("E"); al. add("B"); al. add("D"); al. add("F"); // Use iterator to display contents of al System. out. print("Original contents of al: "); Iterator itr = al. iterator(); while(itr. has. Next()) { Object element = itr. next(); System. out. print(element + " "); } System. out. println(); // Modify objects being iterated List. Iterator litr = al. list. Iterator(); while(litr. has. Next()) { Object element = litr. next(); litr. set(element + "+"); } System. out. print("Modified contents of al: "); itr = al. iterator(); while(itr. has. Next()) { Object element = itr. next(); System. out. print(element + " "); } System. out. println(); // Now, display the list backwards System. out. print("Modified list backwards: "); while(litr. has. Previous()) { Object element = litr. previous(); System. out. print(element + " "); } System. out. println(); }

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

Linked Lists • http: //www. youtube. com/watch? v=195 KUinj. Bp. U