# Java Collections

Week 3 (Oct 5th)

**Part 1**

In java a *collection* is an object that represents a group of objects.
The collections API is a unified framework for representing and manipulating collections independently of their implementation.

An *API* (application programming interface) is an interface protocol between a client and a server, intended to simplify the client side software.

A *library* contains re-usable chunks of code.

**Java Collections framework**
- We have container objects that contain objects
- All containers are either "collections" or "maps"
- All containers provide a common set of method signatures, in addition of their unique set of method signatures

*Collection* - Something that holds a dynamic collection of objects
*Map* - Defines mapping between keys and objects (two collections)
*Iterable* - Collections are able to return an iterator objects that can scan over the contents of a collection one object at a time

NOTE: Vector is a legacy structure in Java replaced with *ArrayList*
      Stack is now *ArrayDeque*

`LinkedList(Collection<? extends E> c)` - means some type that either is E or a subtype of E. The `?` is a wildcard.

```java
public static void main(String[] args) {
     LinkedList list = new LinkedList();
     list.add("string");
     String s = (String)list.getFirst();
     System.out.println(s);
}
```

This is bad coding practice, the collection constructor are not able to specify the type of objects the collection is intended to contain. A `ClassCastException` will be thrown if we attempt to cast the wrong type.

```java
public static void main(String[] args) {
     LinkedList<String> list = new LinkedList<>();
     list.add("string");
     String s = list.getFirst();
     System.out.println(s);
}
```

This is a type safe collection using generics.
- Classes support generics by allowing a type variable to be included in their declaration.
- The `<>` show the same type as stated (in this case string)
- You cannot type a collection with a primitive data type eg int

**HashMap Class**
- A HashMap is a hash table based implementation of the map interface. This implementation provides all if the optional map operations, and permits null values and the null key.

```java
public static void main(String[] args) {
     HashMap<String, Integer> userData = new HashMap<>();
	 userData.put("Emma", 30);
	 userData.put("John", null);
	 userData.put("Millie", 17);

	 Set<String> keys = userData.keySet();

	 for (String key:keys){
	 	System.out.println(key + "=" userData.get(key));
	 }
}
```

```
Emma = 30
John = null
Millie = 17
```

**Part 2**

__Relationships between objects__

*Aggregation* - The object exists outside the other. It is created outside so it is passed as an argument.
An animal object *is part of* a compound object (semantically) but the animal object can be shared and if the  compound object is deleted, the animal object isn't deleted.

```java
public class Compound {
	private Animal dog;

	public void setAnimal(Animal dog){
		this.dog = dog;
	}
}
```

![Image](/lectures/dms/assets/1.png)

*Composition* - The object only exists if the parent object exists, if the parent object is deleted then so is the child object.
The zoo object owns the compound object. If the zoo object is deleted then the compound object is also deleted.

```java
public class Zoo {
	private Compound dogArea = new Compound();
}
```

![Image](/lectures/dms/assets/2.png)

**Inheritance**
A way of forming new classes based on existing classes. Has a "is-a" relationship.

*Polymorphism* - A concept in object oriented programming. Method overloading and method overriding are two types of polymorphism.
- *Method Overloading* - Methods with the same name co-exist in the same class but they must have different method signatures. Resolved during compile time (static binding).
- *Method Overriding* - Methods with the same name is declared in parent and child class. Resolved during runtime (dynamic binding).

```java
public class Child extends Parent {
	public Child(String name){
		super(name);
	}
	
	@Override
	Public void eat() {
		chew();
	}
}
```

The super keyword called the parent class' constructor.

![Image](/lectures/dms/assets/3.png)

**What is the difference between an abstract class and an interface**
- Java abstract class can have instance methods that implement a default behaviour. May contain non-final variables.
- Java interfaces have methods that are implicitly abstract and cannot have implementations. Variables are declared final by default.

Interfaces are less restrictive when it comes to inheritance, interfaces can have many levels of inheritance where as a class can only have one level.
