0% found this document useful (0 votes)
61 views22 pages

Introduction To Java 2 Programming: Array and Collections

This document provides an overview of arrays and collections in Java. It discusses declaring and initializing arrays, looping through arrays, bounds checking, copying arrays, and sorting arrays. It also covers the basics of collections including lists, sets, maps, adding and retrieving items, iterators, and the Comparable and Comparator interfaces for comparing objects.
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
61 views22 pages

Introduction To Java 2 Programming: Array and Collections

This document provides an overview of arrays and collections in Java. It discusses declaring and initializing arrays, looping through arrays, bounds checking, copying arrays, and sorting arrays. It also covers the basics of collections including lists, sets, maps, adding and retrieving items, iterators, and the Comparable and Comparator interfaces for comparing objects.
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 22

Introduction to Java 2 Programming

Lecture 5 Array and Collections

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


Dont 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 well 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 Cant 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 doesnt 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 theyre 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