Grouping objects

1. Grouping objects Collections and iterators

2. Main concepts to be covered • Collections • Loops • Iterators • Arrays Lecture 4: Grouping Objects

3. The requirement to group objects • Many applications involve collections of objects: • Personal organizers. • Library catalogs. • Student-record system. • The number of items to be stored varies. • Items added. • Items deleted. Lecture 4: Grouping Objects

4. A personal notebook • Notes may be stored. • Individual notes can be viewed. • There is no limit to the number of notes. • It will tell you how many notes are stored. Lecture 4: Grouping Objects

5. A personal notebook Lecture 4: Grouping Objects

6. Class Libraries • Learning to program is to learn how to reuse code written by other. There is no point in reinventing the wheel. • Java comes with a library of useful classes, which are referred to as the Java API • They are organized in packages that follow a directory structure Lecture 4: Grouping Objects

7. Class Libraries Lecture 4: Grouping Objects

8. Class libraries • You can access the classes from your code, using the import statement • import java.util.Vector; • import java.util.*; • Grouping objects is a recurring requirement. • The java.util package contains classes for doing this. • We will use ArrayList as a first example Lecture 4: Grouping Objects

9. Class Libraries Lecture 4: Grouping Objects

10. import java.util.ArrayList; /** * ... */ public class Notebook { // Storage for an arbitrary number of notes. private ArrayList notes; /** * Perform any initialization required for the * notebook. */ public Notebook() { notes = new ArrayList(); } ... } Lecture 4: Grouping Objects

11. Object structures with collections Lecture 4: Grouping Objects

12. Adding a third note Lecture 4: Grouping Objects

13. Features of the collection • It increases its capacity as necessary. • It keeps a private count (size() accessor). • It keeps the objects in order. • Details of how all this is done are hidden. • Does that matter? Does not knowing how prevent us from using it? Lecture 4: Grouping Objects

14. Using the collection public class Notebook { private ArrayList notes; ... public void storeNote(String note) { notes.add(note); } public int numberOfNotes() { return notes.size(); } ... } Adding a new note Returning the number of notes (delegation). Lecture 4: Grouping Objects

15. Index numbering Lecture 4: Grouping Objects

16. Retrieving an object Index validity checks public void showNote(int noteNumber) { if(noteNumber < 0) { // This is not a valid note number. } else if(noteNumber < numberOfNotes()) { System.out.println(notes.get(noteNumber)); } else { // This is not a valid note number. } } Retrieve and print the note Lecture 4: Grouping Objects

17. Removing an item public void removeNote(int noteNumber) { if(noteNumber < 0) { // This is not a valid note number, so do nothing. } else if(noteNumber < numberOfNotes()) { // This is a valid note number. notes.remove(noteNumber); } else { // This is not a valid note number, so do nothing. } } Lecture 4: Grouping Objects

18. Removal may affect numbering Lecture 4: Grouping Objects

19. Review • Collections allow an arbitrary number of objects to be stored. • Class libraries usually contain tried-and-tested collection classes. • Java’s class libraries are called packages. • We have used the ArrayList class from the java.util package. Lecture 4: Grouping Objects

20. Review • Items may be added and removed. • Each item has an index. • Index values may change if items are removed (or further items added). • The main ArrayList methods are add, get, remove and size. Lecture 4: Grouping Objects

21. Iteration • We often want to perform some actions an arbitrary number of times. • E.g., print all the notes in the notebook. How many are there? • Most programming languages include loop statements to make this possible. • Java has three sorts of loop statements. • We will focus on its while loopto begin with. Lecture 4: Grouping Objects

22. While loop pseudo code General form of a while loop while keyword Boolean test while(loop condition) { loop body } Statements to be repeated Pseudo-code example to print every note while(there is at least one more note to be printed) { show the next note } Lecture 4: Grouping Objects

23. A Java example /** * List all notes in the notebook. */ public void listNotes() { int index = 0; while(index < notes.size()) { System.out.println(notes.get(index)); index++; } } Increment by one Lecture 4: Grouping Objects

24. Increments • i++ : the value of i is used first before it is being incremented with one • a = 5; b = a++; • a == 6; b == 5; • ++i: increments i with one, the new value of i is then used. • a = 5; b = ++a; • a == 6; b == 6; Lecture 4: Grouping Objects

25. Iterating over a collection Returns an Iterator object java.util.Iterator Iterator it = myCollection.iterator(); while(it.hasNext()) { call it.next() to get the next object do something with that object } public void listNotes() { Iterator it = notes.iterator(); while(it.hasNext()) { System.out.println(it.next()); } } Lecture 4: Grouping Objects

26. Iterators • An iterator is an object that provides functionality to iterate over all elements of a collection or container class • java.util.Iterator • two main methods: hasNext() to check if the Iterator has more elements and next() to take the next object from the Iterator. • You can access an iterator for all java collections. • Not all collections can be accessed using indexes. Lecture 4: Grouping Objects

27. The auction project • The auction project provides further illustration of collections and iteration. • Two further points to follow up: • The null value. • Casting. Used to store the result of get into a variable: • String message = (String) notes.get(0); Lecture 4: Grouping Objects

28. The auction project Lecture 4: Grouping Objects

29. The Lot Class public void bidFor(Person bidder, long value) { if((highestBid == null) || (highestBid.getValue() < value)) { // This bid is the best so far. setHighestBid(new Bid(bidder, value)); } else { System.out.println("Lot number: " + getNumber() + " (" + getDescription() + ")" + " already has a bid of: " + highestBid.getValue()); } } Lecture 4: Grouping Objects

30. The null Keyword • highestBid == null; • The Java keyword null is used to mean ‘no object’ when a variable is not currently holding a reference to a particular object. • setHighestBid(new Bid(bidder, value)); • two things are done here: • we create a new object Bid • we pass this new object immediately to the method Lecture 4: Grouping Objects

31. The Auction Class public void showLots() { Iterator it = lots.iterator(); while(it.hasNext()) { Lot lot = (Lot) it.next(); System.out.println(lot.getNumber() + ": " + lot.getDescription()); // Include any details of a highest bid. Bid highestBid = lot.getHighestBid(); if(highestBid != null) { System.out.println(" Bid: " + highestBid.getValue()); } else { System.out.println(" (No bid)"); } } } Lecture 4: Grouping Objects

32. Type Casting • Lot lot = (Lot) it.next(); • the return value of the Iterator method next() is an object of type Object. To store this in an object of type Lot we need to explicitly convert it that type. This is called Casting • This can only been done if the objects we have added to the container were originally of type Lot. Lecture 4: Grouping Objects

33. Type Casting • Collections in Java allow for the storage of any type of objects. In order to do so it transforms everything you add into an object of type Object. • When retrieving objects from a collection we normally cast them back into their original types. Lecture 4: Grouping Objects

34. Wrapper Classes • Container classes in Java can only contain objects. • Primitive types can therefore not be added. • To solve this, Java provides wrapper classes: Integer, Float, Double • Integer a = new Integer(10); • int b = a.intValue(); Lecture 4: Grouping Objects

35. Fixed-size collections • Sometimes the maximum collection size can be pre-determined. • Programming languages usually offer a special fixed-size collection type: an array. • Java arrays can store objects or primitive-type values. • Arrays use a special syntax. Lecture 4: Grouping Objects

36. The weblog-analyzer project • Web server records details of each access. • Supports webmaster’s tasks. • Most popular pages. • Busiest periods. • How much data is being delivered. • Broken references. • Analyze accesses by hour. Lecture 4: Grouping Objects

37. The weblog-analyzer project Lecture 4: Grouping Objects

38. Creating an array object public class LogAnalyzer { private int[] hourCounts; private LogfileReader reader; public LogAnalyzer() { hourCounts = new int[24]; reader = new LogfileReader(); } ... } Array variable declaration Array object creation Lecture 4: Grouping Objects

39. The hourCounts array Lecture 4: Grouping Objects

40. Using an array • Square-bracket notation is used to access an array element: hourCounts[...] • The number of elements of an array can be obtained via: hourCounts.length • Elements are used like ordinary variables. • On the left of an assignment: • hourCounts[hour] = ...; • In an expression: • adjusted = hourCounts[hour] – 3; • hourCounts[hour]++; • Arrays are passed by reference while their elements are passed by value. Lecture 4: Grouping Objects

41. The for loop • Similar to a while loop. • Often used to iterate a fixed number of times. • Often used to iterate over an array. Lecture 4: Grouping Objects

42. For loop pseudo-code General form of a for loop for(initialization; condition; post-body action) { statements to be repeated } Equivalent in while-loop form initialization; while(condition) { statements to be repeated post-body action } Lecture 4: Grouping Objects

43. A Java example for loop version for(int hour = 0; hour < hourCounts.length; hour++) { System.out.println(hour + ": " + hourCounts[hour]); } while loop version int hour = 0; while(hour < hourCounts.length) { System.out.println(hour + ": " + hourCounts[hour]); hour++; } Lecture 4: Grouping Objects

44. Review • Arrays are appropriate where a fixed-size collection is required. • Arrays use special syntax. • For loops offer an alternative to while loops when the number of repetitions is known. • For loops are often used to iterate over arrays. Lecture 4: Grouping Objects

45. Java API packages import ArrayList Iterator type cast for while array a++ ++a null Concepts Lecture 4: Grouping Objects