Scribd
Upload
26 views

Java Collections API

The document provides an overview of Java arrays and collections. It discusses declaring and initializing arrays, looping through arrays, copying arrays, sorting arrays, and checking array bounds. It then covers Java collection classes like ArrayList and HashMap, adding and retrieving items from collections, iterators for traversing collections, and using Comparable and Comparator interfaces for sorting collections.

Uploaded by

Hassaan Khan
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
26 views

Java Collections API

The document provides an overview of Java arrays and collections. It discusses declaring and initializing arrays, looping through arrays, copying arrays, sorting arrays, and checking array bounds. It then covers Java collection classes like ArrayList and HashMap, adding and retrieving items from collections, iterators for traversing collections, and using Comparable and Comparator interfaces for sorting collections.

Uploaded by

Hassaan Khan
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 22

Java Collections API

Overview
• Arrays
• Working with arrays
• Java API support for arrays
• Collection classes
• Types of collection
• Working with Collections
Java Arrays – The Basics
• Declaring an array
int[] myArray;
int[] myArray = new int[5];
String[] stringArray = new String[10];
String[] strings = new String[] {“one”, “two”};

• Checking an arrays length


int arrayLength = myArray.length;

• Looping over an array


for(int I=0; I<myArray.length; i++)
{
String s = myArray[i];
}
Java Arrays – Bounds
Checking
• Bounds checking
• Java does this automatically. Impossible to go beyond the end of
an array (unlike C/C++)
• Automatically generates an
ArrayIndexOutOfBoundsException
Java Arrays – Copying
• Don’t copy arrays “by hand” by looping over the
array
• The System class has an arrayCopy method to
do this efficiently
int array1[] = new int[10];
int array2[] = new int[10];
//assume we add items to array1

//copy array1 into array2


System.arrayCopy(array1, 0, array2, 0, 10);
//copy last 5 elements in array1 into first 5 of array2
System.arrayCopy(array1, 5, array2, 0, 5);
Java Arrays – Sorting
• Again no need to do this “by hand”.
• The java.util.Arrays class has methods to sort
different kinds of arrays

int myArray[] = new int[] {5, 4, 3, 2, 1};


java.util.Arrays.sort(myArray);
//myArray now holds 1, 2, 3, 4, 5

• Sorting arrays of objects is involves some extra


work, as we’ll see later…
Java Arrays
• Advantages
• Very efficient, quick to access and add to
• Type-safe, can only add items that match the declared
type of the array
• Disadvantages
• Fixed size, some overhead in copying/resizing
• Can’t tell how many items in the array, just how large
it was declared to be
• Limited functionality, need more general functionality
Java Collections
• What are they?
• A number of pre-packaged implementations of
common ‘container’ classes, such as LinkedLists, Sets,
etc.
• Part of the java.util package.
• Advantages
• Very flexible, can hold any kind of object
• Disadvantages
• Not as efficient as arrays (for some uses)
• Not type-safe. Store references to Object
Java Collections
• Two Types of Containers
• Collections
• Group of objects, which may restricted or manipulated
in some way
• E.g. an ordered to make a List or LinkedList
• E.g. a Set, an unordered group which can only contain
one of each item
• Maps
• Associative array, Dictionary, Lookup Table, Hash
• A group of name-value pairs
Java Collections
Java Collections
• Several implementations associated with each of
the basic interfaces
• Each has its own advantages/disadvantages
• Maps
• HashMap, SortedMap
• Lists
• ArrayList, LinkedList
• Sets
• HashSet, SortedSet
Java Collections – The Basics
• HashMap and ArrayList are most commonly
encountered
• Usual object creation syntax
• Generally hold references to the interface and
not the specific collection
• Can then process them generically

List myList = new ArrayList();


List otherList = new ArrayList(5);
Map database = new HashMap();
Set things = new HashSet();
Java Collections – Adding
Items
• For Collections, use add()
List myList = new ArrayList();
myList.add(“A String”);
myList.add(“Other String”);
• For Maps, use put()
Map myMap = new HashMap();
myMap.put(“google”, “http://www.google.com”);
mpMap.put(“yahoo”, “http://www.yahoo.com”);
Java Collections – Copying
• Very easy, just use addAll()

List myList = new ArrayList();


//assume we add items to the list

List otherList = new ArrayList();


myList.addAll(myList);
Collections – Getting
Individual Items
• Use get()
• Note that we have to cast the object to its
original type.
• Collections…
String s = (String)myList.get(1); //get first element
String s2 = (String)myList.get(10); //get tenth element

• Maps…
String s = (String)myMap.get(“google”);
String s2 = (String)mpMap.get(“yahoo”);
Collections – Getting all items
• For Lists, we could use a for loop, and loop through the list
to get() each item
• But this doesn’t work for Maps.
• To allow generic handling of collections, Java defines an object
called an Iterator
• An object whose function is to walk through a Collection of
objects and provide access to each object in sequence
Collections – Getting all items
• Get an iterator using the iterator() method
• Iterator objects have three methods:
• next() – gets the next item in the collection
• hasNext() – tests whether it has reached the end
• remove() – removes the item just returned
• Basic iterators only go forwards
• Lists objects have a ListIterator that can go forward
and backward
Collections – Getting all items
• Simple example:
List myList = new ArrayList();
//we add items

Iterator iterator = myList.iterator();


while (iterator.hasNext())
{
String s = (String)iterator.next();
//do something with it
}
Collections – Other Functions
• The java.util.Collections class has many
useful methods for working with collections
• min, max, sort, reverse, search, shuffle
• Virtually all require your objects to implement an extra
interface, called Comparable
Collections – Comparable
• The Comparable interface labels objects that can be
compared to one another.
• Allows sorting algorithms to be written to work on any kind
of object
• so long as they support this interface
• Single method to implement
public int compareTo(Object o);
• Returns
• A negative number of parameter is less than the object
• Zero if they’re equal
• A positive number if the parameter is greater than the object
Collections – Comparator
• Like Comparable, but is a stand-alone object used
for comparing other objects
• Useful when you want to use your criteria, not that of
the implementor of the object.
• Or altering the behaviour of a system
• Many of the methods in the Collections object all
a Comparator to be specified
• Again has single method:
public int compare(Object obj1, Object obj2)
Collections – Comparator
Example
• Java String comparison is lexicographic not
alphabetic, I.e. based on the character set, not
alphabetic order
public class AlphaComparison implements Comparator
{
public int compare(Object obj1, Object obj2)
{
String s1 = ((String)o1).toLowerCase();
String s2 = ((String)o2).toLowerCase();
return s1.compareTo(s2);
}
}

You might also like