The Java Learning Kit Chapter 5 – Methods and Modular.docx

The Java Learning Kit: Chapter 5 – Methods and Modularity
Copyright 2015 by C. Herbert, all rights reserved.
Last edited January, 2015 by C. Herbert
This document is a chapter from a draft of the Java Learning
Kit, written by Charles Herbert, with editorial input from Craig
Nelson, Christopher Quinones, Matthew Staley, and Daphne
Herbert. It is available free of charge for students in Computer
Science courses at Community College of Philadelphia during
the Spring 2015 semester.
This material is protected by United States and international
copyright law and may not be reproduced, distributed,
transmitted, displayed, published or broadcast without the prior
written permission of the copyright holder. You may not alter
or remove any trademark, copyright or other notice from copies
of the material.
The Java Learning Kit:
Chapter 5
Methods and Modularity

Lesson 5.1 – User Created Methods in Java
Lesson 5.2 – Method Parameters
Lab 5A – Examining code with Several Methods
Lesson 5.3 – Top-Down Design and Modular Development
Lab 5B – Methods and Parameter Passing
JLK Chapter 5 – Methods and Modularity DRAFT January 2015
Edition pg. 2
Contents
Chapter 5 Learning Outcomes
...............................................................................................
..................... 3
User Created Methods in Java
......................................................................................... 4
Method Modifiers
...............................................................................................
................................ 4
Return Type
...............................................................................................
......................................... 6
Other method modifiers
...............................................................................................
...................... 7

Method Parameters
...............................................................................................
............................. 7
Invoking a Method and Parameter Passing
......................................................................................... 7
Method Documentation
...............................................................................................
...................... 9
CheckPoint 5.1
...............................................................................................
................................... 10
................................................................................... 11
Top-Down Design and Modular Development
.............................................................. 13
CheckPoint 5.2
...............................................................................................
................................... 15
............................................................................................
16
Key Terms
...............................................................................................
.............................................. 21
Chapter Questions
...............................................................................................
................................. 21

Chapter Exercises
...............................................................................................
................................... 22
Edition pg. 3
The Java Learning Kit: Chapter 2
Reading, Writing, and Arithmetic
This chapter introduces user-created methods in Java, along
with the accompanying
techniques of modular development and top-down design, also
known as structured
decomposition or functional decomposition.
Parameter passing between methods and polymorphic method
overloading are also
discussed.
Upon completion of this chapter students should be able to:

Oracle’s Java
Tutorials.
the difference
between a formal parameter list and an actual parameter list.
-down design of an algorithm, also
known as
structured decomposition or functional decomposition.
and several
advantages of
developing software in smaller modules.
demonstrating good
modular design and the proper use of parameter passing
between methods.
Edition pg. 4
User Created Methods in Java
So far we have only created software with a single method, the

main method in the single class in each
Java application we created. We have invoked other methods
from other classes, such as the Math class
and the Scanner class, but we have only created one method at a
time in our applications. Now we will
begin to work with multiple methods of our own.
The code for each method in Java software is defined in a
method declaration within a class. A method
declaration defines a method, with a method header, followed
by a block of code marked by braces.
According to Oracle’s Java tutorials, a method declaration has
six components – the five parts of the
method header and the method’s block of code1. A Java method
header includes method modifiers
(such as public and static), the return type of the method, the
method name, a set of parentheses which
contains the method’s parameters, and an exception list. The
parentheses are blank if there are no
parameters. In general the parts of a method header look like
this:
[modifiers] [return type] method name(formal parameter list)
[exception list]
Here is an example. This method has no exception list after the
parameter list. If you do see the word

throws after a parameter list, then that is the beginning of the
exception list, which is also known as a
thrown exception clause. We will learn about exceptions later in
the course.
public double overTime(double hours, double rate) {
double overtimeHours;
double overtimePay;
overtimeHours = hours - 40;
overtimePay = overtimeHours *rate * 1.5;
return overtimePay;
} // end (overtime(( double hours, double rate)
Method Modifiers
Method modifiers provide the compiler with information about
the nature of the method. The most
common method modifier is called the access modifier, which

sets the access level for the method. Java
methods may have public, private, or protected access.
any other software.
within the class which contains the
method.
1 See:
http://docs.oracle.com/javase/tutorial/java/javaOO/methods.htm
l
method header
parameter list return type access modifier method name
Figure 1 – parts of a
method header
Edition pg. 5
subclasses of a class may invoke protected

methods. We learn about subclasses later in the semester when
we learn about inheritance.
Why Java Applications Need a Public Static Void Main()
Method
Every java application must start somewhere.
A Java application can contain many methods in many different
classes and can also import
methods from classes that are not part of the application’s own
source code, but that are defined
elsewhere.
At least one class in a Java application must have the same
name as the application’s software
package. This class must contain a method named main, which
will be the method that is executed
when the software application runs. The main method will
contain any calls or references to other
methods used within the application.
A Java application’s main method must be public, which means
it is available to be run from outside
of its own software package. This is necessary so that the
operating system can start the application
by running the main method. This means that the access
modifier public must be included in a main

method’s header.
An application’s main method is a class-level method,
associated with the overall application’s and
not with an instance of a class, therefore its header must have
the access modifier static, which
identifies class-level methods, variables, and so on.
The main method for a java application does not return any
values. Hence it must be marked with
the access modifier void in the method’s header, which
indicates it does not return any user defined
values. Actually, when a java application terminates it will
send a code to the operating system to
indicate whether or not the application terminated normally.
However, this message passing
happens automatically, and we do not need to be concerned
about it, at least not for now.)
Putting all of this together, the modifiers public, static and void
must come before the method name
in the method header for a main method. For example, a
payroll application whose application
software package is named Payroll, must have a payroll class
with the following method:
public static void main( String[] args) {

. . . method block of code follows . . .
} // end main()
The parameter for the main method is a String array of
arguments, which is why main methods
have the default parameter String[] args. (The terms parameter
and argument mean almost the
same thing, and are often used interchangeably.) Often this
parameter goes unused, but it is there
to enable operating system and the method to communicate with
one another.
Edition pg. 6
Another common method modifier is the static modifier.
According to the JLS, a method that is declared
static is called a class method. A static method is associated
with the class and not with an instance of
the class. It is invoked by using the class name, and not the
instance name, as part of its qualified name.
The main methods in the software we have written so far have

been declared public static void main(…).
We have also seen static methods in the Math class. Methods
such as Math.sqrt() and Math.random()
are class level methods that have been invoked using the name
of the class – the Math class.
The Scanner class methods we have used were not class level
methods. They were invoked using the
name of an instance of the class. We had to declare a new
instance of the Scanner class associated with
a particular input stream before we could use methods such as
nextLIne() in the example below. If the
static modifier is missing, then the method is an instance
method. If the static modifier is present, it is a
class method.
public static void main(String args[]) {
String name;
Scanner kb = new Scanner(System.in);
// say hello to the user and ask for the user’s name
System.out.println("Hello, please enter your name: ");
name = kb.nextLine();

. . . // the method continues . . .
Return Type
The return type in a method header declares the data type of the
value the method returns, or uses the
keyword void to indicate that the method does not return a
value. A method that does not return a
value is often called a void method. A void method is invoked
from another method by using the void
method’s name as if it is a new Java instruction.
A method that returns a value can called from anyplace in
another Java method where a variable or
literal of the same data type can be used. For example, the
Math.sqrt() method returns a value of data
type double. Therefore, it can be called from any place that a
variable type double or a double literal can
be used, such as in a math expression.
Methods that return a value, such as the
Math.sqrt() method, are often called inline
methods, because they can be invoked in a
Java statement “inline”, as shown on the left.
double result;

double num1;
result = 3 * num1 + 4;
result = 3 * Math.sqrt(10) + 4;
The nextLine() method that is invoked from the main() method
in Figure 2, above, has a return type of
String, so it can be used in a Java statement anyplace that a
String value can be used. In this example,
the value returned by the method is assigned to the String
variable name.
Figure 2 – part of
a main() method
The static modifier identifies the main()
method as a class-level method.
The nextLine() method is a instance method,
invoked using the name of the instance of
the Scanner class to which it applies, kb.
Edition pg. 7

Other method modifiers
There are several other modifiers, such as abstract, native,
strictfp, and synchronized, that can be used
in Java methods headers in addition to modifiers and return
types discussed here. They are beyond what
we need to use for now, but are listed and described online at:
http://docs.oracle.com/javase/tutorial/reflect/member/methodMo
difiers.html
Method Parameters
The list of variable declarations in parentheses following the
name of the method is the formal
parameter list. Formal parameters are local variables that will
hold the values passed to the method
when the method is invoked. They are declared in the method
header by listing the data types and
names of the variables. They may be used in the method just as
any other local variables may be used.
The scope of the variables declared in a formal parameter list is
the body of the method in whose
header the list appears.
In the overtime example shown again in Figure 3, the double
variables hours and rate are formal
parameters, which are used as local variables within the method.

Values will be passed to initialize
these variables when the method is invoked from another
method. The parameters that are passed to a
method are also called the arguments of a method.
/****************************************************
*************************/
/* The overtime method calculates the total overtime pay
following the time
* and a half for overtime rule. The result is to be added to the
regular pay
* for 40 hours.
*
* method parameters:
* double hours -- hours worked this week – usually close to
40.0
* double rate -- employee's pay rate a decimal values usually
less than 100
*
* The method returns the total overtime pay for hours above 40
as a double.
*/
public double overTime( double hours, double rate) {

double overtimeHours; // hours worked beyond 40
double overtimePay; // pay for overtime hours
// calculate overtime hours and pay
overtimeHours = hours - 40;
overtimePay = overtimeHours *rate * 1.5;
return overtimePay;
} // end overtime (double hours, double rate)
/****************************************************
*************************/
Invoking a Method and Parameter Passing
There are two ways a method may be invoked from another
method:
a Java statement;
user-created instruction in the
Java language.
The following examples show how to invoke methods.
Figure 3 – a user-

defined method
http://docs.oracle.com/javase/tutorial/reflect/member/methodMo
difiers.html
Edition pg. 8
Example 1 - is a declaration for a method that returns a value.
We can see from the method header that
its return type is int. It also takes two integer parameters, a and
b.
// this method returns the lesser of two integer values
public int lesser( int a, int b) {
if ( b < a)
return b;
else
return a;
} // end lesser()
The method may be used anyplace in a Java expression where an
integer value can be used, such as in
the following statement in another method:

sum = grade 1 + grade2 + lesser(grade3, grade4);
In Java, parameters can be passed by value. Parameter passing
by value means that the values
specified in the actual parameter list are passed to the variables
declared in the formal parameter list.
When a method is invoked, the data types of the actual
parameters must match those of the formal
parameters and the actual parameters must be in the same order
as the formal parameters.
In this case, the values of the variables grade3 and grade4 are
the actual parameters for this invocation
of the method. They are passed to the variables a and b in the
method lesser(). The values of the
variables grade3 and grade4 are used to initialize the variables a
and b in the method lesser().
91
93
grade3
grade4
91
93

a
b
memory space for main() memory space for lesser()
94
87
grade1
grade2
If grade3 = 91 and grade4 = 93, then 91 is passed to a and 93 is
passed to b. There is no connection
between the variables in the two methods – the values from one
are simply passed to the other.
Example 2 - a value returning method named square
// this method returns the square of a double value
public double square( double x) {
return x * x;
} // end square()
The square() method is invoked in each of the following
statements:
dist = Math.sqrt( square(dx) + square(dy) );

area = square(s);
area = square(2.5);
actual parameters
type
Figure 4 – a method that
returns an int value
Figure 5 – parameter
passing by value
Figure 6 – a method that
returns a double value
Edition pg. 9
The square() method is called four times, twice in the first
statement, once in the second statement.,
and once in the third statement. Notice that the third statement
uses the value 2.5 as an actual

parameter – no variable is used. This is perfectly acceptable
when passing by value, as Java does.
In the first statement, the value of dx is passed to square() and
the return value is used in place of the
method call square(dx), then the value of dy is passed to
square() and the return value is used in place of
the method call square(dy).
In the second statement, the value of s is passed to the square()
method and the formal parameter x is
initialized to the value of s. Area will be equal to s2.
In the third statement, the value 2.5 is passed to square and the
formal parameter x is initialized to 2.5.
Area will be equal to 2.52, which is 6.25.
*****************************************************
********************************
Example 3 - a void method
public void printCheck(String name, double netPay) {
System.out.println("Pay to the order of " + name);
System.out.printf("%8.2f”, netPay )
} // end printCheck()
A void method is used as if it is a new instruction in the Java
language:

printCheck(name, netPay);
printCheck(“Mary Jones”, 371.28);
printCheck( (fname + “ “ + lname), net);
In each case, the program will invoke printCheck(), passing the
values to the method. The method uses
the data to print the checks, but no value is returned to the
calling method.
The parameter passing works the same with void methods as
with value returning methods: the values
in the actual parameter list are used to initialize the variables in
the formal parameter list. In the first
statement above, the values of the variables name and netPay in
the calling method are used to
initialize empName and netPay in the printCheck() method.
Even though the two variables netPay have
the same name, they are still different variables not connected
to one another in any way. The value of
one is simply used to initialize the other.
In the second printCheck() statements above, literal values are
specified. These values will be used to
initialize name and netPay when printCheck() is invoked.
Method Documentation

The version of the overtime method shown in Figure 3 is
reasonably well-documented. Documentation
is an important part of programming. Method documentation is
an important part of object-oriented
programming.
Information in a comment describing each method should
include the method’s:
nctions
Figure 7 – a void method
– used “inline” as if it is
a new Java instruction
Edition pg. 10
A method’s entry conditions include information about the
variables in the formal parameter list – such
as the range of values for each parameter – along with any other
special conditions that must be set

before the method runs. In the case of the overTime method in
Figure 3, the expected values of the
variables hours and rate are listed, but no special conditions are
mentioned.
The method documentation should briefly describe what the
method does and how the method
functions. It should tell the reader if any new or unusual
techniques are used in the method. If there
are several different way to do something, then the
documentation should be clear about which way is
used in this method. The documentation for the overTime()
method in Figure 3 makes it clear that the
“time and a half for overtime” rule was applied, and that the
method returns the total pay for all
overtime hours, not just the added half.
A method’s exit conditions should describe what value, if any, a
method returns and anything else the
method does that has an effect outside of the method. Does it
open a new I/O stream? Does it turn a
hardware device on or off? If it does anything with an effect
that will be present after the method runs,
then the exit conditions should say so. In the case of the
overtime method in Figure 3, the only exit

condition is that it returns a value. The data type and meaning
of the value returned should be clearly
described.
You should also do something with the documentation to clearly
separate one method from another in
a class. Programming styles differ, so there are many ways to
do this. In the case of the overtime
method, a line of stars and then a blank line are immediately
placed at the end of the method. This
makes it easier for a reader to distinguish between methods.
Remember, the documentation will be stripped from the code
when the software is compiled. It’s there
to make it easier for people to read and understand the code,
including you as the author of the code
who may need to come back to a method months or years later
and will need to understand how it
works. All documentation should be clear and reasonably
concise, but ease of understanding is the
most important factor. It is worth the time to make sure that
readers can understand your code.
CheckPoint 5.1
1. What are the six parts of a method declaration in Java,
according to Oracle’s Java Tutorials?

2. What do the method modifiers public, private, and static each
mean in a method declaration?
3. What is a void method and how is it invoked form another
method?
4. How is a value returning method invoked from another
method?
5. What is a formal parameter list and how does it correspond to
an actual parameter list?
Edition pg. 11
The following source code is in the NetBeans project
PayMethods, included in the file payMethods.zip in
the files for Week 5 in Canvas. It demonstrates the use of a
value returning method and a void method.
Your task is to download the file, unzip the NetBeans project,
then open it in NetBeans and examine the
code. You should be able to see how the a value returning
method and a voids method are invoked from
main, and how parameters are passed from the main method to
calculateGross() and to payrollReport().

Notice that calculateGross() and payrollReport() are both static
methods. This is because main() is a
static method, and static methods cannot call instance methods.
You should run the program to see how it works, then perhaps
try changing some of the actual
parameters to specific values to see how that works.
Notice the modularity of the program – we could change the
print report formats, for example, without
messing with the main() method. We could also modify the way
overtime is calculated without
changing any other methods.
package paymethods;
import java.util.Scanner;
/* CSCI 111 Fall 2013
* Sample program - payroll methods
* This program has an example of a value returning method and
a void method
*/
public class PayMethods {

public static void main(String[] args) {
String fname; // employee's first name
String lname; // employee's last name
double hours; // hours worked in the week
double rate; // hourly pay rate
double gross; // gross pay (hours * rate) + overtime
// set up input stream from the keyboard
Scanner keyboard = new Scanner(System.in);
// get employee's first name
System.out.print("Please enter the employee's first name: " );
fname = keyboard.next();
// get employee's last name
System.out.print("Please enter the employee's last name: " );
lname = keyboard.next();
// get employee's hours
System.out.print("Please enter the hours for " + fname +" " +

lname+ ": ");
hours = keyboard.nextDouble();
// get employee's rate
System.out.print("Please enter the pay rate for " + fname +" "
+ lname+ ": ");
rate = keyboard.nextDouble();
Figure 8 – a payroll
program composed
of several methods
Edition pg. 12
// call method to calculate gross
// This value returning method is used inline, gross is set to
the value it returns
gross = calculateGross(hours, rate);
// call method to print payroll report
// this void method is used as if it is a new instruction in Java

// the actual parameters must correspond with the method's
formal parameter list
payrollReport(fname, lname, hours, rate, gross );
} // end main()
/****************************************************
*************************/
/* This method calculates gross pay using the time and a half
for overtime rule.
* it has two parameters,
* the hours worked during the week double hrs
* the pay rate double rt
*
* it returns the gross pay
*/
public static double calculateGross(double hrs, double rt ) {
double gr; // gross pay
double ot; // overtime pay

gr = hrs * rt;
if (hrs > 40)
ot = (hrs-40) * .5 * rt; // overtime bonus
else
ot = 0;
gr = gr + ot;
return gr;
} // end calculateGross
/****************************************************
*************************/
/* this method prints a payroll report
* it takes four parameters,
* employeee's first name String fname
* employee's last name String lname
* the hours worked during the week double hrs
* the pay rate double rate
*/

public static void payrollReport(String fname, String lname,
double hrs, double rt, double gross ) {
// print the payroll report
System.out.printf("%n%-12s%-12s%8s%8s%9s%n", "first",
"last",
"Hours", "Rate", "Gross");
System.out.printf("%-12s%-12s%8.2f%8.2f%,9.2f%n", fname,
lname,
hrs,rt, gross);
} // end payrollReport()
} // end class
Edition pg. 13
Top-Down Design and Modular Development
It’s hard to solve big problems.
It’s easier to solve small problems than it is to solve big ones.

Computer programmers use a divide and conquer approach to
problem solving:
This process is a combination of techniques known as top-down
design and modular development.
Top-down design is the process of designing a solution to a
problem by systematically breaking a
problem into smaller, more manageable parts.
First, start with a clear statement of the problem or concept – a
single big idea. Next, break it down into
several parts. If any of those parts can be further broken down,
then the process continues until you
have a collection of parts that each do one thing.
The final design might look something like this organizational
chart, showing the overall structure of
separate units that form a single complex entity.

Edition pg. 14
An organizational chart is like an upside down tree, with nodes
representing each process. The leaf
nodes are those at the end of each branch of the tree. The leaf
nodes represent modules that need to
be developed and then recombined to create the overall solution
to the original problem.
Top-down design leads to modular development.Modular
development is the process of developing
software modules individually, then combining the modules to
form a solution to an overall problem.
Figure 9 – an organizational chart showing
units that form a single complex entity
Figure 10 the leaf nodes of
an organizational chart
Edition pg. 15
Modular development facilitates production of computer

software because it:
… makes a large project more manageable.
Smaller and less complex tasks are easier to understand than
larger ones and are less
demanding of resources.
… is faster for large projects.
Different people can work on different modules, and then put
their work together. This means
that different modules can be developed at the same time, which
speeds up the overall project.
… leads to a higher quality product.
Programmers with knowledge and skills in a specific area, such
as graphics, accounting, or data
communications, can be assigned to the parts of the project that
require those skills.
…makes it easier to find and correct errors.
Often, the hardest part of correcting an error in computer
software is finding out exactly what is
causing the error. Modular development makes it easier to
isolate the part of the software that
is causing trouble.
… increases the reusability of solutions.

Solution
s to smaller problems are more likely to be useful elsewhere
than solutions to bigger
problems. They are more likely to be reusable code. Reusable
code is code that can be written
once, then called upon again in similar situations. It makes
programming easier because you
only need to develop the solution to a problem once; then you
can call up that code whenever
you need it. Modules developed as part of one project, can be
reused later as parts of other
projects, modified if necessary to fit new situations. Over time,
libraries of software modules for
different tasks can be created. Libraries of objects can be
created using object-oriented

programming languages.
Most computer systems are filled with layers of short
programming modules that are constantly reused
in different situations. Our challenge as programmers is to
decide what the modules should be. Each
module should carry out one clearly defined process. It should
be easy to understand what the module
does. Each module should form a single complete process that
makes sense all by itself.
Top-down development is used to figure out what the modules
are needed in a software development
project and how they should be organized. Modular
development involves building those modules as
separate methods, then combining them to form a complete
software solution for the project.
CheckPoint 5.2

1. What are Java’s nine built-in data types and how do they fit
into four major categories?
2. Which Java built-in data type is not a primitive data type?
3. How do each of Java’s integer data types differ from one
another?
4. What is a literal and how are literals represented for different
built-in data types?
5. Describe the formats used to store floating point data in
memory.
Edition pg. 16
In this example we will develop a modular solution for a

problem that is similar to the homework
assignment from chapter 3.
We wish to input the x and y coordinates for two points in the
Cartesian plane, and find the distance
between the two, then print a report telling the user the distance
between the two points and the
quadrant that each point is in.
The distance between two points whose coordinates are (x1,y1)
and (x2, y2) is √��2 + ��2 where Δx
is the difference between the two x coordinates (x1- x2)and Δy
is the difference between the y
coordinates (y1- y2).
The example on the right also shows us
that the quadrants of a Cartesian plane
are numbered I through IV, with the
following properties:

-negative,
the point is in Quadrant I.
f x is negative and y is non-negative,
the point is in Quadrant II
the point is in Quadrant III.
-negative and y is negative,
the point is in Quadrant IV.
Y axis
X axis
(4,4)
Δy = 8
(0,0)
Quadrant IQuadrant II
Quadrant III Quadrant IV

(-2,-4) Δx = 6
Once we understand the specifications, we can make an outline
of what our software should do:
1. get the coordinates of two points: (x1, y1) and (x2, y2)
2. calculate the distance between the two points:
-x2; deltaY = y1-y2;
3. determine which quadrant (x1, y1) is in:
drant III
4. determine which quadrant (x2, y2) is in:

5. print results
Figure 11 – two points
in a Cartesian plane
Edition pg. 17
The similarity of steps 3 and 4 indicate that this would be good
place for reusable code – one method

that can be used twice, but each time with different values
passed to the method. Step 2 is also a good
place for a method, with the details of the calculation in the
method.
Step 1 might seem like a good place for a method – we get four
numbers from the user, each in the
same manner. However, remember that methods can only return
one value, so we really don’t gain
much by making this a separate method. It is a judgment call
and a matter of programming style – it
could be done with four calls to one method, but in this case we
will use four different sets of
statements in the main method.
Here in the design of our software, listing descriptions of the
methods with return types and formal
parameters:

Void main() method
Double CalcDistance(double x1, double y1, double x2, double
y2) method
ulate deltaX
String findQuadrant( double x, double y)

X >=0) && (Y<0) Q =“Quadrant IV”
The code in Figure 12 starting on the next page was developed
from these specifications.
Edition pg. 18
/*
* program to calculate the distance between two points
* CSCI 111 Fall 2103
* last edited Sept 24, 2013 by C. Herbert

*/
package twopoints;
public class TwoPoints {
// The main method gets x and y for two points
// Calls methods to calculate the distance between the two
// and to determine the quadrant of each point
// then outputs the result
//declare variables
double x1,y1,x2,y2; // coordinates of (x1,y1) and

(x2,y2)
double dist; // distance between (x1,y1) and
(x2,y2)
String Q1, Q2; // quadrant containing (x1,y1) and
(x2,y2)
// set up instacne of Scanner for input
// get input in prompt & capture pairs
System.out.print("Enter the x coordinate of point 1 :");
x1 = kb.nextDouble();
System.out.print("Enter the y coordinate of point 1 :");
y1 = kb.nextDouble();

System.out.print("Enter the x coordinate of point 2 :");
x2 = kb.nextDouble();
System.out.print("Enter the y coordinate of point 2 :");
y2 = kb.nextDouble();
// call calcDistance()
dist = calcDistance( x1, y1, x2, y2);
// call findQuadrant(point1)
Q1 = findQuadrant(x1, y1);
// call findQuadrant(point2)
Q2 = findQuadrant(x2, y2);

// output results
System.out.println("nPoint 1 is ("+ x1 + "," + y1 + ")");
System.out.println("Point 2 is ("+ x2 + "," + y2 + ")n");
System.out.printf("The distance between the two points
is: %-8.2f%n", dist );
System.out.println("Point 1 is in " + Q1);
System.out.println("Point 2 is in " + Q2);
} // end main()
/****************************************************
************************/
Figure 12 – a program
organized as 3 methods

Edition pg. 19
// this method calculates and returns the distance between
two points
public static double calcDistance(double x1,double
y1,double x2,double y2) {
double deltaX; // difference in x coordinates
double deltaY; // difference in x coordinates
double dist; // distance between (x1,y1) and (x2,y2)
deltaX = (x1-x2);
deltaY = (y1-y2);

dist = Math.hypot(deltaX, deltaY);
return dist;
/* this whole method could be one line:
* return Math.hypot( (x1-x2), (y1-y2) );
*/
} // end calcDistance() {
/****************************************************
************************/
// this method returns the quadrant that contains the point
public static String findQuadrant(double x,double y) {
String Q; //quadrant message

if ( (x >= 0.0) && (y >= 0.0) )
Q = "Quadrant I";
else if ( (x < 0.0 ) && ( y >= 0.0) )
Q = "Quadrant II";
else if ( (x < 0) && (y < 0.0) )
Q ="Quadrant III";
else // ( (x >= 0) && (y < 0.0) )
Q = "Quadrant IV";
return Q;
} // end findQuadrant
} // end class
Here is sample output from the program:

Enter the x coordinate of point 1 :3
Enter the y coordinate of point 1 :4
Enter the x coordinate of point 2 :-3
Enter the y coordinate of point 2 :-4
Point 1 is (3.0,4.0)
Point 2 is (-3.0,-4.0)
The distance between the two points is: 10.00
Point 1 is in Quadrant I
Point 2 is in Quadrant III
The code in Figure 13 on the next page contains an alternative
version of the same program as Figure
12. To the user, the two programs look the same. They have

identical input and output. They are in the
Week 5 Canvas files. These two Java applications are the
topic of the Week 5 class discussion.
Edition pg. 20
/* distance between two points - alternative programming style
* CSCI 111 Spring 2015 last edited Sept 24, 2013 by C.
Herbert
*/
package twopointsb;
public class TwoPointsB {

// The main method calls a methods to calculate the distance
between
// two points, then prints that distance and the quadrant of
each point
double x1,y1,x2,y2;
double dist;
// input coordinates
x1 = inCor("x", "1");
y1 = inCor("y", "1");
x2 = inCor("x", "2");
y2 = inCor("y", "2");

dist = Math.hypot( (x1-x2), (y1-y2) );
System.out.println("nPoint 1 is ("+ x1 + "," + y1 + ")");
System.out.println("Point 2 is ("+ x2 + "," + y2 + ")n");
System.out.printf("The distance between the two points
is: %-8.2f%n", dist );
printQuadrant("1", x1 , y1);
printQuadrant("2", x2 , y2);
} // end main()
/****************************************************
************************/
// this method gets as input a single coordinate of a point
public static double inCor(String axis, String point) {

// set up instance of Scanner for input
// get coordinate with prompt
System.out.print("Enter the " + axis + " coordinate of point
" + point + " :");
return kb.nextDouble();
} // end inCor()
/****************************************************
************************/
// this method prints the quadrant a point is in
public static void printQuadrant(String P, double x,double y)
{

if ( (x >= 0.0) && (y >= 0.00) )
System.out.println( "Point "+ P + " is in Quadrant I");
else if ( (x < 0.0 ) && ( y >= 0) )
System.out.println( "Point "+ P + " is in Quadrant II");
else if ( (x < 0) && (y < 0) )
System.out.println( "Point "+ P + " is in Quadrant III");
else // ( (x >= 0) && (y < 0) )
System.out.println( "Point "+ P + " is in Quadrant IV");
} // end printQuadrant
} // end class
Figure 13 –Figure 12’s
program reorganized.

Edition pg. 21
Key Terms
access modifier, 4
entry conditions, 10
exit conditions, 10
formal parameters, 7
inline methods, 6
leaf nodes, 15
method declaration, 4
method header, 4

method modifiers, 4
modular development, 16
organizational chart, 14
parameter passing by value, 8
private access, 4
protected access, 4
public access, 4
return type, 6
reusable code, 16
static method, 6
throws, 4
top-down design, 14
void, 6

Chapter Questions
1. So far this semester we have only created one method at a
time in our applications, but what are some
examples of methods from other classes that we have invoked in
our source code?
2. What is included in a method declaration?
3. What are the parts of a method header?
4. What is in the parentheses that follow the name of the method
in a method header? What does it
mean if the parentheses are blank?
5. What does it mean if the word throws follows a method
header?
6. Where does the return type belong in a method header?
7. What are the three access modifiers used in Java? What does

the private access modifier do?
8. When do we need a main method in a class? What modifiers
should be used with this method?
9. What does the JLS tell us about a method with the modifier
static? How is a static method invoked?
10. What methods that we have previously used were static
methods? What methods that we have
previously used were associated with an instance of a class?
11. What do we call a method that does not return as value?
What return type does it have?
12. Where can we use a method that returns a double value?
13. What is a method that can be invoked in a Java expression
often called?
14. What is the difference between the formal parameter list and
the actual parameters? Which of the two
declares new variables for a method? Which contains values

used to initialize variables?
Edition pg. 22
15. What should be included in a comment describing each
method? What happens to this documentation
when a method is compiled?
16. What should be described as part of a method’s entry
conditions? What should be described as part of a
method’s exit conditions?
17. In what two ways can a method be invoked from another
method? How is a value returning method
invoked? How is a void method invoked?
18. How are parameters passed in Java? How must the values of
the actual parameters be organized when a

method is invoked?
19. When breaking a method down into parts using top-down
design, which nodes on an organizational
chart need to be developed and then recombined to create the
overall solution to the original problem?
20. What are five of the ways in which modular development
facilitates production of computer software?
Chapter Exercises
1. Match the actual parameters on the left with the correct
formal parameter list on the right.
(3,4)
(2.0,3.0)
(“Jones”, 97.5)
(“J00123453”, “B”)
(42, 10.50)
(double hours, double rate)
(String name, double pay)

(short people, double PoundsOfCake)
(String Jnumber, String grade)
(int length, int width)
2. Multiplication Table
A set of nested for loops can be used to print a multiplication
table using System.out.printf statements.
1 2 3 4 5 6 7 8 9
1 1 2 3 4 5 6 7 8 9
2 2 4 6 8 10 12 14 16 18
3 3 6 9 12 15 18 21 24 27
4 4 8 12 16 20 24 28 32 36
5 5 10 15 20 25 30 35 40 45
6 6 12 18 24 30 36 42 48 54
7 7 14 21 28 35 42 49 56 63

8 8 16 24 32 40 48 56 64 72
9 9 18 27 36 45 54 63 72 81
Write a program to print such a multiplication table, using a
method to print each row, which is invoked
from the method that prints the overall multiplication table.
Edition pg. 23
3. Printing Patterns
Nested for loops can print patterns of stars, such as the example
below:
for(i=1; i<=5; i++)

{
for(j=1; j<=10; j++)
{
System.out.print(“*”);
} // end for j
System.out.println();
} // end for i
Output from this program:
**********
**********
**********
**********
**********
Write a program with a main method which asks the user for the
number of rows and for the number of
columns, then calls a method which uses that information to
print a rectangle of stars.

4. Celsius to Fahrenheit Table
Write a program to print a Celsius to Fahrenheit conversion
table that invokes a method to calculate
Fahrenheit temperature using formula is F = ( 9.0
5.0
C) + 32.0. The main method should have a loop to
print the table, calling the conversion method from within the
loop.
The table should include integer Celsius degrees from 0 to 40.
You program does not need to use
integers, but the table should display the Celsius temperature,
then the Fahrenheit accurate to one-
tenth of a degree. The first few entries from the table are
shown below:
Celsius Fahrenheit
0 32.0
1 33.8

2 35.6
3 37.4
5. We wish to write a modular program that can be used to
calculate monthly payments on a car loan. The
formula is: payment =
�� ∗ ��
1−(1+�� )−��ℎ�
The program will be composed of several methods – a main
method, a monthly interest rate method, a
monthly payment method, and an output method.
The main method should:
1. ask the user for
- the loan amount

- the annual interest rate ( as a decimal, 7.5% is 0.075 )
- the number of months
2. call a method to calculate and return the monthly payment
(Note: The formula uses monthly rate. Annual rate is input.
monthly rate = annual rate/12)
3. call a method to print a loan statement showing the amount
borrowed, the annual interest
rate, the number of months, and the monthly payment
Edition pg. 24
6. International Gymnastics Scoring

We wish to write a program to quickly calculate gymnastics
scores for an international competition. Six
judges are judging the competition, numbered 1 through 6 for
anonymity. The program should have a
loop that:
1. calls a method asking for the score from a single judge, The
method should print the judge
number and score and return the judges score
2. adds the returned score to a total score.
After the loop is done, your program should call a method that
calculates and displays the average
score.
Scores are in the range 0 to 10 with one decimal place, such as
8.5. The average should be displayed
with two decimal places.

Here is a sample of the output:
Score for Judge 1: 8.5
The average score is: 8.77
7. Test for Divisibility
If the remainder from dividing A by B is zero, then A is a
multiple of B ( A is evenly divisible by B ).
For example, the remainder from dividing 6, 9, or 12 by 3 is 0,
which means 6, 9, and 12 are all multiples

of 3.
Write a program with a loop to to print the numbers from 1 to
25, and within the loop, invokes a
method to see if the number is a multiple of 2, a method to see
if the number is a multiple of 3, and a
method to see if the number is a multiple of 5. The methods
should each print a message if the number
is a multiple of the value for which they are testing.
Here is a sample of part of the output:
1
2 multiple of 2
3 multiple of 3
4 multiple of 2
5 multiple of 5

6 multiple of 2 multiple of 3
7
8 multiple of 2
9 multiple of 3
10 multiple of 2 multiple of 5
Edition pg. 25
8. Estimate of a Definite Integral
Write the program to estimate a definite integral with
rectangles, with a loop that calls a method to
calculate the height and area of each rectangle.

A loop in a computer program can be used to approximate the
value of a definite integral. We can
break the integral into rectangles, find the area of each
rectangle then add the areas together to get the
total area, as shown in the accompanying diagram. In practice,
we could make the width small enough
to achieved the desired accuracy in estimating the area under
the curve.
y = 9-x2
area under the curve
estimated by rectangles
As the width of the rectangles gets progressively smaller, their
total area gets closer to the total area
under the curve. This is an old method that predates Calculus.
Both Leibnitz and Newton used this

method, eventually developing calculus from the concept of
infinitesimals, which, in the case of our
rectangles, would amount to asking, what would the total area
be if we had very many rectangles with
very small width?
This was tedious by hand, but we now have computers. We can
set the width of the rectangle. The
height of the rectangle is the y value at point x. So for example,
if we need to solve:
∫ 9 − �2 ��
−3
+3
The starting point is -3, the ending point is +3, and the height of
the rectangle at each value of x in
between the two is 9 − �2 ; Y at each x is the is the height of
the rectangle at that x. We can use a width

of 0.001, and write a loop like this:
for x = -3 to +3 step 0.0001 // x is -3.00, then -2.9, then -2.8,
etc.
{
y = 9 − �2 ; // the height is the y value at each x
area = y * .01; // the width is the increment, in this case 0.1
totalArea = totalArea + area;
}
In this version of the program, the statements in the box above
should be in a separate method, invoked
from within the loop. When the loop is finished, totalArea is
the total area of the rectangles, which is
an approximation of the area under the curve.

Your lab report should explain what you did, and the result of
your work.
Edition pg. 26
9. Supermarket Checkout
Design a program for a terminal in a checkout line at a
supermarket. What are the tasks that are
included as part of checking out at a register? We must consider
things like the cost of each item,
weighing produce and looking up produce codes, the total cost
of the order, bonus card discounts, and
sales tax on taxable items only. You do not need to write the
program, but you should design the
methods using top down development and modular design.
Submit a description of the methods

needed for the program, a brief description of what each method
does, and a description of how the
methods are related to one another in terms of parameter
passing and return types.
10. We wish to write a program to draw the scene below. We
can create methods to draw primitive shapes,
as follows:
circle() takes x and y coordinates of center point, the radius,
and the color
triangle() takes x and y coordinates of each of three endpoints
and the color
rectangle() takes x and y coordinates of each of four corner
points and the color
Create a modular design for software to draw the scene using
the methods above. The software should
be layered. For example, a house() method should use the

primitive graphics methods to draw the
house.
Your design document should list and briefly describe each
method, including and what it does,
parameters, and any methods the method calls. Your list should
start with the main method.
— End of Chapter 5 —
The Java Learning Kit: Chapter 6 – Arrays

Copyright 2015 by C. Herbert, all rights reserved.
Last edited January, 2015 by C. Herbert
This document is a chapter from a draft of the Java Learning
Kit, written by Charles Herbert, with editorial input from Craig
Nelson, Christopher Quinones, Matthew Staley, and Daphne
Herbert. It is available free of charge for students in Computer
Science courses at Community College of Philadelphia during
the Spring 2015 semester.
This material is protected by United States and international
copyright law and may not be reproduced, distributed,
transmitted, displayed, published or broadcast without the prior
written permission of the copyright holder. You may not alter
or remove any trademark, copyright or other notice from copies
of the material.
The Java Learning Kit:
Chapter 6

Arrays
Lesson 6.1 – Arrays
Lesson 6.2 – One Dimensional Arrays in Java
Lesson 6.3 – Operations on Numeric Arrays
Lesson 6.4 – Searching and Sorting Arrays
Lesson 6.5 – Text File Input and Output in Java
Lab 6 – Programming Example: Moving Data between Arrays
and Files
JLK Chapter 6 – Arrays DRAFT 2015 Edition pg. 2
Contents
...............................................................................................
..................... 3
Arrays

...............................................................................................
............................... 4
Array Storage in Computer Memory
...............................................................................................
.... 5
CheckPoint 6.1
...............................................................................................
..................................... 6
One Dimensional Arrays in Java
...................................................................................... 7
What is actually in an array in Java?
...............................................................................................
.... 7
Assigning Values to Array Elements
...............................................................................................
... 10
The Array length Property; Iterating an Array
................................................................................... 11

The Enhanced for Statement
...............................................................................................
............. 12
Copying an Array
...............................................................................................
................................ 13
Arrays as Method Parameters in Java
...............................................................................................
13
Passing an Array Element as a Method Parameter
........................................................................... 15
CheckPoint 6.2
...............................................................................................
................................... 15
Operations on Numeric Arrays
...................................................................................... 16
Sum, Average, and Count of Values in an Array
................................................................................ 16

The Minimum and Maximum Values in an Array
.............................................................................. 17
Searching and Sorting Arrays
........................................................................................ 18
Comparing Strings
...............................................................................................
.............................. 18
Linear Search of an Array
...............................................................................................
................... 18
Sorting an Array
............................................................................................ ...
................................. 21
Swapping the Values of Two Variables
.............................................................................................
22
CheckPoint 6.4
...............................................................................................
................................... 24

Text File Input and Output in Java
................................................................................. 25
Handling Data File Exceptions like Hot Potatoes
............................................................................... 26
A Technique for Writing Text Data Files using Java
........................................................................... 27
A Technique for Reading Text Data Files using Java
.......................................................................... 28
CheckPoint 6.5
...............................................................................................
................................... 29
and Files ............................................. 30
Key Terms
...............................................................................................
.............................................. 35
Chapter Questions

...............................................................................................
................................. 36
Chapter Exercises
............................................................................................ ...
................................... 37
The Java Learning Kit: Chapter 6
Arrays
This chapter introduces the concept of an array and working
with arrays in Java, along with the use
of text files in Java applications for long-term storage of arrays
and other data.
Lesson 1 introduces the concept of an array as a set of
subscripted variables, including a look at

how arrays are stored in memory.
Lesson 2 shows how to implement arrays for Java’s built-in data
types.
Lesson 3 discusses simple statistical processing of numeric
arrays — finding the sum, average
minimum, and maximum in an array of numbers.
Lesson 4 looks at simple techniques for searching and sorting
arrays.
Lesson 5 introduces simple text file I/O in Java.
Upon completion of this chapter students should be able to:
stored in a
computer’s memory.
an array in Java; and how to declare an

array, initialize
an array, and iterate an array in Java.
parameter in Java;
and how to pass an individual array element as a method
parameter in Java.
iterate an array;
and pass both references to arrays and individual array elements
as
parameters.
operations on
numeric arrays, including counting array elements, and finding
the sum,
average, minimum and maximum of values in an array.

sum, average,
minimum and maximum of values in an array.
algorithm for a linear to search of an array.
two variables,
search an array, and sort an array.
Arrays
Until now we have been using single variables in our Java
programs. Java, like most other programming

languages, Java also supports arrays. An array is a set of
indexed variables, all of the same data type.
Instead of just having individual variables such as x, y, or
empName, we can have a set of indexed
variables such as x1, x2, x3, … and so on, where the value of
the index identifies an element of an array.
Each element of an array is an individual data item in the array,
such as:
empName0, empName1, empName2, … empNamen-1
In mathematics, such an array is also referred to as a set of
subscripted variables, because the index is
written as a subscript. In Java, they may also be called
subscripted variables, but instead of using
subscripts, Java uses square brackets following the variable
name to indicate an array or an element in
an array. empName0, empName1, employname2… from

mathematics would be written as empName[0] ,
empName[1], empName [2] … empName [n-1] in Java.
empName is the name of the array; whereas
empName[i], where i is an integer, is an element in the array
empName. The index values in an array
start at zero for reasons we will see later in this chapter.
empName[0] , empName[1], empName[2] … empName[n-1]
Arrays are very useful for storing and working with sets of
similar data items, such as lists of test scores.
We will see how to set up an array to hold a set of numbers,
such as test scores, then write code to find
the sum, the average, the minimum or the maximum of the
numbers. Once data has been established in
the computer’s memory as an array, we can do many things with
the data, including conducting a full
statistical analysis of the data, searching the data for specific

items, or sorting the data. Later, when we
learn to work with objects, we can set up an array of objects,
such an array of student records with
properties like student number, first name, last name, address,
and major, then we can sort or search
through the data according to any of the object’s properties.
But for now, we will only work with arrays
of primitive data types and Strings.
Most high-level programming languages support using arrays of
data. They generally have two different
type of arrays, single-dimensional arrays and mutli-dimensional
arrays. A single dimensional array, also
called a linear array, is an array with only one index variable,
forming what can be thought of as a line of
data items. The above example of empName[0] , empName[1],
empName [2] … empName [n-1] is a one

dimensional linear array.
Multi-dimensional arrays have multiple index variables, such as
the two-dimensional array shown here:
a0,0 a0,1 a0,2 . . . a0,n
a1,0 a1,1 a1,2 . . . a1,n
a2,0 a2,1 a2,2 . . . a2,n
am,0 am,1 am,2 . . . am,n
This is a two dimensional array from the world of mathematics,
forming a table with m rows and n
columns. In Java, the array would look like this:
a[0,0] a[0,1] a[0,2 ]. . . a[0,n]
a[1,0] a[1,1] a[1,2 ]. . . a[1,n]

a[2,0] a[2,1] a[2,2 ]. . . a[2,n]
a[m,0] a[m,1] a[m,2] . . . a[m,n]
Two dimensional arrays can be used to represent tables of data
with rows and columns of information,
similar to an electronic spreadsheet. They are often used for
matrices in linear algebra problems.
Multi-dimensional arrays can have more than two dimensions.
A three dimensional array could, for
example, represent a three-dimensional matrix for solving
problems related to three-dimensional
Euclidean space with x, y, and z coordinates. However, for the
remainder of this chapter we will stick
with simple single dimensional arrays, leaving the more
complex problems for another day.
Array Storage in Computer Memory

The values for variables in a computer program are stored in a
computer’s internal memory while the
program runs. Hence, each variable name is associated with a
specific address in the computer’s
memory. This matching of variables to memory addresses is
usually managed by the computer’s
operating system with a symbol table. A symbol table is a list
of symbolic names, such as the names of
methods, classes, and variables, mapped to specific addresses in
a computer’s internal memory.
Almost all modern computer systems have byte addressable
memory, meaning that bytes in a
computer’s memory are sequentially numbered, regardless of
the word length of a particular processing
unit. There are many advantages to this, which are discussed in
computer architecture and organization
courses such as CSCI 213– Computer Organization at

Community College of Philadelphia.
The following example shows how an operating system keeps
track of the values of variables using a
symbol table. The memory map shows us how space is allocated
in the computer’s memory.
variables symbol table memory map
int score; score 4000 4000 score
double velocity; velocity 4004 4001
int colorDepth; colorDepth 400C 4002
boolean transparent; transparent 4010 4003
4004 velocity
4005
Memory is allocated according to how variables are declared.
4006

Space is allocated based on data types, as described back in
chapter 2, for example:
int 32 bits (4 bytes)
double 64 bits (8 bytes)
boolean (1 byte in this system)
The symbol table records where variables are stored
in the internal memory. Memory addresses are hexadecimal
(base 16).
4007
4008
4009
400A
400B
400C color depth
400D
400E

400F
4010 transparent
When an array is declared, the operating system only keeps
track of array’s base address, which is the
location where the array starts in memory. Here is an example:
CheckPoint 6.1
1. What is the relationship among the terms array, indexed
variables, and subscripted variables?
2. What is a linear array?
3. What does it mean to say that most computers use byte-
addressable memory?

4. If array begins at memory address 5000 and each array
element requires 16 bits of storage
space, where will the array element with index 3 be stored in
memory?
5. How can arrays be used to represent tables of data with rows
and columns, similar to an
electronic spreadsheet?
priority = new int [6]; priority 4000 4000 priority [0]
int score; score 4018 4001
4002
The symbol table only contains the base address of an
array. Since all of the elements of the array are the
same data type, they will all use the same number of
bytes in memory. So, the computer calculates the
address of an element in an array using the formula:

memory address = base address + (index * size)
In this example, the base address for the array priority
is 4000. The size of each element is 4 bytes, since it is
an array of integers. So, the address of priority[2] is:
address of priority[2] = 4000 + 2 * 4
which equals 4008.
(Remember, addresses are base 16 – hexadecimal).
This scheme works because the index of the first
element in the array is 0, not 1. In fact, this is why
array index values start at 0.
Notice that the highest index is one less than the size of
the array, because the array index numbering starts at
zero. In this example priority has 6 elements,
priority[0] through priority[5].
4003
4004 priority [1]

4005
4006
4007
4008 priority [2]
4009
400A
400B
400C priority [3]
400D
400E
400F
4010 priority [4]

4011
4012
4013
4014 priority [5]
4015
4016
4017
4018 score
4019
401A
401B

One Dimensional Arrays in Java
A one-dimensional array in Java is a indexed fixed-length
homogeneous data structure. In other words,
it is a set of sequentially numbered data elements, in which all
of the data must be of the same data
type, and with a number of elements that cannot be changed. In
Java, an array is an object.
There are two parts to declaring an array in Java, unlike
primitive data types, which have a one-step
declaration. First, the array must be named; second, the size
must be declared.
step 1 – Declare a name for the array. There are two styles for
doing this, which both assign a name to
an array, but do not create the array in memory: (The first style
is preferred.)
int[] score; // declares score to be the name of an int array, it

has no elements
int score[]; // declares score to be the name of an int array, it
has no elements
step 2 – Declare the size of the array.
score = new int[10]; // declares the array score to have 10
integer elements
The number in brackets is the number of elements or size of the
array, also known as the array length.
The indexes in Java arrays must be non-negative and always
start at zero. The highest index will be one
less than the size of the array. If the array length is n, then the
highest index will be n-1.
The statement that declares the array length actually creates the
array.
The two statements naming an array and declaring an array must
both be used to create the array:

int[] score;
score = new int[10];
The name and size declarations for an array can be put together
in one Java statement, which is the
easiest and most common way to create an array in Java:
int[] score = new int[10]; // score is the name of an integer
array with 10 elements
The keyword new is necessary when declaring objects. An
array is an object in Java. This statement
declares an array named score and sets the size to 10 elements.
What is actually in an array in Java?
Each element in an array is an individual variable of the data
type declared for the array. For example, if
empName is declared as:
String[] empName = new String[10];

then each of the array elements, such as empName[3], is a
String variable.
If the data type of an array is a primitive data type, then each
element of the array contains a value of
that data type. If the data type of an array is a class of objects,
then each element in the array contains
a memory address referring to where an object of the correct
data type is stored in memory. A memory
address referring to where an object is stored is called a
reference to an object. Java Strings are objects,
so each element in a String array holds a reference to a String,
not the String itself.
Example 1 – an integer array

An array of integers contains the actual values of integers, since
int is a primitive data type.
int[] score = new int[5];
This statement creates an array of integers named score with 5
elements. The actual values of integers
would be stored in the each element in the array, such as:
memory
address
variable name for
this address
value stored
at this address
4000 score[0] 93
4004 score[1] 87
4008 score[2] 91

400C score[3] 95
4010 score[4] 88
We can think of an array as a set of empty boxes. In the integer
array score, each box holds an integer:
Score[]
93 87 91 95 88
Example 2 – A String array
With any array of objects, including a String array, the elements
of the array actually contain references
to the objects, not the objects themselves. So, an array of
Strings would contain references to where
the Strings themselves are stored in memory, like this:
String[] empName = new String[5];
memory

address
variable name for
this address
value stored
at this address
4000 empName[0] ….4184
4004 empName[1] ….4210
4008 empName[2] ….4258
400C empName[3] ….510C
4010 empName[4] ….4412
This example assumes that each memory address is 32 bits (4
bytes)
long, but only the last 4 hexadecimal digits are shown.
The Strings are actually stored in the memory locations
referenced by the values in the array.

If we think of an array as a set of empty boxes, then each box in
the String array empName, holds a
reference to where a String value is actually stored in memory:
empName[]
….4184 ….4210 ….4258 ….510C ….4412
“Jones” “Goldschneider” “Brown” (and so on…)
Why does Java store arrays of objects this way? Remember, an
array is a fixed length data structure, but
Strings and many other objects are not fixed length, their sizes
can change. This method for storing
objects in memory allows variable length objects to be store in
fixed length arrays. It also has several
advantages that are beyond the scope of what we cover in this
chapter.

Even though the elements of a String array actually contain
references to Strings, if we use a variable
from the array in our Java code, we will get the String, not the
reference. For the example above:
System.out.println( empName[2] ); //prints the name Brown,
not the reference ….4258
Once we learn to work with objects, we will see that we can
have an array for any type of object, just as
with Strings, using references to the objects stored in memory,
such as an array of images:
Example 3 – an Array of Images
JPGimage[] orientation = new JPGimage[5];
orientation[]

4100 6404 7820 880C B204
… and so on. Each element in the array contains a reference
to a stored image.
Assigning Values to Array Elements
There are two ways to assign values to array elements:
1. using assignment statements
For example:
score[3] = 98; // an int value is assigned to the fourth
element in score

empName[0] = “Jones”; // a String value is assigned to
the first element in empName
a[4] = x; // a[4] is set to the value of x (data types
must match)
2. by listing values in an alternate array declaration
Arrays may be declared in a statement that lists their values:
int[] score = {93, 87, 91, 95, 88};
This method is sometimes called an explicit array declaration.
The values listed in braces,
separated by commas, are assigned in order to the array
elements. The length of the array is
determined by the number of values in the list. The keyword
new is not needed in an explicit
array declaration.
An explicit array declaration like the one just shown above
works well for small arrays, but can be

awkward for large arrays.
One common way to initialize the values in an array is with a
count controlled loop. Here are a few
examples:
Example 4 – Initializing all of the elements in an Array to Zero
The following code initializes the values of an array of data
type double all to the same value, zero:
double[] cost = new double[100]; // an array of 100 numbers
for(int i=0; i<100; i++)
cost[i] = 0.0;
Example 5 – Initializing an Array with User Input
The following code initializes the values of an array of data
type String with user input. Inside the array

the names are numbered starting with 0, but to the user they are
numbered starting with 1. This
assumes that the code is encapsulated, meaning that the user
does not see the code.
String[] student = new String[10]; // an array of 10 student
names
for( int i= 0; i < 10; i++)
{
// Ask the user for a student name, then get the name from the
keyboard
System.out.print("Please enter the name of student number"
+ (i+1) + “:” );
student[i] = x.nextLine();
} // end for

Example 6 – Initializing an Array with random numbers
The following code initializes the values of an int array with
random numbers between 1 and 100. An
array of random numbers is often used in game or simulation
programming, or to test other software.
int [] num = new int[100]; // an array of 100 integers
for( int i= 0; i < 100; i++)
num[i] = 1+(int)(Math.random()*100); // random, 1 <= num[i]
<= 100
Math.random() yields a value between 0 and 1; the arithmetic
converts it to a integer between 1 and 100.
The Array length Property; Iterating an Array
x.length, where x is the name of an array, is a method for

instances of array objects that returns the
length of the array as an integer. For example, if the array
score[] has 10 elements, then score.length
returns the value 10.
The length property can be used to iterate an array. To iterate an
array means to go through each of the
elements in the array on at a time. The three examples above
each iterate an array, and could be
written to use the length property. Here is the code from
example 4, above, re-written using the length
property for the cost array.
Example 7 – Initializing an Array using the length method
for(int i = 0; i < cost.length; i++)
cost[i] = 0.0;

There are many different reasons to iterate an array – to
initialize the array as above, or to print the
elements of the array, for example.
Example 8 – Printing the Elements of an Array
// the following assumes student is a String array that has
been initialized
for( int i= 0; i < student.length; i++)
System.out.print("Student number " + ( i+1) + “ is ” +
student[i]);
Example 9 – Printing the Fibonacci numbers
The Fibonacci sequence is a sequence of numbers that starts
with 0 and 1, then each successive term in
the sequence determined by adding the previous two terms.
Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,
…

Such a pattern is very common in the natural world. The
following diagrams help us to understand why
that is so. On the left, we see a set of rectangles composed by
adding squares whose sides are
successively larger Fibonacci numbers. The next square to be
added will have a side of length 13, and
will be added above the existing rectangle. On the right we see
a spiral drawn by connecting the corners
of Fibonacci squares. The growth of branches on a tree, the
shape of a spiral sea shell, the pattern of
seeds on a sunflower, the growth of a population of rabbits, and
many other patterns in the real world
fit the Fibonacci sequence.

In this example, we will store the first 10 Fibonacci numbers in
an array named fib[], then print the
array. We will declare the array using a set of values.
int[] fib = {0,1,1,2,3,5,8,13,21,34}; // an array initialized with
Fibonacci numbers
int i;// used as an array index
System.out.println(“The first ten Fibonacci numbers” );
// this loop prints the values in the array
for( i= 0; i < fib.length; i++)
System.out.print(fib[i] + “ “);
System.out.println(); // go to a newline after printing the array
values
The output looks like this:

The first ten Fibonacci numbers
0 1 1 2 3 4 5 8 13 21 34
The Enhanced for Statement
The for statement we have been using so far is the basic for
statement. Java also has a special version of
the for statement, called the enhanced for statement. The
enhanced for statement iterates an entire
array. It may only be used with an array or an object that can be
iterated like an array.
The enhanced for statement has a loop header with the keyword
for, followed by parentheses that
contain an integer declaration and the name of an array. The
statement or block of code following the
loop header will be executed once for each element in the array.
Within the statement or block of code, the integer declared in
the loop header refers to each element in

the array. The syntax within an enhanced for loop can be
tricky, so be careful. We do not use the name
of the array within the loop, only the integer variable declared
in the header. This variable refers to an
element of the array, sequentially incremented each time
through the loop. Here is the syntax of the
enhanced for loop:
for ( integer declaration : name of an array)
block of code
Here is the same code from above to print the array with the
first 10 Fibonacci numbers, using an
enhanced for loop instead of a basic for loop:

Example 10 – the enhanced for loop
int[] fib = {0,1,1,2,3,5,8,13,21,34} // an array initialized with
Fibonacci numbers
System.out.println(“The first ten Fibonacci numbers” );
// this loop prints the values in the array using the enhanced for
statement
for(int i : fib)
System.out.print(i + “ “); // i refers to fib[i] in this enhanced
for loop
System.out.println(); // go to a newline after printing the array
values
The first ten Fibonacci numbers

0 1 1 2 3 4 5 8 13 21 34
Although it is convenient, the enhanced for loop has limited
applications. It can only be used to iterate
an entire array, not part of an array, and the declared integer
variable cannot be used as an integer
variable within the loop, only to refer to each element of the
array.
Copying an Array
An assignment statement such as second = first; will not copy
an array; it copies the reference to the
array, creating two variables referencing the same array. To
copy an array in Java, we must create
another array of the same data type and size, then copy each
value from the original array into the new
array. The actual copying can be done with a for loop or with
an enhanced for loop.

Example 11 – copying an array
// an array initialized with ten prime numbers
int[] first = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
// To copy an array, we need to create another array of the
same data type and size.
int[] second = new int[10];
// Then, we copy each element from the first array into the
second array.
for(int i : i < first.length; i++)
second[i] = first[i];
// This could also be done with an enhanced for loop
for(int i : first)

second[i] = first[i];
Arrays as Method Parameters in Java
An entire array can be passed as a method parameter, but
remember, the name of the array by itself is a
reference to the base address where the array is stored in
memory. It is this reference, and not the
values in the array, that is passed to another method when an
array is passed in Java. We end up with
two different reference variables pointing to the same array in
memory, not two different arrays, as
shown in example 12 on the next page.
Example 12 – Passing an Array as a Parameter

In this example, an entire array is passed from the main method
to the method printJob(). However, the
array is not really passed; it is the value of the reference
variable that points to the array’s location in
memory that is really passed. Java always passes values. In this
case the value is the address of the array
in memory, so we end up with two different variables, priority –
the original name for the array – and
category – the copied name – both referring to the original
array.
priority = new int [6]; priority 4000 4000 priority [0]
int score; score 4018 4001
. . . 4002

int[] category; category 4000 4003
int i; i 4054 4004 priority [1]
int[] priority = new int[6];
. . .
// call method printJob()
printJob(priority);
. . .
public static void printJob(int[] category){
for( int i=0; i < category.length; i++) {
System.out.printl(“Job” + i + “is in category “ + category[i]);
. . .
}
The method header for the printJob() method establishes a
reference variable to
refer to an array, category, but category has no value until the
method is invoked

from another method.
When printJob() is invoked from the main method, the value of
the array reference
variable priority is passed to array reference variable category
in the formal
parameter list. Now both priority and category have the same
value, the address
of the same array. This means they refer to the same array –
priority and category
have become two names for the same array – whatever we do to
one we do to the
other. If we change the value of an element in category we also
change the value
of that element in priority. category[3], for example, is
priority[3].
Java always passes a value, not a reference to a value, but that
value may be an
address of an object, such as the address of the array passed in
this case.
4005
4006

4007
4008 priority [2]
4009
400A
400B
400C priority [3]
400D
400E
400F
4010 priority [4]
4011
4012

4013
4014 priority [5]
4015
4016
4017
4018 score
4019
401A
401B
401C
401D
401E
401F

4020
The value of the actual
parameter priority is passed
to the formal parameter
category, but that value is a
reference to an array.
Passing an Array Element as a Method Parameter
Each element in an array is an individual variable that is treated
like any other any variable with the
element’s data type. It may be used like any other variable of

that data type, including as an actual
parameter for a method.
Example 13 – passing an array element as a parameter
In this example, price[] is an array of double values. price[3] in
the main method is used as an actual
parameter. The value of the variable price[3] is passed to the
formal parameter cost when the
method is invoked.
double[] price = { 1.99, 3.87, 4.95, 2.99, 2.57};
. . . // all of the code is not shown
currentSale(price[3]);
/****************************************************
******************/

public static void currentSale(double cost) {
System.out.printl(The cost of the item is: “ + cost);
}
The value of price[3] is copied to cost in the method
currentSale(). Any change that is later made to
cost has no effect on the original value in price[3].
CheckPoint 6.2
1. A one-dimensional array in Java is defined as an indexed
fixed-length homogeneous data
structure. What does this mean?
2. What is actually in an array if the array’s data type is a
primitive data type and how does this

differ from what is in an array if the array’s data type is class of
objects?
3. What are the two ways that a value can be assigned to an
array element?
4. Create an example showing how the enhanced for statement
can be used to iterate an array.
5. How is an entire array passed as a method parameter and
what happens in the original array if a
value is changed in an array within a method that has received
the array as a parameter?
Operations on Numeric Arrays
Once we have a set of numbers stored in an array, we can

perform numerical analysis of the data.
Common operations on numerical arrays include finding the
sum, the average, the minimum and the
maximum of the values in an array.
The following examples show how to do each of these things for
a set of values in a double array.
Sum, Average, and Count of Values in an Array
To find the sum of a set numbers in an array we need a variable
to hold the sum. It should have the
same data type as the elements of the array, and it should be
initialized to zero. Then, we iterate the
loop, adding each value in the array to the sum, as in the
following code. After the loop to iterate the
array is finished, then the variable will hold the sum.
The average is simply the sum divided by the number of
elements in the array. The array length

property is the number of elements in the array.
Example 14 – finding the sum and average of values in an array
double sum = 0;
// the statements that give values to the elements in the array are
not shown
for(int i= 0; i < cost.length ; i++)
sum = sum + cost[i];
System.out.println("the total cost is " + sum);
System.out.println( "the average cost is " + sum/cost.length );
In this example, the average is calculated as part of the print
statement. We could also have a variable
to hold the average if we need to use it later.

Counting Elements in an Array
Sometimes we wish to count all of the values in an array that
meet a certain condition. To do so, we
simply initialize a counter to zero, then increment the counter
for each element that meets the
condition.
Example 15 – counting the elements in an array
In this we will again use the first ten Fibonacci numbers.
Instead of printing each of the numbers, we
will only print the even Fibonacci numbers and we will count
them as well.
The variable countEven is first initialized to zero, then, as we
iterate the array, we will increment the
count for each even Fibonacci number. To test for even
numbers, we will use the Java’s remaindering

operation (%), which returns the remainder of an integer
division operation. If the remainder is zero
when we divide by two, then the number is an even number.
int[] fib = {0,1,1,2,3,5,8,13,21,34}; // an array initialized with
Fibonacci numbers
int i;// used as an array index
int countEven = 0;// used to count how many of the first 10
Fibonacci numbers are even
System.out.println(“Even Fibonacci numbers” );
// this loop prints the values in the array

for( i= 0; i < fib.length ; i++)
if (fib[i] % 2 == 0) {
countEven++;
System.out.println( fib[i] + “ is even”);
}
System.out.println ( countEven + “ of the first 10 Fibonacci
numbers are even”);
Even Fibonacci numbers
0 is even
2 is even
8 is even
34 is even

4 of the first 10 Fibonacci numbers are even.
The Minimum and Maximum Values in an Array
To find the minimum value in an array, we start with a variable
to hold the minimum. We initialize the
minimum to the first value in the array, then go through the rest
of the values in the array, testing each
to see if it is less than the minimum. If a value is less than the
minimum, it becomes the new minimum.
After going through the entire array, the variable will hold the
minimum value from the array.
The maximum is calculated in almost the same way, setting the
first value to be the maximum, except
we then check to see if each value is greater than the maximum.
Example 16 – finding the minimum value in an array

int i;
double minimum;
not shown
minimum = a[i];
for( i= 1; i < cost.length ; i++) // iterate starting at the second
element
if ( cost[i] > minimum )
minimum = cost[i];
System.out.println("the minimum cost is " + minimum);
Example 17 – finding the maximum value in an array
int i;

double maximum;
not shown
maximum = a[i];
for( i= 1; i < cost.length ; i++) // iterate starting at the second
element
if ( cost[i] < maximum)
maximum = cost[i];
System.out.println("the maximum cost is " + maximum);
Searching and Sorting Arrays
Comparing Strings

In order to search or sort an array of Strings we need to be able
to compare String values. This is easy for
integers and floating point data, but when it comes to Strings,
there is a complication.
The Boolean condition (a == b) will work if a and b are Strings,
but it doesn’t work the way most people
think it does. Strings are objects, and a comparison of two
objects using the == operators compares the
reference values stored in the two variables, not the values of
the objects themselves. In other words,
(a==b) will be true only if a and b refer to the same object, not
equal objects. We have a similar
problem with the < and > operators.
Java has a number of different ways to compare objects in
general and Strings in particular. Here we
will look at two different methods from the String class that can

be used to compare Strings:
1. the a.matches(b) method. The String matches() method
returns a true value if the String
variable a is equal to the String expression b, otherwise, it
returns a false value. The String
expression may be a variable, a String literal, or anything that
evaluates to or returns a String.
2. the a.compareTo(b) method. The String compareTo() method
compares two Strings
lexicographically. A lexicographic comparison compares two
text items character-by-character
using a predefined collating sequence. In the case of Java
Strings, the collating sequence is the
UTF-16 version of Unicode. This is similar to the way a person
might compare two names to see
which one comes first alphabetically. The method returns an
integer value,

a. If the two Strings are the same, then the compareTo() method
returns the integer 0.
b. If a is less than b, then the method returns an integer less
than 0 (a negative integer).
c. If a is greater than b then the method returns an integer
greater than 0 (a positive
integer).
The String matches() method is an easy way to see if two
Strings are the same. The String compareTo()
method is useful for when we are trying to see which String
comes before the other, such as when we
are sorting a list of String values.
String handling is covered more in detail later in this course,
and in subsequent courses. The matches()
and compareTo() methods are used in the rest of this section.

Linear Search of an Array
Sometimes we wish to search an array to see if it contains a
certain value. We can do this many
different ways, but the simplest and most straightforward is a
linear search. In a linear search of an
array, we look at each value in the array one at a time to see if
the value we are seeking is in the array.
If we find the value, then we are done. If we get to the end of
the array without finding the value, then
the value is not in the array.
There are several different ways to implement a linear search.
We will use a loop with a compound
condition and a Boolean variable to keep track of whether or not
the value we are seeking is in the
array. In the following example, we first look at the
pseudocode for the array then see the final program

built from that pseudocode.
Example 18 – linear search of an array
In this example, an array contains a list of cities that have
professional football teams. The user enters
the name of a city to see if it is in the list. The program will
perform a linear search of the array. First, a
boolean variable named found is set to false. The continuation
condition in the for loop to iterate the
array will contain a compound condition, continuing while
found is false and while the end of the array
has not been reached. If the city is found, a message is printed
and a boolean variable is set to true to
terminate the loop. If the found variable is still false after the

loop, a not found message is printed.
Using the found variable in the compound condition provides an
advantage by making the search more
efficient. With it, the loop will stop as soon as the value is
found. Without it, the loop always goes
through the entire array. Consider, for example what happens
if the value being sought is in the first
element in an array of 100 elements. With the compound
condition, the loop stops after looking at the
first element. Without the compound condition the loop iterates
all 100 times.
The efficiency of algorithms is important, especially as data
sets grow larger. Algorithmic efficiency is
studied in detail CSCI 112 and 211.
Pseudocode for a linear search of a String array
/* in the search, n is the loop counter -- the continuation

condition is:
( n less than NFLcities.length )and (target city not found)
*/
String[] NFLcities; // an array holding the names of cities
with NFL teams
n int; // loop counter
boolean found = false; // will be set to true if the city is found
in the list
print intro message
get the target name of the city from the user
for ( i=0; not (found) AND n < NFLcities.length ; n++)
if ( target matches NFLcities[n] ) // if the name entered
matches this entry in the list.
print NFLcity[n] has an NFL team
set found to true

after the loop – if not(found) print “ [target] is not in the list of
cities with an NFL team.”
/* CSCI 111 - Fall 2013
* NFL City Search Program
* This program performs a linear search of a String array with
* the names of cities that have NFL teams
* last editied Sept. 28, 2013 by C. Herbert
*/
package nflcities;

public class NFLcities {
// an array holding the names of cities with NFL teams.
String[] NFLcities = {"Buffalo", "Miami", "Boston", "New
York", "Baltimore",
"Cincinnati", "Cleveland", "Pittsburgh", "Houston",
"Indianapolis",
"Jacksonville", "Tennessee", "Denver", "Kansas City",
"Oakland",
"San Diego", "Dallas", "New York", "Philadelphia",
"Washington", "Chicago",
"Detroit", "Green Bay", "Minnesota", "Atlanta", "Charlotte",
"New Orleans",
"Tampa", "Arizona", "St. Louis", "San Francisco",
"Seattle"};

String target; // the city for which we are searching
int n; // loop counter
boolean found = false; // true if the target city is found in the
array
// set up input stream from the keyboard
Scanner keyboard = new Scanner(System.in);
// print intro message
System.out.print("This program will tell you if a city has an
NFL team.nn");
// get the target name of the city from the user
System.out.print("Please enter the name of a city: " );

target = keyboard.nextLine();
// search array of NFL cities for target city
// the loop coninues to the end of the array if the city is not
found
for (n=0 ; (!found) && (n < NFLcities.length) ; n++)
{
if (NFLcities[n].matches(target) ) // uses the String class
matches() method
{
//print found message and set found to true
System.out.println(target + " has an NFL team.n");
found = true;
} // end if

} // for loop
// after the loop – if not(found) print not found message
if (!found)
System.out.println(target + " is not in the list of cities with an
NFL team.n");
} // end main()
} // end class
Sorting an Array
It is useful to be able to sort an array. There are many different

ways to do so, which are studied in
detail in CSCI 112 and CSCI 211. We will look at a simple
sorting method called a bubble sort.
In a bubble sort, we go through an array of data comparing each
data item to the next item. If they are
out of order, then we swap them; if they are in the correct order,
then we leave them alone. We
compare each item to the next item until we reach the end of the
array. Each time we go through the
entire array is called a pass through the array. We continue to
make passes until we can make one pass
all the way through the array without swapping anything. The
bubble sort is based on the transitive
property of equality and inequality (if A≤B and B≤C, then A≤B)
If we can make a pass without swapping
anything, then we know the array is in the correct order and
we’re done – the array is sorted.

We can use a boolean variable named swapped to keep track of
whether or not we needed to swap
anything in each pass through the array. Before we go through
the array, we set swapped to false. If we
swap anything, we also set swapped to true. When we finish a
pass, if swapped is true, then something
was swapped, and another pass is needed. If swapped is still
false after making a pass through the array,
then nothing needed to be swapped in that pass, and the array is
in the correct order; the sort is done.
Here is pseudocode for a bubble sort of an array. Notice that
each pass through the array only goes to
the second-to-last element in the array, since we are comparing
each element to the one that follows it.
The last comparison will then be between the second-to-last
element in the array and the last element.

Start Bubble Sort – sorts in ascending order (lowest to highest)
a[n] is an array with n elements
boolean swapped = true; //keeps track of when array values are
swapped; true to start the sort
while (swapped = true);//the outer loop will repeat each pass
through the list if swapped is true
{
swapped = false; // set swapped to false before each pass
for ( i=0; i < a.length – 1; i++) // a pass through the array
to the second to last element
{
if ( a[i+1] < a[i]) // if the two items are out of order
{
swap the two items (a[i] and a[i+1])

set swapped to true
} // end if
} // end for
} // ends while -- the outer loop will repeat if swapped is true
– another pass
Stop Bubble Sort
The table on the next page illustrates a bubble sort on the array
of integers { 3 7 1 9 4 8 2 5 6).
On the left, we can see what happens during the first pass
through the array. Starting with i=0, A[i+1] is
compared to A[i]. If A[i+1] < A[i], they are swapped,
otherwise, nothing happens.
On the right, we see what the list looks like after each pass.
The sort stops when a pass is made without
swapping anything, which means the list is in order.

inside one pass in a Bubble Sort
3 7 1 9 4 8 2 5 6 i=0
— nothing happens
3 7 1 9 4 8 2 5 6 i=1
— swapped
3 1 7 9 4 8 2 5 6 i=2
— nothing happens
3 1 7 9 4 8 2 5 6 i=3
— swapped
3 1 7 4 9 8 2 5 6 i=4

— swapped
3 1 7 4 8 9 2 5 6 i=5
— swapped
3 1 7 4 8 2 9 5 6 i=6
— swapped
3 1 7 4 8 2 5 9 6 i=7
— swapped
3 1 7 4 8 2 5 6 9 result of first pass
Swapping the Values of Two Variables
In order to implement the bubble sort, we need to learn how to
swap the value of two variables. In fact,
almost every sorting method requires swapping the values of
variables at some point. It is a little more
complicated than it seems at first. Consider the following code:

int a = 7; a 7
int b = 3; a 7 b 3
a = b; a 3 b 3
b = a: a 3 b 3
The code doesn’t swap the two variables. To swap two
variables correctly, we need a third variable,
called a catalyst variable. A catalyst variable is like a catalyst
in a chemical reaction – we don’t care
what it is before the operation or after the operation, but it
needs to be there to make things work
properly. In this case, the catalyst variable preserves the value
of one of the variables being swapped.
Consider this code:
int a = 7; a 7
int b = 3; a 7 b 3
int c; a 7 b 3 c
c = a; a 7 b 3 c 7

a = b; a 3 b 3 c 7
b = c: a 3 b 7 c 7
In this case a and b have been successfully swapped. c is the
catalyst variable we need to do this.
after each pass in a Bubble Sort
3 7 1 9 4 8 2 5 6
swapped = true
3 1 7 4 8 2 5 6 9
swapped = true
1 3 4 7 2 5 6 8 9
swapped = true
1 3 4 2 5 6 7 8 9
swapped = true

1 3 2 4 5 6 7 8 9
swapped = true
1 2 3 4 5 6 7 8 9
swapped = false
the list is now in order
Example 19 – bubble sort
The following code implements a bubble sort in Java. It has
one loop inside another loop. The inner
loop, the for loop, makes a pass through the array comparing
each element to the next element. If the
two are out of order, then the two values are swapped and the

swapped variable is set to true. The
outer loop repeats if anything swapped is true, indicating a swap
was made during the pass. When a
pass is made through the loop without swapping, swapped will
remain false and the outer loop will end.
This means the array is in order. The swapped variable is set to
true before the first pass to to get things
started.
In this example we will again use the array of cities with NFL
teams. We will print the list, sort the list,
and then print it again. The program is written in several
modules – a main method, a printing method,
and a sorting method. The only thing the main method does is
to call the other methods. This is how
good modular development works.
/* CSCI 111 – Spring 2015

* Bubble Sort Example
*
* This program performs a bubble sort of a String array with
* the names of cities that have NFL teams
*
* it also demonstrates modular development and passing an
array as a parameter
*
* last edited Feb. 11, 2015 by C. Herbert
*/
package bubblesort;
public class BubbleSort {

// an array holding the names of cities with NFL teams
String[] NFLcities = {"Buffalo", "Miami", "Boston", "New
York", "Baltimore",
"Cincinnati", "Cleveland", "Pittsburgh", "Houston",
"Indianapolis",
"Jacksonville", "Tennessee", "Denver", "Kansas City",
"Oakland",
"San Diego", "Dallas", "New York", "Philadelphia",
"Washington", "Chicago",
"Detroit", "Green Bay", "Minnesota", "Atlanta",
"Charlotte", "New Orleans",
"Tampa", "Arizona", "St. Louis", "San Francisco",
"Seattle"};
// call a method to print the list of cities before sorting

printCities(NFLcities);
// call a method to sort the array of cities
sortCities(NFLcities);
// call a method to print the list of cities after printing
printCities(NFLcities);
} // end main()
/****************************************************
************************/
(The code is continued on the next page.)

(This code is continued from the last page.)
// this method prints the values in a string array
public static void printCities(String[] a) {
int i; // used as a loop counter
System.out.println(); // print a blank line before starting
for (i=0; i <a.length; i++)
System.out.print(a[i] + " ");
} // end printcities()
/****************************************************
************************/

// this method sorts the values in an array of Strings using the
bubble sort algorithm
public static void sortCities(String[] a) {
boolean swapped = true; // keeps track of when array values
are swapped, true to start
int i; // used as a loop counter
String c; // a catalyst variable for swapping values of
variables
//the loop will repeat when swapped is true (until no swap
occurs)
while (swapped) {
swapped = false;
// each iteration of the for loop is a pass through the array
to the second-to-last element

for(i=0; i < (a.length - 1) ; i++) {
// if the two items are out of order
if (a[i+1].compareTo(a[i]) < 0) {
// swap the two items and set swapped to true
c = a[i];
a[i] = a[i+1];
a[i+1] = c;
swapped = true;
} // end if
} // end for
} // end while

} // end sortCities()
/****************************************************
************************/
} // end class
CheckPoint 6.4
1. Why is the String class matches() method used to tell if two
String values are equal, rather than
using the comparison operator (a ==b), such as for int values?
2. Describe how the String class compareTo() method is used to
compare String values
3. Describe what a linear search of an array is and how it works.
4. Describe the transitive property of equality and inequality
and why it is important in most

techniques for sorting data.
5. Describe how a bubble sort works.
Text File Input and Output in Java
Reading from data files and writing to data files can be quite
complicated. Yet, there are a few fairly
simple ways to create text files using Java. In this section we
will look at a simple techniques for writing
text data to a file using the PrintWriter class, and for reading
text data from a file that uses the Scanner
class we have been using for console input.
Accessing a text data file is a two-step process:
1. use a File class objects to establish the file we wish to work

with,
2. then connect a text input stream from a file to our application
using the Scanner class, or
connect a text output stream from our application to a file using
the PrintWriter class.
The data in files on most modern computer systems consists of
electronic, magnetic, or optical
signals that represent bits of information that could represent
almost anything – text, numbers,
sound, pictures, video, and so on. The bits need to be formatted
following the rules for what they
represent, such as the JPEG format for images, an IEEE 754
format for floating point numbers, or
the Adobe PDF document format. How many different file
formats are there? Many. The
Wikipedia page online at:
http://en.wikipedia.org/wiki/List_of_file_formats has a list of

roughly
one thousand of the most commonly used file formats.
In chapter 2 we looked briefly at console file input and output,
organized as streams of tokenized text
data, as shown in the following diagram.
Input and output to and from data files formatted as simple text
can work the same way, except the
source and destination are data files, not the console. Within the
application, there is little difference,
except we need to connect the data streams to files, not to the
console.
http://en.wikipedia.org/wiki/List_of_file_formats

We will see how to read data into our applications from text
files using the features of the Scanner class,
which we have already used. Methods in the Scanner class such
as the Scanner class’s nextDouble()
method, can turn incoming text data into formats for other data
types. (See chapter 2, page22.)
We will use methods from the Printwriter Class to send text
data to a file. The methods are identical to
the Sytem.out methods we have already used – print(), println(),
and printf().
The File class in the Java IO package includes methods for
naming, identifying and accessing data files
from within Java applications. It works in conjunction with the
host operating system to deal with data
files, but not with the formats of the data in the files.
The Java IO package with the file class is used so often that it is

automatically accessible from any Java
program, so we don’t need to import it. The Java Utilities
package, which contains the Scanner class,
does require an import statement, such as import java.util.* to
import the entire package, or
import java.util.Scanner to import just the Scanner class from
the package.
In the rest of this section we look at simple examples of the
techniques for reading and writing text data
files described above. A Java text file is a a Unicode UTF-16
text file, organized as characters based on
the Unicode UTF-16 specifications. It can be read by almost
any modern text editor or word processor.
If you send the files to most printers or computer screens, they
will display or print the characters in the
file so that we can read them. Accessibility tools for the
physically disabled, such as text to speech text

readers, can work with Unicode text files. Almost all modern
operating systems have the ability to
handle Unicode text files.
Handling Data File Exceptions like Hot Potatoes
Before we start, there is one more thing about data file
programming that we need to know. Java
requires us to tell it how we are going to handle any exceptions
that occur when we are working with
data files.
An exception is an object that is created whenever a run-time
error occurs in a Java program. A run-
time error is an error that occurs while an application is
running, not when the program is being
complied. There are different classes of exception objects, such
an ArrayIndexOutOfBoundsException if

an application tries to access employee[300] when the array
employee[] only has 100 elements, or a
FileNotFoundException if an application tries to read from a
data file that does not exist. The type of
exception that occurs and properties stored in the exception
object contain information that might be
useful to software analysts in finding and correcting software
errors.
Some data file exceptions will generally cause our programs to
crash, or worse, they could mess up
other files, perhaps even disabling a hard drive or causing a
computer system to crash. Because of this,
Java requires us to tell it how we plan to handle file I/O
exceptions.
There are generally two ways to handle exceptions in a Java
method – the first is to create an exception
handler, which is a method that handles an exception. What it

does depends on the nature of the
exception. This is known as catching an exception. To catch an
exception is to transfer control to an
exception handler when an exception occurs. We aren’t yet
ready to start catching exceptions.
Exceptions will be discussed briefly near the end of the
semester and in more detail in CSCI 112.
The second way to handle an exception is to throw the
exception. To throw an exception is to send it
back to whatever software invoked the method in which the
exception occurred. For the main methods
in our Java applications, most of the time this will be the
computer’s operating system. We can think of
this as the “hot potato” method of dealing with an exception.

We don’t know how to handle it, so we
throw it back to someone else to handle. We will throw file
exceptions back to the operating system to
handle.
This is pretty easy to do. We simply add the “throws Exception”
clause to the end of a method header.
For now, we need to do this whenever we access data files in a
method, and in our main method if it
calls any methods that handle data files. This will throw the
exception like a hot potato back to the main
method, which will in turn throw it back to the operating
system.
Here is an example of a method header with a “throws
Exception” clause: (notice the capital E)
public static void main(String[] args) throws Exception
We should add the “throws Exception” clause to any method

that accesses a data file, or that calls
another method which access a data file, or that calls a method
that calls a method that accesses a file,
or that calls a method that calls a method that calls a method
that calls a method that … you get the
picture.
The operating system is most likely going to halt our
application if we throw it an exception, but at least
we won’t accidently wipe out a hard drive, crash the entire
computer, bring the Internet to a grinding
halt, or accidently start a global thermonuclear war because of a
run-time error in what should be a
relatively simple Java application.
A Technique for Writing Text Data Files using Java
The File class in the Java IO package is used in conjunction
with classes that manage the formats of files

to read and write data. The File class manages the names and
locations of data files from within Java
applicaaions, but other classes handle the format of data moving
to and from files.
The PrintWriter class in the Java IO package includes methods
for sending out a stream of data
formatted as text. it has print(), println() and printf() methods
virtually identical to the System.out
print(), println() and printf() methods with which we are already
familiar. To quote a famous Saturday
Night Live character, “How convenient!”
We can create instances of objects from the File class and the
PrintWriter class to write to a data file.
They work together – the File class identifies the file and the
Printwriter class sends out the data to the
file as a stream of formatted text, just as System.out sends data

to the console.
The easiest way to see how to do this is to look at examples.
The following two examples are contained in
NetBeans folders in the files for week 6. You should become
familiar with how these two programs work.
Example 20 – writing data to a data file
The code below sends the message “Hello World!” to a text data
file. The file will be stored in the
NetBeans folder for your project. After the program runs, you
should be able to open the folder and
look at it with NotePad, WorPad, Word, or any application that
can read a text file.

/* CSCI 111 - Fall 2013
* writing "Hello world!" to a data file
* this program demonstrates writing to a text file
* last edited Sept. 28, 2013 by C. Herbert
*
* warning -- this will overwrite the file "hello.txt"
*/
package writehello;
public class WriteHello {
public static void main(String[] args) throws Exception {
// create a File class object and give the file the name

hello.txt
java.io.File x = new java.io.File("hello.txt");
// Create a PrintWriter text output stream and link it to the
file x
java.io.PrintWriter y = new java.io.PrintWriter(x);
// Write text output to the file using print(), println() or
printf()
y.println("Hello World! ");
System.out.println("File written...");
System.out.println("Open the NetBeans folder for this
project and then");
System.out.println("open the file hello.txt to see the
result.n");

// close the data stream and associated file
y.close();
} // end main()
} // end class
A Technique for Reading Text Data Files using Java
We can use the File class and Scanner class together to read
data from a text file. The File class is used
to connect to data files from within Java applications and the
Scanner class is used to read the input
data stream from the file, just as we did from the console. It’s
trickier than writing to a file because we
need to know the name of the file, where it is, and what’s in the
file to make it work properly.

Example 21 – reading data from a data file
In the example below, we will read a single line of text from a
data file named Hello.txt that is stored in
the NetBeans project folder for the application.
/* CSCI 111 - Fall 2013
* reading "Hello world!" from a data file
* this program demonstrates reading from a text file
* last edited Sept. 28, 2013 by C. Herbert
*

* the file "hello.txt" must exist in the project folder for this to
work
*/
package readhello;
public class ReadHello {
String message; // holds the line of text coming in from
the file
// Create a File class object x and give it the name of the file
to read
java.io.File x = new java.io.File("hello.txt");

// Create a Scanner named y to read the input stream from the
file x
Scanner y = new Scanner(x);
// Read a line of text from the file
message = y.nextLine();
// print the message from the file on the screen
System.out.println("reading from the data file...n");
System.out.println(message);
// Close the input data stream and associated file
y.close();
} // end main()

} // end class
CheckPoint 6.5
1. How are Java’s File class and Scanner class used together to
read text data from a data file?
2. How are Java’s File class and PrintWriter class used together
to write text data to a data file?
3. What format does Java to store data in text files?
4. What is an exception in Java software?
5. Describe the difference between catching and throwing java
exceptions?

and Files
In this example we will see how to construct an application to
read data from a data file into an array,
sort the array, then write the data back out to another data file
from the array.
We will use the data files unsorted.txt, which contains a list of
tutorials for different programming
languages. Each line lists a different tutorial. Our task is to
read the file into an array of Strings, sort the
array alphabetically, then write the list to a new data file named
tutorials.txt
This example uses most of the things covered in this chapter
along with development of a modular
program.
First let’s look at the contents of the text file unsorted.txt:

Java - The Java Tutorials -
http://docs.oracle.com/javase/tutorial/
Python - Tutorialspoint Java tutorials -
http://www.tutorialspoint.com/python/
Perl - Tutorialspoint Perl tutorials -
http://www.tutorialspoint.com/perl/
C++ - cplusplus.con C++ tutorials -
http://www.cplusplus.com/doc/tutorial/
Objective C - The objective C programming tutorials -
http://howtomakeiphoneapps.com/objective-c-tutorial/
C++ - the LearnCPP C++ Tutorial - http://www.learncpp.com/
Objectice C - The Objective C tutorial -
http://objectivectutorial.org/
Java - LearnJavaOnline.org Interactive Java Tutorial -
http://www.learnjavaonline.org/
Objective C - Objective C beginner's Guide -
http://www.otierney.net/objective-c.html

C# - Microsoft's C# Tutorials - http://msdn.microsoft.com/en-
us/library/aa288436%28v=vs.71%29.aspx
Python - The Python Tutorial - http://docs.python.org/2/tutorial/
Python - Learn Python interactive Tutorial -
http://www.learnpython.org/
COBOL - The ZingCOBOL beginners guide to COBOL
Programming - http://cobol.404i.com/
Java - Tutorialspoint Java tutorials -
http://www.tutorialspoint.com/java/
C++ - Tutorialspoint Java tutorials -
http://www.tutorialspoint.com/cplusplus/
Ruby - Ruby in Twenty Minutes - https://www.ruby-
lang.org/en/documentation/quickstart/
PHP - PHP: a Simple Tutorial -
http://php.net/manual/en/tutorial.php
JavaScript - W3 Schools Javascript Tutorial -

http://www.w3schools.com/js/default.asp
Ruby - The Ruby DOC Introduction to Ruby - http://ruby-
doc.org/docs/Tutorial/
JavaScript - JavaScript for the Total Non-Programmer -
http://www.webteacher.com/javascript/
We can see that each line in the file contains the name of a
language, followed by the name of an online
tutorial for that language, followed by the URL for the tutorial.
We will first read the data into an array of Strings, with each
line as a separate element in the array,
then sort the array, then print the array. Each of these tasks
will be complete within its own method.
We will also print the array on the console after reading it in
and after sorting it.

Pseudocode – sorting a text file line by line
start main() method
String[] tutorials an array of Strings listing programming
language tutorials
int count the number of elements in the that are used
call a method to read data into tutorials[] and return count
call a method to print the array
call a method to sort the array
call a method to print the array
call a method to write the data to a file
stop main method
/*************************************************
This method reads data from a file into an array. We want our
array to work with up to 100 elements.

Each line from the file will be an element in the array. The
method returns the number of elements used.
start method int readList (String[] lines)
int count = 0; // count lines read
set up file access with File object
set up input Stream from the file object
while (the next line in the file exists) {
lines[count] = read next line from the file
count++;
} // end while
close file
return count // returns the number of items used in the array.
stop readlist
/*************************************************/
This method sorts an array of Strings line by line using a simple
bubble sort. The first parameter is the
array. The second parameter is the number of elements in the
array that actually contain data.

start method sortStringArray (String[] lines, int count)
boolean swapped = true ; // keeps track of when array values
are swapped, true to get started
int i; // a loop counter
// Each iteration of the outer loop is a pass. If any swap is made
in a pass, it repeats another pass.
while (swapped) {
set swapped to false before each pass
for ( i=0; i < count – 1; i++) { // a pass through the
array to the second to last element
if ( a[i+1] < a[i]) { // if the two items are out of
order, swap the two items
swap (a[i] and a[i+1])
set swapped to true
} // end if
} // end for
} // end while -- the outer loop will repeat if swapped is true –
another pass
stop sortStringArray

This method prints an array of Strings on the screen. The first
parameter is the array. The second
parameter is the number of elements in the array that actually
contain data.
start method printTextArray( String[] lines, int count)
for ( i=0; i < count – 1; i++) // a pass through the array
print an element from the array
stop method writeTextArray
/*************************************************
This method writes an array of Strings to a text data file. The
first parameter refers to the array in the
main method. The second parameter is the number of elements
in the array that actually contain data.
start method writeTextArray( String[] lines)

set up file access with File object
set up input Stream from the file object
for ( i=0; i < count – 1; i++) // a pass through the array to the
second to last element
write an element from the array to line in the file
close file
stop method writeTextArray
The next step is to convert the pseudocode to actual Java Code.
The code is shown on the next page.
Here is what the sorted data file should look like:
C# - Microsoft C# - http://msdn.microsoft.com/en-
us/library/aa288436%28v=vs.71%29.aspx
C++ - Tutorialspoint Java tutorials -
http://www.tutorialspoint.com/cplusplus/
C++ - cplusplus.con C++ tutorials -
http://www.cplusplus.com/doc/tutorial/
C++ - the LearnCPP C++ Tutorial - http://www.learncpp.com/
COBOL - The ZingCOBOL beginners guide to COBOL

Programming - http://cobol.404i.com/
Java - LearnJavaOnline.org Interactive Java Tutorial -
http://www.learnjavaonline.org/
Java - The Java Tutorials -
http://docs.oracle.com/javase/tutorial/
Java - Tutorialspoint Java tutorials -
http://www.tutorialspoint.com/java/
JavaScript - JavaScript for the Total Non-Programmer -
http://www.webteacher.com/javascript/
JavaScript - W3 Schools Javascript Tutorial -
http://www.w3schools.com/js/default.asp
Objectice C - The Objective C tutorial -
http://objectivectutorial.org/
Objective C - Objective C beginner's Guide -
http://www.otierney.net/objective-c.html
Objective C - The objective C programming tutorials -

http://howtomakeiphoneapps.com/objective-c-tutorial/
PHP - PHP: a Simple Tutorial -
http://php.net/manual/en/tutorial.php
Perl - Tutorialspoint Perl tutorials -
http://www.tutorialspoint.com/perl/
Python - Learn Python interactive Tutorial -
http://www.learnpython.org/
Python - The Python Tutorial - http://docs.python.org/2/tutorial/
Python - Tutorialspoint Java tutorials -
http://www.tutorialspoint.com/python/
Ruby - Ruby in Twenty Minutes - https://www.ruby-
lang.org/en/documentation/quickstart/
Ruby - The Ruby DOC Introduction to Ruby - http://ruby-
doc.org/docs/Tutorial/

/* CSCI 111 - Fall 2013
* reading, sorting and writing data in text files
* this program reads data from a text file, sorts the data,
* then writes the data back to another text file.
* last edited Oct 1, 2013 by C. Herbert
*
* for this to work, the file "unsorted.txt" must be in the project
folder
* warning -- this will overwrite the file "tutorials.txt"
*
* This program has methods to read lines from a text file into
an array,

* display a text array on screen line-by-line, sort a text array,
and write
* a text array to a data file line by line.
*
* The program is limited to a file with 100 lines. To change
this, change the
* size of the array declared in the main method.
*
*/
package tutorials;
import java.io.Scanner;
public class Tutorials {

// the main method call methods to perform each part of the
program
String[] tutorials = new String[100]; // an array to hold a
list of tutorials
int count; // the number of elements
actually used
// read data into tutorials[] line by line and return count
count = readLines(tutorials);
// print the array on the screen
System.out.println("The original file:");
displayLines(tutorials, count);

// sort the array
sortStringArray(tutorials, count);
// print the array on the screen line by line
System.out.println("nThe sorted file:");
displayLines(tutorials, count);
// write the array to a data file line by line
writeLines(tutorials, count);
} // end main()
/*************************************************/
/* This method reads data from the file into the array.
* We want our array to work with up to 100 elements

* Each line from the file will be one element in the array.
*
* The parameter refers to the array in the main method.
*
* The method returns the number of elements it uses.
*/
public static int readLines(String[] lines) throws Exception
{
int count = 0; // number of array elements with data

// Create a File class object linked to the name of the file
to read
File unsorted = new File("unsorted.txt");
// Create a Scanner named infile to read the input stream
from the file
Scanner infile = new Scanner(unsorted);
/* This while loop reads lines of text into an array. it uses
a Scanner class
* boolean function hasNextLine() to see if there another
line in the file.
*/
while ( infile.hasNextLine() ) {
// read a line and put it in an array element
lines[count] = infile.nextLine();

count ++; // increment the number of array elements
with data
} // end while
infile.close();
return count; // returns the number of items used in the
array.
} // end readList()
/*************************************************/
/* This method sorts an array of Strings line by line
* using a simple bubble sort.
*
* The first parameter refers to the array in the main method.

* The second parameter is the number of elements in the
array that
* actually contain data
*/
public static void sortStringArray(String[] a, int count) {
boolean swapped = true; // keeps track of when array
values are swapped
int i; // a loop counter
String temp; // catalyst variable for String
swapping
// Each iteration of the outer do loop is one pass through
the loop.
// If anything was swapped, it makes another pass.
while (swapped) {

// set swapped to false before each pass
swapped = false;
// the for loop is a pass through the array to the second
to last element
for( i=0 ; (i < count-1) ; i++ ) {
// if the two items are out of order
if(a[i+1].compareTo(a[i]) < 0) {
// swap the two items and set swapped to true
temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
swapped = true;

} // end if
} // end for
} // end while
} // end sortStringArray
/****************************************************
**************/
/* This method prints an array of Strings on the screen.
* The first parameter refers to the array in the main method.
The second
* parameter is the number of elements in the array that
actually contain data
*/

public static void displayLines(String[] lines, int count)
{
int i; // loop counter
// iterate the elements actually used
for ( i=0; i < count; i++)
System.out.println(lines[i]);
} // end displayLines()
/*************************************************/
/* This method writes an array of Strings to a text data file.
The first
* parameter refers to the array in the main method. The
second parameter

* is the number of elements in the array that actually
contain data
*/
public static void writeLines(String[] lines, int count)
throws Exception {
// create a File class object and give the file the name
tutorials.txt
File tut = new File("tutorials.txt");
// Create a PrintWriter text output stream and link it to the
file x
PrintWriter outfile = new PrintWriter(tut);
// iterate the elements actually used
for (int i=0; i < count; i++)

outfile.println(lines[i]);
outfile.close();
} // end writeTextArray()
/*************************************************/
} // end class
Key Terms
array length, 7
base address, 6
bubble sort, 21
byte addressable memory, 5

catalyst variable, 22
catch an exception, 26
compareTo(), 18
element, 4
enhanced for statement, 12
exception, 26
exception handler, 26
explicit array declaration, 10
File class, 26
iterate an array, 11
Java text file, 26
lexicographic comparison, 18
linear search, 18

matches(), 18
multi-dimensional arrays, 4
one-dimensional array, 7
PrintWriter class, 27
reference to an object, 7
run-time error, 26
symbol table, 5
throw an exception, 27
transitive property, 21
Unicode UTF-16 text file, 26

Chapter Questions
1. If the first element in an array is an integer, what do we know
about all of the elements in the array?
Why are array elements referred to as subscripted variables?
2. What is the highest index in an array of 20 elements? What is
the lowest index?
3. What is the difference between a linear array and a multi-
dimensional array? How can we represent a
table with rows and columns as an array?
4. How are variables matched with memory locations? What are
other some items that need to be
mapped to specific addresses in a computer’s internal memory?
How is memory numbered in most
computer systems?

5. How does an operating system keep track of where an array is
in memory? What is an array’s base
address? If an array named points of data type int has a base
address of 3000, what is the address of
element points[2]?
6. What are the two parts to declaring and array? What is a
common way of including both parts in the
same Java statement?
7. If an array has a primitive data type, what does each element
of the array contain? If the data type of an
array is an object, what does each element contain? What is
actually in an array of double values in
Java? What is actually in an array of Strings in Java? What
will be printed if we use a variable from a
String array in a print statement, such as System.out.println(
prices[2] ); ?

8. What is another name for an alternate array declaration? How
are values assigned to array elements in
an alternate array declaration? How is the length of the array
determined when using an alternate array
declaration?
9. How is an array passed as a parameter? If an int array is
passed as parameter and we change the value
of an element in the array, what happens in the original array?
How is an individual element of an array
passed as a parameter?
10. What is a good way to initialize all the elements of a large
array with random numbers? What is a good
way to initialize all the elements of a large array with the same
value?
11. What array method can be used to help us determine the size
of an array? How can it be used to iterate

an array?
12. How can we find the sum of the values in a numeric array?
How can we find the average of the values in
a numeric array?
13. How can we find the minimum of the values in a numeric
array? How can we find the maximum of the
values in a numeric array?
14. What does Java’s enhanced for statement do? What does the
integer variable in enhanced for statement
refer to each time through the loop?
15. What two String class methods can we use to see if two
Strings have the same value? Which of these
methods can be used to see if one String comes before another
lexicographically? What are the
meanings of the values that this method returns?

16. How can we implement a linear search of an array in Java?
What advantage is provided by using a
Boolean found variable in a compound condition for a search
loop?
17. How does a bubble sort work? What happens during each
pass in a bubble sort? When does the
algorithm stop making passes in a bubble sort?
18. What happens if we try to swap the values of two variables
with statements like a=b; b=a; ? What is a
catalyst variable? How is a catalyst variable used to swap the
values of two variables?
19. What is the File class used for in in accessing text data files
from a Java application? What can the
Scanner class be used for in accessing text files? What can the

PrintWriter class be used for in accessing
text files?
20. What is an Exception in a Java program? What is a run-time
error? In what two ways can a Java
application deal with exceptions?
Chapter Exercises
1. If the memory space for variables starts at memory location
1000, show what the symbol table
would look based on the following set of declarations:
int count;
double average;
int[] scores = new int[20];
2. Create a NetBeans application that asks the user for five test

scores, then calculates the average
score, the highest score and the lowest score. Your application
should read the five test scores into
an array of integers, and should output a neatly formatted report
to a text file including the scores,
the average, the highest score and the lowest score. Your
program should exhibit good modular
development. Be sure to include the output file with your
NetBeans project folder and lab report.
3. Exercises 1 through 9 at the end of Chapter 4 each ask you to
write a program to print a table of
data or a set of data using console output. Re-write any one of
those programs to send the output
to a data file. Be sure to include the output file with your
NetBeans project folder and lab report.
4. Create a NetBeans application that fills an array with 1,000
random integers, each between 1 and

10. Your program should then perform a frequency count – How
many elements are equal to 1, how
many are equal to 2, etc. for all 10 possible values. Your
program should also calculate the average
of the values. Your application should output a neatly
formatted summary report to a text file with
the summary results, not the entire array. Your program should
exhibit good modular development.
In your lab report, you should describe how the results
compared to what you expected the results
to be.
5. The file enrollments.txt in the files for Chapter 6 is a text file
with each line containing a positive
integer that represents the enrollment in a section of CIS 103.
The highest value is 36. Write a
program to read the data from the file into an array, then

calculate and display the number of
sections, the average class size, the minimum class size, and the
maximum class size.
6. Using the enrollments.txt file mentioned in number 5, above,
count and display the number of full
sections and the percentage of the sections that are full. A
section is full if it contains 36 students.
7. The data structure known as a stack reverses the order of
things put on the stack, like a stack of
dishes – the last item put on the stack will be the first taken off
the stack. The data file months.txt
contains the names of the twelve months in order. Write a
program that works like a stack to read
the data from a file into an array, then write the data to a new

data file in reverse order.
Parallel arrays –described here – are used in exercises 8, 9 and
10. Parallel arrays are two arrays
whose contents are coordinated so that element i in one array is
somehow related to element i in
another array, such as a list of names and phone numbers.
Parallel arrays are not as common as
they previously were, because of the use of objects in modern
programming, such as an array of
person objects with name and phone number properties in the
object. You should use good
modular development in creating your application as you should
in all applications.
8. In this exercise you should create an old fashioned parallel
array program to read data from a file
into two parallel arrays – an array of the names of states and an

array of state capitals. The data file,
named capitals.txt contains a list of states and capitals, with a
state name on one line followed by a
capital name on the next line, such as:
Alabama
Montgomery
Alaska
Juneau
Arizona
Phoenix
Arkansas
Little Rock
Your application should read the state names into one array and

the capital names into a parallel
array. Your code should then ask the user to enter a state and
search the state array for the state.
If the name entered is in the array, then tell the user the name of
the state capital from the parallel
array. If the name entered is not in the array, then tell the user
this.
9. Using parallel arrays, create a quiz asking people to name
state capitals. You should read the data
from the capitals.txt data file into parallel arrays, then randomly
select one of the elements in the
states array and ask the user to enter the name of the capital.
You should then compare the answer
the user entered to the corresponding element in the parallel
array of capitals. Tell the user if the
answer is correct, or, if it is wrong, then tell the user so, and

tell the user the correct answer.
10. The data file careers.txt contains a list of job titles and
average annual salaries on alternating lines in
the file, such as:
Computer and Information Research Scientists
102190
Computer and Information Analysts
80460
Computer Systems Analysts
79680
Information Security Analysts
86170
The file has real data from the US Department of Labor’s May
2013 survey of occupations and
wages. In this exercise you should create two parallel arrays,

one for job and one for salary, and read
data from the file into the arrays – one line into the job array
and then one line into the
corresponding element in the salary array. Your program
should sort the lists in parallel according
to the values in the salary array, with the highest salary first.
Sorting in parallel means that in your
sort, if you swap two elements in the salary array, you must also
swap the corresponding elements
in the job array. Your program should then display the list of
jobs and corresponding salaries on the
screen in a neatly formatted table, with commas in the salaries.
— End of Chapter 2 —

The Java Learning Kit Chapter 5 – Methods and Modular.docx

More Related Content

Similar to The Java Learning Kit Chapter 5 – Methods and Modular.docx

More from arnoldmeredith47041

Recently uploaded

The Java Learning Kit Chapter 5 – Methods and Modular.docx