136 lines
4.6 KiB
Markdown
136 lines
4.6 KiB
Markdown
# 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;
|
|
}
|
|
}
|
|
```
|
|
|
|
|
|
|
|
*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();
|
|
}
|
|
```
|
|
|
|
|
|
|
|
**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.
|
|
|
|
|
|
|
|
**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.
|