First Data Structure Definition
A data structure is a data type whose
components are smaller data structures
and/or simple data types.
Data Structure Starting Point
Any data type that can store more than
one value is a data structure.
First Array Definition
An array is a data structure with one, or more,
elements of the same type.
A 1-dimensional array is frequently called a vector.
A 2-dimensional array is frequently called a matrix.
The array is the first historical data structure
which was introduced in the language FORTRAN.
Record Definition
A record is a data structure with one,
or more, elements, called fields, of the
same or different data types.
The language FORTRAN did NOT
have records which is why it
was NOT good for business.
COBOL (Common Business
Oriented Language) introduced
the record data structure.
A Note About Classes
A class is a record
that can also store methods.
File Definition
A file is an internal data structure - with an
unspecified number of elements of the same
type - assigned to an external file name.
The file data structure
allows transfer of data
between internal and
external storage.
Stack Definition
A stack is a data structure
with elements of the same
type.
Data elements of the stack
data structure can only be
accessed (stored or
retrieved) at one end of the
stack in a LIFO (Last In,
First Out) manner.
Improved Data Structure Definition
A data structure is a data type whose
components are smaller data structures
and/or simple data types.
The storing and retrieval of the data
elements is performed by accessing
methods that characterize the data
structure.
First Array Definition Again
An array is a data structure with one,
or more, elements of the same type.
Improved Array Definition
An array is a data structure with a fixed
number of elements of the same type.
Every element of the array can be
accessed directly.
Array Example
[16]
Ingrid
[17]
Darlene
[18]
Gene
[19]
Sean
[20]
Stephanie
[11]
Holly
[12]
Blake
[13]
Michelle
[14]
Remy
[15]
Haley
[06]
Diana
[07]
Jessica
[08]
David
[09]
Anthony
[10]
Alec
[01]
Isolde
[02]
John
[03]
Greg
[04]
Maria
[05]
Heidi
// Java1101.java
100
101 102 103 104 105 106 107 108
// This program declares 10 different int variables.
// Each variable is assigned a value and each variable value is displayed.
// This approach is very inefficient for a large number of variables.
public class Java1101
{
public static void main(String[] args)
{
int number0 = 100; int number1 = 101;
int number2 = 102; int number3 = 103;
int number4 = 104; int number5 = 105;
int number6 = 106; int number7 = 107;
int number8 = 108; int number9 = 109;
System.out.print(number0 + " ");
System.out.print(number1 + " ");
System.out.print(number2 + " ");
System.out.print(number3 + " ");
System.out.print(number4 + " ");
System.out.print(number5 + " ");
System.out.print(number6 + " ");
System.out.print(number7 + " ");
System.out.print(number8 + " ");
System.out.print(number9 + " ");
System.out.println();
}
}
109
100 101 102 103 104 105 106 107 108 109
// Java1102.java
// This program declares an array of 10 <int> elements.
// Each array element value is individually assigned and displayed.
// There does not appear any real benefit from the from program example.
public class Java1102
{
public static void main(String[] args)
{
int list[];
// declares the array object identifier
list = new int[10];
// allocates memory for 10 array elements
list[0] = 100;
list[2] = 102;
list[4] = 104;
list[6] = 106;
list[8] = 108;
list[1] = 101;
list[3] = 103;
list[5] = 105;
list[7] = 107;
list[9] = 109;
System.out.print(list[0] + " ");
System.out.print(list[1] + " ");
System.out.print(list[2] + " ");
System.out.print(list[3] + " ");
System.out.print(list[4] + " ");
System.out.print(list[5] + " ");
System.out.print(list[6] + " ");
System.out.print(list[7] + " ");
System.out.print(list[8] + " ");
System.out.print(list[9] + " ");
System.out.println();
}
}
Index
Value
0
100
1
101
2
102
3
103
4
104
5
105
6
106
7
107
8
108
9
109
Array Index Note
Java arrays indicate individual elements with
an index inside two brackets, following the
array identifier, like list[3]
The array index is always an integer and
starts at 0.
In an array of N elements, the largest index is
N-1.
//
Java1103.java
100
101 102 103 104 105 106 107 108 109
// The previous program with separate statements for each array member
// assignment and display is now replaced with two loops. The loop counter,
// index, is used to specify each array element in an efficient manner.
public class Java1103
{
public static void main(String[] args)
{
int list[];
list = new int[10];
for (int index = 0; index <=9; index++)
list[index] = index + 100;
for (int index = 0; index <=9; index++)
System.out.print(list[index] + " ");
System.out.println();
}
}
Index
Value
0
100
1
101
2
102
3
103
4
104
5
105
6
106
7
107
8
108
9
109
Defining Static Arrays
int list[];
list = new int[10];
// declares the array list identifier
// allocates memory for 10 integers
char names[];
names = new char[25];
// declares the names array identifier
// allocates memory for 25 characters
double grades[];
// declares the grades array identifier
grades = new double[50]; // allocates memory for 50 doubles
Defining Static Arrays
Preferred Method
int list[ ] = new int[10];
char names[ ] = new char[25];
double grades[ ] = new double[50];
This is similar to what you
learned in Chapters 3 & 6.
Chapter This will work:
This is preferred:
3
int x;
x = 5;
int x = 5;
6
Bank tom;
tom = new Bank();
Bank tom = new Bank();
11
int list[ ];
list = new int [10];
int list[] = new int[10];
//
Java1104.java
100
101 102 103 104 105 106 107 108 109
// This program is the same list array and the same list values
// as the previous program. This time note that the array declaration
// is accomplished with a single statement.
public class Java1104
{
public static void main(String[] args)
{
int list[] = new int[10];
for (int index = 0; index <=9; index++)
list[index] = index + 100;
for (int index = 0; index <=9; index++)
System.out.print(list[index] + " ");
}
}
Index
Value
0
100
1
101
2
102
3
103
4
104
5
105
6
106
7
107
8
108
9
109
// Java1105.java
// This program demonstrates how to initialize array elements.
// The <new> operator is not necessary in this case.
This
called an initializer list.
public
classisJava1105
Note that the size of the array
{
public
args)
doesstatic
not void
needmain(String[]
to be specified.
{
int list[] = {100,101,102,103,104,105,106,107};
for (int k = 0; k <= 7; k++)
System.out.println("list[" + k + "] = " + list[k]);
System.out.println();
}
}
list[0] = 100
// Java1105.java
list[1]
= 101
// This program demonstrates how to initialize
array elements.
list[2]
= 102
// The <new> operator is not necessary in this
case.
list[3]
list[4]
list[5]
list[6]
list[7]
public class Java1105
{
public static void main(String[] args)
{
int list[] = {100,101,102,103,104,105,106,107};
=
=
=
=
=
103
104
105
106
107
for (int k = 0; k <= 7; k++)
System.out.println("list[" + k + "] = " + list[k]);
System.out.println();
}
}
0
1
2
3
4
5
6
7
100 101 102 103 104 105 106 107
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
//0 Java1106.java
// This
program
a string
A
B C
D E demonstrates
F G H I aJcharacter
K L Marray
N Oand
PQ
R Sarray.
T U VWX Y Z
// Both arrays use an initializer list.
ABCDEFGHIJKLMNOPQRSTUVWXYZ
public class Java1106
John Greg Maria Heidi Diana David
{
public static void main(String[] args)
{
char list1[] = {'A','B','C','D','E','F','G','H','I','J','K','L','M',
'N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
for (int k = 0; k < 26; k++)
System.out.print(list1[k]);
System.out.println("\n");
}
}
String list2[] = {"John","Greg","Maria","Heidi","Diana","David"};
for (int k = 0; k < 6; k++)
System.out.println(list2[k]);
System.out.println();
0
1
2
3
4
5
list2
John
Greg
Maria Heidi
Diana David
// Java1106.java
// This program demonstrates a character array and a string array.
// Both arrays use an initializer list.
Try This!
Add one or more names to this list.
Will
they
show up in the output? Why?
public class
Java1106
{
public static void main(String[] args)
{
char list1[] = {'A','B','C','D','E','F','G','H','I','J','K','L','M',
'N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
for (int k = 0; k < 26; k++)
System.out.print(list1[k]);
System.out.println("\n");
String list2[] = {"John","Greg","Maria","Heidi","Diana","David"};
for (int k = 0; k < 6; k++)
System.out.println(list2[k]);
System.out.println();
}
}
// Java1106.java
// This program demonstrates a character array and a string array.
// Both arrays use an initializer list.
Now Try This!
Remove several names from this list.
Does
the
program still work? Why?
public class
Java1106
{
public static void main(String[] args)
{
char list1[] = {'A','B','C','D','E','F','G','H','I','J','K','L','M',
'N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
for (int k = 0; k < 26; k++)
System.out.print(list1[k]);
System.out.println("\n");
String list2[] = {"John","Greg","Maria","Heidi","Diana","David"};
for (int k = 0; k < 6; k++)
System.out.println(list2[k]);
System.out.println();
}
}
// Java1107.java
There are 4 array elements.
// This program introduces
the length field
determine the
names[0]
= toJoe
// number of elements in the array. Remove the comments from line 17
names[1]
= field
Tomis altered.
// to observe what happens
when the length
names[2] = Sue
names[3] = Meg
public class Java1107
{
public static void main(String[] args)
{
String names[ ] = {"Joe","Tom","Sue","Meg"};
int n = names.length; // data field access; not a method call
System.out.println("There are " + n + " array elements.");
for(int k = 0; k < n ; k++)
System.out.println("names[" + k + "] = " + names[k]);
names.length = 10;
//
}
}
0
1
2
3
Joe
Tom
Sue
Meg
// Java1107.java
// This program introduces the length field to determine the
// number of elements in the array. Remove the comments from line 16
Add
onewhat
or happens
morewhen
names
to field
thisis altered.
list.
// to observe
the length
Try This!
Will they show up in the output? Why?
public class Java1107
Why
is this different from program Java1106?
{
public static void main(String[] args)
{
String names[ ] = {"Joe","Tom","Sue","Meg"};
int n = names.length; // data field access; not a method call
System.out.println("There are " + n + " array elements.");
for(int k = 0; k < n; k++)
System.out.println("names[" + k + "] = " + names[k]);
names.length = 10;
//
}
}
// Java1107.java
// This program introduces the length field to determine the
// number of elements in the array. Remove the comments from line 16
Remove
several
from
list.
// to observe what
happens names
when the length
fieldthis
is altered.
Now Try This!
Does the program still work? Why?
public class Java1107
Why
is this different from program Java1106?
{
public static void main(String[] args)
{
String names[ ] = {"Joe","Tom","Sue","Meg"};
int n = names.length; // data field access; not a method call
System.out.println("There are " + n + " array elements.");
for(int k = 0; k < n; k++)
System.out.println("names[" + k + "] = " + names[k]);
names.length = 10;
//
}
}
// Java1107.java
// This program introduces the length field to determine the
// number of elements in the array. Remove the comments from line 16
Remove
thehappens
comment
// to observe what
when the symbol
length field isfrom
altered.the last
Try This Also!
program statement in this program.
public class Java1107
Will
the program still compile?
{
public static void main(String[] args)
{
String names[ ] = {"Joe","Tom","Sue","Meg"};
int n = names.length; // data field access; not a method call
System.out.println("There are " + n + " array elements.");
for(int k = 0; k < n; k++)
System.out.println("names[" + k + "] = " + names[k]);
names.length = 10;
//
}
}
// Java1107.java
// This program introduces the length field to determine the
// number of elements in the array. Remove the comments from line 16
// to observe what happens when the length field is altered.
NO!
public class Java1107
{
public static void main(String[] args)
The
length field is a
{
String
] = {"Joe","Tom","Sue","Meg"};
final
or names[
constant
attribute
just int
like
the PI in Math.PI
n = names.length;
// data field access; not a method call
System.out.println("There are " + n + " array elements.");
for(int k = 0; k < n; k++)
System.out.println("names[" + k + "] = " + names[k]);
names.length = 10;
}
}
Static Arrays vs.
Dynamic Arrays
The size or length of a static array cannot
be changed.
This is why it is called a static array.
The size of a dynamic array can be changed.
You will learn about dynamic arrays in the
next chapter.
list[0] = 244
// Java1108.java
list[1] = 594
// This program fills an <int> array with a random set
of numbers.
list[2]
= 902
list[3] = 385
list[4] = 949
list[5] = 792
list[6] = 636
list[7] = 894
list[8] = 126
list[9] = 103
list[10] = 938
list[11] = 592
list[12] = 584
list[13] = 112
list[14] = 766
list[15] = 791
list[16] = 447
list[17] = 298
list[18] = 596
list[19] = 243
public class Java1108
{
public static void main(String[] args)
{
int list[] = new int[20];
for (int k = 0; k < 20; k++)
{
double temp = Math.random() * 900;
int rand = (int) temp + 100;
list[k] = rand;
}
for (int k = 0; k < 20; k++)
System.out.println("list[" + k + "] = " + list[k]);
}1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
0
}
17
18
19
244 594 902 385 949 792 636 894 126 103 938 592 584 112 766 791 447 298 596 243
// Java1109.java
// This program will display 15 random sentences.
// With 7 different ranks, 7 different people, 7 different actions and 7 different locations,
// there are more than 2400 different sentences possible.
Random random = new Random();
String rank[] = {"Private","Corporal","Sargent","Lieutenant","Captain","Major","General"};
String person[] = {"Smith", "Gonzales", "Brown", "Jackson", "Powers", "Jones", "Nguyen"};
String action[] = {"drive the tank", "drive the jeep", "take the troops", "bring all supplies",
"escort the visitor", "prepare to relocate", "bring the Admiral"};
String location[] = {"over the next hill", "to the top of the mountain", "outside the barracks",
"30 miles into the dessert", "to the middle of the forest",
"to my present location", "to anywhere but here"};
for (int j = 1; j <= 15; j++)
{
int randomRank
=
int randomPerson =
int randomAction =
int randomLocation =
random.nextInt(rank.length);
random.nextInt(person.length);
random.nextInt(action.length);
random.nextInt(location.length);
String sentence = rank[randomRank] + " " + person[randomPerson] + " " +
action[randomAction] + " " + location[randomLocation] + ".";
System.out.println("\n" + sentence);
}
Sargent Brown, bring all supplies outside the barracks.
Major Brown, drive the tank to anywhere but here.
General Smith, prepare to relocate to the middle of the forest.
Corporal Jones, bring the Admiral over the next hill.
General Jackson, take the troops outside the barracks.
Captain Brown, escort the visitor to my present location.
Corporal Powers, drive the tank to my present location.
Private Smith, drive the jeep to my present location.
Captain Jackson, escort the visitor to anywhere but here.
Corporal Smith, bring the Admiral over the next hill.
Corporal Smith, drive the jeep to anywhere but here.
Corporal Gonzales, prepare to relocate outside the barracks.
Major Gonzales, escort the visitor to the top of the mountain.
Major Smith, escort the visitor to the top of the mountain.
Lieutenant Gonzales, escort the visitor over the next hill.
// Java1110.java
11 22 33 44 55 66 77 88 99
// This program introduces the Java Version 5.0 enhanced <for..each> loop
// with an <int> array.
11 22 33 44 55 66 77 88 99
public class Java1110
{
public static void main(String[] args)
{
int list[] = {11,22,33,44,55,66,77,88,99};
}
}
for (int k = 0; k < 9; k++)
System.out.print(list[k] + " ");
System.out.println("\n\n");
// Old <for> loop syntax
for (int item: list)
System.out.print(item + " ");
System.out.println("\n\n");
// New <for> loop syntax
Tom Sue Joe Jan Bob Lee Ann Meg
// Java1111.java
// This program uses the Java Version 5.0 <for..each> loop with a <String> array.
Tom Sue Joe Jan Bob Lee Ann Meg
public class Java1111
{
public static void main(String[] args)
{
String names[] = {"Tom","Sue","Joe","Jan","Bob","Lee","Ann","Meg"};
}
}
for (int k = 0; k < 8; k++)
System.out.print(names[k] + " ");
System.out.println("\n\n");
// Old <for> loop syntax
for (String name: names)
System.out.print(name + " ");
System.out.println("\n\n");
// New <for> loop syntax
// Java1112.java
// This program demonstrates a very generalized <for..each> loop usage
// with the <Object> class.
public class Java1112
{
public static void main(String[] args)
{
System.out.println("Java1112\n");
String names[] = {"Tom","Sue","Joe","Jan","Bob","Lee","Ann","Meg"};
for (int k = 0; k < 8; k++)
System.out.print(names[k] + " ");
System.out.println("\n\n");
for (Object obj: names)
System.out.print(obj + " ");
System.out.println("\n\n");
}
}
Enhancing the for Loop
The enhanced for loop is called the for .. each loop.
The new loop structure does not replace the older for
loop, because it is not possible to access specific array
elements.
int numbers[ ] = {1,2,3,4,5,6,7,8,9};
for (int number: numbers)
System.out.print(number + "
");
// Java1112.java
// This program shows that actual parameters are not
// altered by a call to the <swap> method.
public class Java1112
{
public static void main(String[] args)
{
int p = 10;
int q = 20;
System.out.println(p + " " + q);
swap(p,q);
System.out.println(p + " " + q);
}
}
public static void swap (int x, int y)
{
System.out.println(x + " " + y);
int temp = x;
x = y;
y = temp;
System.out.println(x + " " + y);
}
10
10
20
10
20
20
10
20
// Java1113.java
// In this program it appears that a call to the <swap>
// can alter values in the calling method.
444
public class Java1113
555
{
public static void main(String[] args)
{
int[ ] list = {111,222,333,444,555,666,777,888,9999};
System.out.println(list[3] + " " + list[4]);
swap(list,3,4);
System.out.println(list[3] + " " + list[4]);
}
public static void swap(int[ ] x, int p, int q)
{
int temp = x[p];
x[p] = x[q];
x[q] = temp;
}
}
555
444
// Card01.java
// This <Card> class is the version,
// which was introduced in Chapter IX.
// ///////////////////////////////////////////////////////////////////////////////////////////////
// This program is designed to explain the "Elevens" lab created
// by Michael Clancy, Robert Glen Martin and Judith Hromcik.
// Divided into stages and altered August 2014 by Leon Schram.
public class Card01
{
private String suit;
private String rank;
private int value;
public Card01(String s, String r, int v)
{
suit = s;
rank = r;
value = v;
}
public String getSuit()
public String getRank()
public int getValue()
{ return suit;
}
{ return rank; }
{ return value; }
public void setSuit(String s)
{ suit = s;
public void setRank(String r) { rank = r;
public void setValue(int v)
{ value = v;
}
}
}
}
// Card02.java
// The <Card02> class re-defines the <toString> method,
// which is used to display the <Card02> attributes.
// ///////////////////////////////////////////////////////////////////////////////////////////////
// This program is designed to explain the "Elevens" lab created
// by Michael Clancy, Robert Glen Martin and Judith Hromcik.
// Divided into stages and altered August 2014 by Leon Schram.
public class Card02
{
private String suit;
private String rank;
private int value;
public String toString()
{
return "[" + suit + ", " + rank + ", " + value + "]";
}
}
public Card01(String s, String r, int v)
{
suit = s;
rank = r;
value = v;
}
public String getSuit()
public String getRank()
public int getValue()
{ return suit; }
{ return rank; }
{ return value; }
public void setSuit(String s)
{ suit = s;
public void setRank(String r) { rank = r;
public void setValue(int v)
{ value = v;
}
}
}
// CardTester02.java
// This program tests the <Card02> class.
// /////////////////////////////////////////////////////////////////////////////////////////////////
// This program is designed to explain the "Elevens" lab created
// by Michael Clancy, Robert Glen Martin and Judith Hromcik.
// Divided into stages and altered August 2014 by Leon Schram.
public class CardTester02
{
public static void main(String[] args)
{
Card02 card = new Card02("Spades","Ace",11);
System.out.println("Suit: " + card.getSuit());
System.out.println("Rank: " + card.getRank());
System.out.println("Value: " + card.getValue());
System.out.println();
card.setSuit("Hearts");
card.setRank("Seven");
card.setValue(7);
System.out.println(card);
}
}
Suit: Spades
Rank: Ace
Value: 11
[Hearts, Seven, 7]
// Card03.java
// The <Card03> class adds the <matches> method.
// This class now is identical to the <Card> class of the "Elevens" lab.
// ///////////////////////////////////////////////////////////////////////////////////////////////
// This program is designed to explain the "Elevens" lab created
// by Michael Clancy, Robert Glen Martin and Judith Hromcik.
// Divided into stages and altered August 2014 by Leon Schram.
public class Card03
{
private String suit;
private String rank;
private int value;
public Card03(String s, String r, int v)
{
suit = s;
rank = r;
value = v;
}
public String suit() { return suit; }
public String rank() { return rank; }
public int value()
{ return value; }
public boolean matches(Card otherCard)
{
return
otherCard.getSuit().equals(this.suit)
&& otherCard.getRank().equals(this.rank)
&& otherCard.getValue() == this.value;
}
public String toString() { return "[" + suit + ", " + rank + ", " + value + "]"; }
// CardTester03.java
[Spades, Ace, 11]
// This program tests the <Card03> class.
[Clubs, Seven, 7]
// //////////////////////////////////////////////////////////
[Spades, Ace, 11]
// This program is designed to explain the "Elevens" lab created
// by Michael Clancy, Robert Glen Martin and Judith Hromcik.
// Divided into stages and altered August 2014 byfalse
Leon Schram.
true
false
public class CardTester03
{
public static void main(String[] args)
{
Card03 card1 = new Card03("Spades","Ace",11);
Card03 card2 = new Card03("Seven","Clubs",7);
Card03 card3 = new Card03("Spades","Ace",11);
System.out.println(card1);
System.out.println(card2);
System.out.println(card3);
System.out.println();
System.out.println(card1.matches(card2));
System.out.println(card1.matches(card3));
System.out.println(card2.matches(card3));
}
}
// Deck01.java
// The first stage of the <Deck> is very basic.
// It shows how the <Card> class is used to create a
// <cards> array as a data structure attribute of the <Deck> class.
// ////////////////////////////////////////////////////////////////////////////////////////////////
// This program is designed to explain the "Elevens" lab created
// by Michael Clancy, Robert Glen Martin and Judith Hromcik.
// Divided into stages and altered August 2014 by Leon Schram.
public class Deck01
{
private Card[] cards;
private int size;
public Deck01()
{
cards = new Card[52];
size = 0;
}
public int size()
{ return size;
}
public boolean isEmpty() { return size == 0; }
}
// DeckTester01.java
// This program tests the <Deck01> class.
// ///////////////////////////////////////////////////////////////////////////////////////////////
// This program is designed to explain the "Elevens" lab created
// by Michael Clancy, Robert Glen Martin and Judith Hromcik.
// Divided into stages and altered August 2014 by Leon Schram.
Deck01@1db9742
0
true
public class DeckTester01
{
public static void main(String[] args)
{
Deck01 deck = new Deck01();
System.out.println(deck);
System.out.println(deck.size());
System.out.println(deck.isEmpty());
}
}
// Deck02.java
// Methods <add> and <display> are added to the <Deck02> class.
// Objects of the <Card> class can now be stored in the <cards> array.
// ///////////////////////////////////////////////////////////////////////////////////////////////
// This program is designed to explain the "Elevens" lab created
// by Michael Clancy, Robert Glen Martin and Judith Hromcik.
// Divided into stages and altered August 2014 by Leon Schram.
public class Deck02
{
// only new methods shown
public void add(String suit, String rank, int value)
{
Card temp = new Card(suit,rank,value);
cards[size] = temp;
size++;
}
public void display()
{
for (int k = 0; k < size; k++)
System.out.println(cards[k]);
System.out.println();
}
}
// DeckTester02.java
[Clubs, Three, 3]
// This program tests the <Deck02> class. [Diamonds, Four, 4]
// //////////////////////////////////////////////////////////
[Hearts, Five, 5]
// This program is designed to explain the "Elevens" lab created
Six, 6]
// by Michael Clancy, Robert Glen Martin [Spades,
and Judith Hromcik.
// Divided into stages and altered August 2014 by Leon Schram.
public class DeckTester02
{
public static void main(String[] args)
{
Deck02 deck = new Deck02();
4
false
deck.add("Clubs","Three",3);
deck.add("Diamonds","Four",4);
deck.add("Hearts","Five",5);
deck.add("Spades","Six",6);
deck.display();
System.out.println(deck.size());
System.out.println(deck.isEmpty());
}
}
// Deck02.java
// Methods <add> and <display> are added to the <Deck02> class.
// Objects of the <Card> class can now be stored in the <cards> array.
// //////////////////////////////////////////////////////////
// This program is designed to explain the "Elevens" lab created
Change
display
method
that
it uses the for..each
// by Michael the
Clancy,
Robert Glen
Martin andso
Judith
Hromcik.
//
Divided Recompile
into stages and altered
2014 by Decktester02.java.
Leon Schram.
loop.
andAugust
execute
Try This!
public class Deck02
{
// only new methods shown
public void add(String suit, String rank, int value)
{
Card temp = new Card(suit,rank,value);
cards[size] = temp;
size++;
}
public void display()
{
for (Card card: cards)
System.out.println(card);
System.out.println();
}
}
Important Note:
You just saw an example where a fundamental
question was raised.
Does the new for..each loop provide
the same output as the traditional index for loop?
Both loops do display the array elements, but the
indexed loop can be easily controlled to only include
those elements that reference a deeper value.
It is precisely in the asking of the what..if questions,
followed by some experimenting that students learn
the most about programming.
// Deck03.java
// The <display> method is now replaced by the <toString> method.
// ////////////////////////////////////////////////////////////////////////////////////////////////
// This program is designed to explain the "Elevens" lab created
// by Michael Clancy, Robert Glen Martin and Judith Hromcik.
// Divided into stages and altered August 2014 by Leon Schram.
public class Deck03
{
// only new methods shown
public String toString()
{
String temp = "";
for (int k = 0; k < size; k++)
temp = temp + cards[k].toString() + "\n";
return temp;
}
}
// DeckTester03.java
[Clubs, Three, 3]
// This program tests the <Deck03> class.
[Diamonds, Four, 4]
// //////////////////////////////////////////////////////////
[Hearts, Five, 5]
// This program is designed to explain the "Elevens" lab created
[Spades, Six, 6]
// by Michael Clancy, Robert Glen Martin and Judith Hromcik.
// Divided into stages and altered August 2014 by Leon Schram.
public class DeckTester03
{
public static void main(String[] args)
{
Deck03 deck = new Deck03();
deck.add("Clubs","Three",3);
deck.add("Diamonds","Four",4);
deck.add("Hearts","Five",5);
deck.add("Spades","Six",6);
4
false
System.out.println(deck);
System.out.println(deck.size());
System.out.println(deck.isEmpty());
}
}