4 gouping object

Grouping objects
Indefinite iteration - the while loop

2
Konsep Penting
• Collections
• Loops
• Iterators
• Arrays

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.

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 how many notes are
stored.
• Explore the notebook1 project.

5
Class libraries
• Collections of useful classes.
• Java calls its libraries, packages.
• Grouping objects is a recurring
requirement.
– The java.util package contains
classes for doing this.

6
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();
}
...
}

7
Object structures with
collections

8
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?
Objects First with Java - A Practical Introduction using BlueJ, © David J. Barnes, Michael Kölling

9
Using the collection
public class MusicOrganizer
{
private ArrayList<String> files;
...
public void addFile(String filename)
{
files.add(filename);
}
public int getNumberOfFiles()
{
return files.size();
}
...
}
Adding a new file
Returning the number of files
(delegation)

10
Index numbering

11
Retrieving an object
Could be invalid !
public void listFile(int index)
{
String filename = files.get(index);
System.out.println(filename);
}
Print the file name Retrieve the file name

12
Retrieving an object
Index validity checks
public void listFile(int index)
{
if(index >= 0 &&
index < files.size()) {
}
else {
// This is not a valid index.
}
}
Retrieve and print the file name
Needed? (Error message?)

13
Removal may affect
numbering

14
The general utility of indices
• Using integers to index collections
has a general utility:
– ‘next’ is: index + 1
– ‘previous’ is: index – 1
– ‘last’ is: list.size() – 1
– ‘the first three’ is: the items at indices
0, 1, 2
• We could also think about accessing
items in sequence: 0, 1, 2, …

15
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.

16
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.
• ArrayList is a parameterized or
generic type.

17
Interlude:
Some popular errors...

18
/**
* Print out info (number of entries).
*/
public void showStatus()
{
if(files.size() == 0); {
System.out.println("Organizer is empty");
}
else {
System.out.print("Organizer holds ");
System.out.println(files.size() + " files");
}
}
What’s wrong here?

19
/**
*/
{
if(files.size() == 0);
{
}
else {
System.out.println(files.size() + "files");
}
}
This is the same as before!

20
/**
*/
{
if(files.size() == 0)
;
{
}
else {
}
}
This is the same again

21
/**
*/
{
if(files.size() == 0) {
;
}
{
}
else {
}
}
and the same again…

22
/**
*/
{
if(isEmpty = true) {
}
else {
}
}
This time I have a boolean field
called ‘isEmpty’... What’s wrong here?

23
/**
*/
{
if(isEmpty == true) {
}
else {
}
}
This time I have a boolean field
called ‘isEmpty’... The correct version

24
/**
* Store a new file in the organizer. If the
* organizer is full, save it and start a new one.
*/
{
if(files.size() == 100)
files.save();
// starting new list
files = new ArrayList<String>();
}
What’s wrong here?

25
/**
*/
{
if(files.size == 100)
files.save();
}
This is the same.

26
/**
*/
{
if(files.size == 100) {
files.save();
}
}
The correct version

Grouping objects
Collections and the for-each loop

28
Main concepts to be covered
• Collections
• Loops: the for-each loop

29
Iteration
• We often want to perform some actions an
arbitrary number of times.
– E.g., print all the file names in the organizer.
How many are there?
• Most programming languages include loop
statements to make this possible.
• Java has several sorts of loop statement.
– We will start with its for-each loop.

30
Iteration fundamentals
• We often want to repeat some
actions over and over.
• Loops provide us with a way to
control how many times we repeat
those actions.
• With collections, we often want to
repeat things once for every object
in a particular collection.

31
For-each loop pseudo code
for(ElementType element : collection) {
loop body
}
For each element in collection, do the things in the loop body.
loop header
for keyword
Statement(s) to be repeated
Pseudo-code expression of the actions
of a for-each loop
General form of the for-each loop

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

33
Review
• Loop statements allow a block of
statements to be repeated.
• The for-each loop allows iteration over a
whole collection.

35
Main concepts to be covered
• The difference between bounded
and unbounded iteration.
• The while loop

36
Search tasks are indefinite
• We cannot predict, in advance, how
many places we will have to look.
• Although, there may well be an
absolute limit – i.e., checking every
possible location.
• ‘Infinite loops’ are also possible.
– Through error or the nature of the task.

37
The while loop
• A for-each loop repeats the loop body
for each object in a collection.
• Sometimes we require more variation
than this.
• We use a boolean condition to decide
whether or not to keep going.
• A while loop provides this control.

38
While loop pseudo code
while(loop condition) {
loop body
}
while we wish to continue, do the things in the loop body
boolean test
while keyword
Statements to be repeated
Pseudo-code expression of the actions of
a while loop
General form of a while loop

39
Looking for your keys
while(the keys are missing) {
look in the next place;
}
Or:
while(not (the keys have been found)) {
look in the next place;
}

40
Looking for your keys
boolean searching = true;
while(searching) {
if(they are in the next place) {
searching = false;
}
}
Suppose we don’t find them?

41
A Java example
/**
* List all file names in the organizer.
*/
public void listAllFiles()
{
for(String filename : files) {
}
}
for each filename in files, print out filename

42
A Java example
/**
* List all file names in the organizer.
*/
{
int index = 0;
while(index < files.size()) {
index++;
}
}
Increment index by 1
while the value of index is less than the size of the collection,
get and print the next file name, and then increment index

43
for-each versus while
• for-each:
– easier to write.
– safer: it is guaranteed to stop.
• while:
– we don’t have to process the whole
collection.
– doesn’t even have to be used with a
collection.
– take care: could be an infinite loop.

44
Finishing a search
• How do we finish a search?
• Either there are no more items
to check:
index >= files.size()
• Or the item has been found:
found == true
found
! searching

45
Continuing a search
• With a while loop we need to state
the condition for continuing:
• So the loop’s condition will be the
opposite of that for finishing:
index < files.size() && ! found
index < files.size() && searching
• NB: ‘or’ becomes ‘and’ when
inverting everything.

46
Searching a collection
int index = 0;
boolean found = false;
while(index < files.size() && !found) {
String file = files.get(index);
if(file.contains(searchString)) {
// We don't need to keep looking.
found = true;
}
else {
index++;
}
}
// Either we found it at index,
// or we searched the whole collection.

47
The String class
• The String class is defined in the
java.lang package.
• It has some special features that
need a little care.
• In particular, comparison of String
objects can be tricky.

48
Side note: String equality
if(input == "bye") {
...
}
if(input.equals("bye")) {
...
}
Always use .equals for text equality.
tests identity
tests equality

49
Identity vs equality 1
Other (non-String) objects:
person1 == person2 ?
“Fred”
:Person
person1 person2
“Jill”
:Person

50
“Fred”
:Person
person1 person2
“Fred”
:Person

51
“Fred”
:Person
person1 person2
“Fred”
:Person

52
Identity vs equality (Strings)
"bye"
:String
input
"bye"
:String
String input = reader.getInput();
if(input == "bye") {
...
}
== ?
 (may be) false!
== tests identity

53
Identity vs equality (Strings)
"bye"
:String
input
"bye"
:String
String input = reader.getInput();
if(input.equals("bye")) {
...
}
equals ?
 true!
equals tests
equality

54Objects First with Java - A Practical Introduction using BlueJ, © David J. Barnes, Michael Kölling

Iterator and iterator()
• Collections have an iterator()
method.
• This returns an Iterator object.
• Iterator<E> has three methods:
– boolean hasNext()
– E next()
– void remove()

57
Using an Iterator object
Iterator<ElementType> it = myCollection.iterator();
call it.next() to get the next object
do something with that object
}
java.util.Iterator
returns an Iterator object
{
Iterator<Track> it = files.iterator();
Track tk = it.next();
System.out.println(tk.getDetails());
}
}

58
Iterator mechanics

:Element
myList:List
:Element :Element
:Iterator
myList.iterator()
:Element

:Element :Element :Element
:Iterator
hasNext()? ✔
next()
Element e = iterator.next();
:Element
:Iterator
myList:List

hasNext()? ✔
next()
:Element
:Iterator :Iterator
myList:List

hasNext()? ✗
:Element
:Iterator
myList:List

64
Index versus Iterator
• Ways to iterate over a collection:
– for-each loop.
• Use if we want to process every element.
– while loop.
• Use if we might want to stop part way through.
• Use for repetition that doesn't involve a collection.
– Iterator object (new).
• Use if we might want to stop part way through (with while).
• Often used with collections where indexed access is not
very efficient, or impossible.
• Use to remove from a collection.
• Iteration is an important programming pattern.

65
Removing from a collection
Iterator<Track> it = tracks.iterator();
Track t = it.next();
String artist = t.getArtist();
if(artist.equals(artistToRemove)) {
it.remove();
}
}
Use the Iterator’s remove method.

66
Review
• Loop statements allow a block of
statements to be repeated.
• The for-each loop allows iteration over a
whole collection.
• The while loop allows the repetition to be
controlled by a boolean expression.
• All collection classes provide special
Iterator objects that provide sequential
access to a whole collection.

68
What is an Array?

69
The size of an array is fixed

70
Arrays in Java

71
Declaring Arrays

72
Constructing Arrays

73
The length variable for 1D Arrays

74
The length variable for 2D Arrays

75
Example

76
Array Initializer

77
Enhanced for Statement

79
Enhanced forStatement

80
Fixed-size collections
• Sometimes the maximum collection
size can be pre-determined.
• A special fixed-size collection type is
available: an array.
• Unlike the flexible List collections,
arrays can store object references or
primitive-type values.
• Arrays use a special syntax.

81
Creating an array object
public class LogAnalyzer
{
private int[] hourCounts;
private LogfileReader reader;
public LogAnalyzer()
{
hourCounts = new int[24];
reader = new LogfileReader();
}
...
}
Array object creation
— specifies size
Array variable declaration
— does not contain size

82
The hourCounts array

83
Using an array
• Square-bracket notation is used to access
an array element: hourCounts[...]
• Elements are used like ordinary variables.
• The target of an assignment:
hourCounts[hour] = ...;
• In an expression:
hourCounts[hour]++;
adjusted = hourCounts[hour] – 3;

84
Standard array use
private int[] hourCounts;
private String[] names;
...
hourCounts = new int[24];
...
hourcounts[i] = 0;
hourcounts[i]++;
System.out.println(hourcounts[i]);
declaration
creation
use

85
Array literals
• Array literals in this form can only be
used in declarations.
• Related uses require new:
private int[] numbers = { 3, 15, 4, 5 };
declaration,
creation and
initialization
numbers = new int[] {
3, 15, 4, 5
};
• The size is inferred from the data.

86
Array length
• NB: length is a field rather than a
method!
• It cannot be changed – ‘fixed size’.
private int[] numbers = { 3, 15, 4, 5 };
int n = numbers.length;
no brackets!

87
Review
• Arrays are appropriate where a fixed-
size collection is required.
• Arrays use a special syntax.
• For loops are used when an index
variable is required.
• For loops offer an alternative to
while loops when the number of
repetitions is known.
• Used with a regular step size
(Increment by the same number each
time).

4 gouping object

More Related Content

What's hot (20)

Similar to 4 gouping object (20)

More from Robbie AkaChopa (20)

Recently uploaded (20)

4 gouping object