This document provides an overview of Java collections including common implementations like lists, maps, and queues. It discusses how collections allow storing and accessing multiple objects, the benefits of generics for type safety, and useful methods in the Collections class for sorting, shuffling, and copying collections. Code examples are provided for creating parameterized lists and maps, sorting lists using Comparator, and exercises for working with collections in practice.

1. Java Collections Lectures
http://eglobiotraining.com/
Prof. Erwin M. Globio, MSIT
Experienced Java Developer

2. Java Collections
A Java collection is a data structure which contains and processes a set of
data. The data stored in the collection is encapsulated and the access to the
data is only possible via predefined methods.
For example if your application saves data in an object of type People, you
can store several People objects in a collection.
While arrays are of a fixed size, collections have a dynamic size, e.g. a
collection can contain a flexible number of objects.
Typical collections are: stacks, queues, deques, lists and trees.
As of Java 5 collections should get parameterized with an object declaration
to enable the compiler to check if objects which are added to the collection
have the correct type. This is based on Generics. Generics allow a type or
method to operate on objects of various types while providing compile-time
type safety.

3. The following code shows an example how to create a Collection of type List which is
parameterized with <String> to indicate to the Java compiler that only Strings are allowed in this
list. .
package collections;
import java.util.ArrayList;
public class MyArrayList {
public static void main(String[] args) {
// Declare the List concrete type is ArrayList
List<String> var = new ArrayList<String>();
// Add a few Strings to it
var.add("Lars");
var.add("Tom");
// Loop over it and print the result to the console
for (String s : var) {
System.out.println(s);
}
}
}

4. If you try to put a non String into this list, you would
receive a compiler error.
List is only an interface, a common implementation is the
ArrayList class, hence you need to call new ArrayList().

5. Important implementations
Map and HashMap
The Map interface defines an object that maps keys to values. A map cannot contain
duplicate keys; each key can map to at most one value.
The HashMap class is an efficient implementation of the Map interface. The
following code demonstrates its usage.
package com.eglobiotraining.java.collections.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class MapTester {
public static void main(String[] args) {
// Keys are Strings
// Objects are also Strings

6. Map<String, String> mMap = new HashMap<String, String>();
mMap.put("Android", "Mobile");
mMap.put("Eclipse", "IDE");
mMap.put("Git", "Version control system");
// Output
for (String key : mMap.keySet()) {
System.out.println(key +" "+ mMap.get(key));
}
System.out.println("Changing the data");
// Adding to the map
mMap.put("iPhone", "Created by Apple");
// Delete from map

7. mMap.remove("Android");
System.out.println("New output:");
// Output
for (String key : mMap.keySet()) {
System.out.println(key +" "+ mMap.get(key));
}
}
}

8. List, ArrayList and LinkedList
List is the interface which allows to store objects in a resizable
container.
ArrayList is implemented as a resizable array. If more elements
are added to ArrayList than its initial size, its size is increased
dynamically. The elements in an ArrayList can be accessed
directly and efficiently by using the get() and get() methods,
since ArrayList is implemented based on an array.
LinkedList is implemented as a double linked list. Its performance
on add() and remove() is better than the performance of
Arraylist. The get() and get() methods have worse performance
than the ArrayList, as the LinkedList does not provide direct
access.

9. The following code demonstrates the usage of List and ArrayList.
package com.eglobiotraining.java.collections.list;
import java.util.ArrayList;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(3);
list.add(2);
list.add(1);
list.add(4);
list.add(5);
list.add(6);
list.add(6);
for (Integer integer : list) {
System.out.println(integer);
}
}
}

10. Useful collection methods
The java.util.Collections class provides useful functionalities
for working with collections.
Collections
Method Description
Collections.copy(list, list) Copy a collection to another
Collections.reverse(list) Reverse the order of the list
Collections.shuffle(list) Shuffle the list
Collections.sort(list) Sort the list

11. Using Collections.sort and Comparator in Java
Sorting a collection in Java is easy, just use the
Collections.sort(Collection) to sort your values. The following
code shows an example for this.
package de.eglobiotraining.algorithms.sort.standardjava;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Simple {
public static void main(String[] args) {
List list = new ArrayList();

12. list.add(5);
list.add(4);
list.add(3);
list.add(7);
list.add(2);
list.add(1);
Collections.sort(list);
for (Integer integer : list) {
System.out.println(integer);
}
}
}

13. This is possible because Integer implements the Comparable interface. This
interface defines the method compare which performs pairwise comparison of
the elements and returns -1 if the element is smaller then the compared
element, 0 if it is equal and 1 if it is larger.
If what to sort differently you can define your own implementation based on the
Comparator interface.
package com.eglobiotraining.algorithms.sort.standardjava;
import java.util.Comparator;
public class MyIntComparable implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return (o1>o2 ? -1 : (o1==o2 ? 0 : 1));
}
}

14. package com.eglobiotraining.algorithms.sort.standardjava;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Simple2 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(5);
list.add(4);
list.add(3);
list.add(7);
list.add(2);
list.add(1);
Collections.sort(list, new MyIntComparable());
for (Integer integer : list) {
System.out.println(integer);
}
}
}

15. Note
For the above you could also have used the
Collection.reverse() method call.
This approach is that you then sort any object by any
attribute or even a combination of attributes. For example if
you have objects of type Person with an attribute income
and dataOfBirth you could define different implementations
of Comparator and sort the objects according to your needs.

16. Exercise: Use Java Collections
Create a new Java project called
com.vogella.java.collections. Also add a package with the
same name.
Create a Java class called Server with one String attribute
called url.
package com.eglobiotraining.java.collections;
public class Server {
private String url;
}

17. Create getter and setter methods for this attribute using code generation capabilities of
Eclipse. For this select Source → Generate Getters and Setters from the Eclipse menu.
Create via Eclipse a constructor which gets a url as parameter. For this select Source →
Generate Constructor using Fields... from the Eclipse menu.
Type main in the class body and use code completion (Ctrl+Space) to generate a main
method.

18. In your main method create a List of type ArrayList and add 3
objects of type Server objects to this list.
public static void main(String[] args) {
List<Server> list = new ArrayList<Server>();
list.add(new Server("http://www.eglobiotraining.com"));
list.add(new Server("http://www.google.com"));
list.add(new Server("http://www.heise.de"));
}

19. Use code completion to create a foreach loop and write the
toString method to the console. Use code completion based
on syso for that.
Run your program.
Use Eclipse to create a toString method based on the url
parameter and re-run your program again.

21. Prof. Erwin M. Globio, MSIT
Managing Director of eglobiotraining.com
IT Professor of Far Eastern University
Mobile: 09393741359 | 09323956678
Landline: (02) 428-7127
Email: erwin_globio@yahoo.com
Skype: erwinglobio
Website: http://eglobiotraining.com/