Feb 18, 2020 -- Notes

IT 313 -- Feb 18, 2020

Practice Exercise

Modify the BarChart class in the JFreeChart Example to read exchange rates from the input file exchange-rates.txt and display them in a JFreeChart barchart.
Ans: Here is the modified BarChart class, which uses the input file exchange-rates.txt. Here is a second version that uses two input files currencies.txt and exchange-rates.txt. Finally, here is a third version with extracted getExchangeRate method. This method was obtained by IntelliJ using refactoring (Extract Method).

Combine this example with the code that obtains the exchange rates form the io.fixer website in Item 2 of the Project 5 Section in the Feb 6 Class Notes.

Interfaces

An interface is used to insure uniformity among seemingly disparate classes.
Interfaces are used in Java instead of multiple inheritance.
See the speaker module in the Interfaces Example. The Speaker interface has the required method speak.
An interface can be thought of as a contract:
1. The party writing the interface agrees not to change it after it is published.
2. The class implementing the interface agrees to supply all of the required methods.
Here are some interfaces that are part of the Java class library collections framework:
- Comparable Insures that objects can be sorted.
- Serializable Insures that objects can be serialized and deserialized.
- Collection Used to pass objects where maximum generality is required.
- Set Refers to collections where no duplicate elements are allowed.
- List Refers to an ordered collection such as an ArrayList or SortedList.
- Map Refers to a collection where elements are stored and accessed by key (also called a hashtable or a dictionary). HashMap is a commonly used implementation.

Here are some other Java Class Library interfaces:

AccessibleStreamable  Callable  Cloneable  Closeable  
Compilable  Destroyable  Externalizable  Flushable  
Formattable  Invocable  ItemSelectable  Iterable  
JMXAddressable  Joinable  Pageable  Printable  Readable  
Referenceable  Refreshable  Runnable  Scrollable  
StateEditable  Streamable  Transferable  TypeVariable

See the sortable module in the Interfaces Example. Objects that implement the Comparable interface can be sorted in arrays or collections.

Iterators

An iterator is an object that sequentially presents all the objects in a collection.

An iterator is implicitly used in this loop:

for(Object obj : col) {
    System.out.println(obj);
}

An explicit Iterator object can be created. Look up some of the Iterator methods in the Java Class Library. Some of the Iterator methods are the same as the Scanner methods.

Here is some code that explicitly defines and uses an iterator:

// Create and populate array list.
ArrayList<Object> col = new ArrayList<Object>( );
col.add(5);
col.add("dog");
col.add(false);
System.out.println(col);

// Obtain and use iterator from array list.
Iterator itr = col.iterator( );
while (itr.hasNext( )) {
  Object element = itr.next( );
  System.out.println(element);
}

Java Collections

A collection (also called a collection class or container class) is an object that groups multiple objects in to a single unit.
A collections framework is a unified architecture for working with collections and objects. It includes
- interfaces abstract datatypes that allow objects to refer to other objects in the framework.
- implementations reusable data structures for manipulating objects in the framework.
- algorithms methods that perform operations (for example searching and sorting) of objects in the framework.
Some advantages of a collections framework:
- Reduces programming effort
- Increases program speed and quality
- Allows interoperability among related APIs
- Reduces effort to learn and to use new APIs
- Reduces effort to design new APIs
- Facilitates software reuse

Some Important Java Collections:

ArrayList  HashMap  HashSet  ArrayDequeue  LinkedList
LinkedHashSet  LinkedHashMap  TreeSet  TreeMap

Each collection class, including the ArrayList collection, has an iterator that allows one to sequentially perform an operation on each element in the collection.

Practice Problem: Try this out on the array list containing the Dog objects like this:

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;

public class Test {
    public static void main(String[] args) {

        ArrayList<Dog> col = new ArrayList<Dog>( );

        Calendar c1 = Calendar.getInstance( );
        c1.set(2017, 10,17);
        Dog d1 = new Dog("Molly", 'F', "Golden Lab", c1, 1111, true);
        System.out.println(d1);

        Calendar c2 = Calendar.getInstance( );
        c1.set(2017, 8,15);
        Dog d2 = new Dog("Sushi", 'M', "Pomeranian", c2, 2222, false);
        System.out.println(d2);

        Calendar c3 = Calendar.getInstance( );
        c3.set(2012, 3,5);
        Dog d3 = new Dog("Sasha", 'F', "Rough Collie", c3, 3333, false);
        System.out.println(d3);

        col.add(d1);
        col.add(d2);
        col.add(d3);

        // Implicit Iterator
        for(Dog d : col) {
            System.out.println(d);
        }

        // Explicit Iterator
        Iterator<Dog> itr = col.iterator( );
        while (itr.hasNext( )) {
            Dog element = itr.next( );
            System.out.println(element);
        }
    }
}

The HashMap Collection

Problem 1: Create a HashMap collection that contains these items:

Key	Value	Value Datatype
"C111"	"apple"	String
"C222"	194	Integer
"C333"	3.14159	Double
"C444"	'W'	Character
"C555"	true	Boolean

Ans:

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Object> hm = new HashMapS<tring, Object>(50, 0.5f);

        hm.put("C111", "apple");
        hm.put("C222", 194);
        hm.put("C333", 3.14159);
        hm.put("C444", 'W');
        hm.put("C555", true);

        System.out.println(hm);
        System.out.println(hm.get("C444"));
    }
}

Problem 2: Create a HashMap collection that contains four Dog objects. Ans:

import java.util.Calendar;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        Calendar c1 = Calendar.getInstance( );
        c1.set(2017, 10,17);
        Dog d1 = new Dog("Molly", 'F', "Golden Lab",
                c1, 1111, true);
        //System.out.println(d1);

        Calendar c2 = Calendar.getInstance( );
        c1.set(2017, 8,15);
        Dog d2 = new Dog("Sushi", 'M', "Pomeranian",
                c2, 2222, false);
        //System.out.println(d2);

        Calendar c3 = Calendar.getInstance( );
        c3.set(2012, 3,5);
        Dog d3 = new Dog("Sasha", 'F', "Rough Collie",
                c3, 3333, false);

        HashMap<Integer, Dog> col = new HashMap<Integer, Dog>(50, 0.5f);
        col.put(1111, d1);
        col.put(2222, d2);
        col.put(3333, d3);
        System.out.println(col);
    }
}

Problem 3: Show how to insert elements into a hash table. For the in-class members, use the last two digits of your social security as your hash code (hashCode) % 50. (If the last two digits of your SSN are less than 50, then use them as-is. If they are greater or equal to fifty, subtract 50 so that your hash code is in the range from 0 to 49 inclusive. The hash table will be an array of size 50. Write your initials in the array cell corresponding to your hash code. If the cell with index hashCode is already occupied (a collision occurs), write your initials in (hashCode + 1) % 50. If that cell is already occupied, use the cell (hashCode + 2) % 50, etc. Eventually you will find an empty cell unless the hash table is completely full.
The load factor is the maximum percentage of occupied cells in the table. When the percentage of occupied cells in a hash table reaches the load factor, the size of the table is automatically increased. The load factor is a tradeoff; if the load factor is too small, there is wasted space in the table. If the load factor is too high, there will be many collisions, which wastes time and computing resources.

Here is a picture of the whiteboard after each student entered his or her initials in the location specified by
```
hashCode = socialSecurityNumber % 50
```
Fourteen sets of initials are stored in the hashtable of size 50, so the load factor is 14 / 50 = 28%.

Project 6a

Discuss Project 6a.