Introduction to Java
By Paul Baumgarten
[Link]
July 2020 edition
Introduction to Java programming
1. Hello world
For the first few weeks we will use an online service, h ttps://[Link]/ to complete our programming. This will
make it easy for me to monitor your progress in these early lessons. Once we have completed the
introductory activities, we'll spend a lesson getting your personal laptop setup to run Java programs.
Study your first program
Your first program looks like this...
public class Main {
public static void main(String[] args) {
[Link]("Hello world!");
}
}
There is a lot of technical grammar and syntax in this program, given this is supposed to be the "first and
easiest" starting point! Take a close look at the different elements. What do you predict this program will do?
Sign up to [Link]
In your web browser, open [Link] and create a new account using your school Google Account.
Respond to the Google Classroom question where I ask you to inform me of your [Link] username. This will
allow me to monitor your progress.
Create a Java program on [Link]
Find the "new repl" icon and click it.
In the new window that appears, select Java as your
programming language and give your repl project a
meaningful name. Repl will create random names that will be
impossible for you to keep track of otherwise. In the example
below I am suggesting to use a number indicating lesson
number, followed by a brief name for the exercise.
You will notice your first program is actually the default that
repl provides, so nothing to type for this first program. Click
the run icon and see if it behaves the way you predicted.
Modify
Experiment with modifying the sample program. Posit: how might you display multiple lines of messages?
Pair with someone else. Set your partner a multiline message you want them to create.
Discussion
We will discuss the first program as a class, including some of the syntax and grammar involved. You can
safely consider a lot of it as a "boilerplate" that is "just required" for now. Over the coming weeks you will learn
what all the different elements do.
Some immediate things to draw your attention to:
● Java is case sensitive.
[Link] and [Link] are not the same thing!
● Syntax must be precise. Computers are exact tools and can only interpret what you provide according
to set strict rules.
● Most instructions require a set of parenthesis (rounded brackets). Inside those parenthesis go the
parameters. This is the information the instruction requires in order to run. If the instruction requires
multiple parameters, the order of the parameters matters. You would separate each parameter with a
comma.
● When we need to provide text information, we use "quotes" to indicate the start and end of the text.
● The curly braces { } enclose "blocks" of code. They are used to group parts of your program
together. Every opening brace requires a corresponding closing brace.
● Every instruction in Java terminates with a semicolon ; which you can think of as the equivalent to a
full stop.
● The indentation provided is not mandated by Java, but is mandatory by me. Just because this will run
does not mean you should ever do it!
class Main{public static void main(String[] args){[Link]("Hello
world!");}}
● Programmers use indentation to make code more readable. The general rule of thumb:
○ Every time you open a new block with { indent future lines of code.
○ Every time you close a block with } shift your indentation left again.
○ One instruction per line. Once you use a semicolon, move on to a new line.
● In-code comments are critical for readability. Comments are a way for you to add notes to your code
for your future information. They are ignored by Java. There are two ways of adding comments to
your code in Java.
class Main {
public static void main(String[] args) {
// This is a one line comment
[Link]("Hello world!");
}
}
class Main {
public static void main(String[] args) {
/* This is a multiline comment
It will keep going until I close it
like this... */
[Link]("Hello world!");
}
}
● You should also use comments to add links to tutorials or resources that helped you solve a
particular issue as the example below shows. There are two benefits for this…
○ It helps you when you are looking at your code in the future to figure out why you did
something a particular way.
○ It is the academically honest approach to give credit where credit is due. This will be important
for your assessments later. Get in good habits now.
class Main {
public static void main(String[] args) {
// "Not a statement" error fixed via
// [Link]
[Link]("Hello world!");
}
}
For future reference
● Sometimes when referring to Java tutorials online you need to know the version of the Java Runtime
Engine (JRE) you are running as some features have only been introduced in newer versions. The
following is a handy bit of reference code that will advise the version of Java you are running.
class Main {
public static void main(String[] args) {
[Link]("Java version "+[Link]("[Link]"));
}
}
2. Variables & data types
Printing a few messages to the screen is all well and good but not terribly useful. In order to actually compute
anything is going to require the use of variables.
A variable is a named memory location reserved for you to store values under that name. This will allow us to
use the result from one calculation as the input for the next.
In addition to requiring a unique name, variables also require a d ata type. Because computers are far more
capable than the humble calculator, they can store many different types of values into a variable, but for the
programming language to respond correctly it must know what type of data is being stored in that variable.
There are a lot of data types available, and later on you will even create your own, but for now let's consider
some of the most common ones.
Java name Description
boolean A boolean is a type that can only have one of two possible values: t rue or f alse.
int An integer number.
It has 32 bits of memory allocated (we'll get into that later). For now, the significance is
that integers must be between the range of
−2'147'483`648 to +2'147'483'647.
long A "long" integer number.
It has double the memory allocation, 64 bits. The number range permissible is
−9,223,372,036,854,775,808 to +9,223,372,036,854,775,807
float Floating point number which means it is capable of storing decimals. This uses 32 bits
with 1 bit for sign, 8 bit exponent, 23 bits significant figures.
double "Double" precision floating point number meaning it has 64 bits of memory allocated. 1
bit sign, 11 bit exponent, 52 bit significant figures. Be aware that double, rather than
float, is the default for most Java math functions.
String A "string of characters", more easily known as "text".
A variable is created by using the keyword of the data type, followed by a unique name for the variable, finally
(optionally) you can assign it an initial value.
class Main {
public static void main(String[] args) {
int num = 10; // Create integer variable num
[Link](num);
}
}
3. Numbers
Declaring
The following code creates two integers, a and b. Predict the outputs and then test your understanding.
class Main {
public static void main(String[] args) {
int a = 10;
int b = a;
a = 5;
[Link](a);
[Link](b);
}
}
In like manner, declaring doubles looks very similar but the output will be slightly different. Can you predict
the difference?
class Main {
public static void main(String[] args) {
double a = 10;
double b = a;
a = 5;
[Link](a);
[Link](b);
}
}
Arithmetic operations
All the usual arithmetic operations are available for use in Java. Can you determine what all the symbols
represent? Predict f and g in particular.
class Main {
public static void main(String[] args) {
int a, b, c, d, e, f, g;
a = 17;
b = 4;
c = a + b;
d = a - b;
e = a * b;
f = a / b;
g = a % b;
[Link](a);
[Link](b);
[Link](c);
[Link](d);
[Link](e);
[Link](f);
[Link](g);
}
}
Try the above again, but first convert all the data types to float and note the slight differences.
Input numbers
Our program would be far more useful if the user can enter their own numbers instead of needing them
pre-entered into code. To have the program prompt for user input would look like this…
// Import the Scanner object from the [Link] library
import [Link];
class Main {
public static void main(String[] args) {
int a, b, c, d, e, f, g;
// Create a keyboard reading object
Scanner keyboard = new Scanner([Link]);
// Prompt the user & collect their responses
[Link]("Enter value for a:");
a = [Link]();
[Link]("Enter value for b:");
b = [Link]();
// The rest is the same as before
c = a + b;
d = a - b;
e = a * b;
f = a / b;
g = a % b;
[Link](a);
[Link](b);
[Link](c);
[Link](d);
[Link](e);
[Link](f);
[Link](g);
}
}
As you may infer, there is also a k
[Link]() function available if you need it.
Math library
There are a whole range of useful functions in the Math library. Here are some of the more useful ones you
are likely to use.
[Link]( base, exponent ) Perform exponential calculation, base raised to exponent.
[Link]( num ) What is the square root of num?
[Link]( num ) Round num to the nearest integer value
[Link]( num ) Truncate any decimals off of num down to the nearest integer value
[Link]( num ) What is the absolute value of num?
[Link]() Generate a random number between 0 and 1
[Link]( a, b ) Returns the larger of a or b
[Link]( a, b ) Returns the smaller of a or b
[Link] The value of the mathematical constant PI, ie: 3.1415….
Math.E The value of the mathematical constant E, ie: 2.7183….
[Link]( num ) What is the sine value of num? (answers in radians)
[Link]( num ) What is the cosine value of num? (answers in radians)
[Link]( num ) What is the tangent value of num? (answers in radians)
[Link]( num ) What is the inverse sine value of num? (assumes input of radians)
[Link]( num ) What is the inverse cosine value of num? (assumes input of radians)
[Link]( num ) What is the inverse tangent value of num? (assumes input of radians)
[Link]( a, b ) Given sides of length a and b, what is the hypotenuse?
[Link]( r ) Convert r radians to degrees
[Link]( d ) Convert d degrees to radians
Example usage...
class Main {
public static void main(String[] args) {
double a = [Link](2.0, 5.0); // Find the exponent of 2 to the power of 5
[Link](a);
}
}
Problems
The following questions assume you will use variables as the inputs into each problem, so the problems can
recalculate solutions by changing the value assigned to the variable. You should also print the given
information in your answer.
For example, if the question was, “for a given number of minutes, how many whole hours are there?”, the
pseudo code for the solution could look like:
# Input
MINUTES = 310
# Calculation
LEFTOVER_MINUTES = MINUTES % 60
HOURS = (MINUTES - LEFTOVER_MINUTES) / 60
PRINT "In "+ MINUTES +" minutes, there are "+ HOURS +" full hours"
1. For any given number, extract the 10s digit. For example, The tens digit in 1234 is 3.
2. Area of a right angled triangle calculator. Given values for base and height, print the area.
3. For any two digit number, swap the position of the digits. For instance, 79 becomes 97.
4. For any three digit number, print the sum of the three digits. For instance 273 becomes 12 (2+7+3)
5. For any given year, print the century that year belongs to. Remember that 1999 and 2000 were the
20th century, whereas 2001 was the beginning of the 21st century.
6. Given a number representing the number of seconds since midnight, print the time in 24hour clock
format. For example 70500 seconds should print a time of 19:35.
7. Area of a non-right angled triangle calculator. Given values for length a, length b and angle in degrees
C, return the area of the triangle (remember you will have to convert degrees to radians first).
8. For any given values for a, b and c, will provide the solutions to the quadratic formula (you may
assume both solutions are required). Be careful with your order of precedence. Here is an example solution
set for testing: If y=2x^2-4x-10 then the solutions are 3.44949 and -1.44949.
9. Surface area of a sphere calculator given a radius
10. Volume of a cone calculator
11. Work out the Java order of operations by testing the following 3/4+5*2/33–3+8*3 .
4. Strings
A string is the programming term for text. More properly it can be thought of as a string of characters. We've
already used strings whenever we've used the double quote enclosed text in the println() function. We can
also use strings with variables. The string variable in Java is defined with a capitalised String.
The generalised rule of creating a String variable is…
String variableName = "initial value";
That said, Java does not require you to provide an initial value if you choose not to. You can declare and
create the variable without that, and then set the value later. This would be valid…
String variableName;
variableName = "some value";
You only use the String keyword when creating the variable. When changing its value in later code you do not
use the keyword.
The following example will create two String variables. Before coding this, predict what the printed message
will be. Can you identify the one minor thing that you might want to alter before programming it?
class Main {
public static void main(String[] args) {
String name = "Mr Baumgarten";
String message = "Hello" + name + "!";
[Link](message);
}
}
Second prediction: What will be the printed message in this version?
class Main {
public static void main(String[] args) {
String name, message;
name = "Mr Baumgarten";
message = "Hello" + name + "!";
name = "Mr B";
[Link](message);
}
}
Input strings
Like numbers, we can easily prompt the user to enter string information into our program.
import [Link]; // Import Scanner object
class Main {
public static void main(String[] args) {
String name, message;
[Link]("What is your name?");
Scanner keyboard = new Scanner([Link]); /
/ Create keyboard reading object
name = [Link](); / Read a line from the keyboard
/
message = "Hello, "+name+"!";
[Link](message);
}
}
String functions
There are a number of different functions available for you to inspect and manipulate the content of strings.
Some are more intuitive than others. Take the time to try each of these out and determine what they do and
post your responses to the relevant Google Classroom assignment.
import [Link];
class Main {
public static void main(String[] args) {
Scanner keyboard = new Scanner([Link]);
[Link]("Type something:");
String s1 = [Link]();
// The .length() function
[Link]( [Link]() );
// The .charAt() function
[Link]( [Link](0) );
[Link]( [Link](1) );
[Link]( [Link](2) );
// The .charAt() with a twist. This may take some figuring out
[Link]( [Link](0) + 0 );
// .indexOf() and .lastIndexOf()
[Link]( [Link](" ") );
[Link]( [Link](" ") );
// .substring() - try changing the numbers.
[Link]( [Link](8, 12) );
// .replace()
[Link]( [Link](" ", "#") );
// Hopefully these last two are intuitive
[Link]( [Link]() );
[Link]( [Link]() );
}
}
Test your understanding of these functions by completing the problem set.
Problems
1. Given a string, return a new string made of 3 copies of the last 2 chars of the original string. Assume
the input string length will be at least 2 characters. For example, the string “Hello” should result in “lololo”.
2. Given a string, return the string made of its first two chars, so the String “Hello” yields “He”. If the
string is shorter than length 2, return whatever there is, so “X” yields “X”, and the empty string "" yields the
empty string "".
3. Given a string, return a version without the first and last char, so “Hello” yields “ell”. The string
length will be at least 2.
4. Given 2 strings, return their concatenation, except omit the first char of each. The strings will be at
least length 1. For example, strings “Hello” and “There” should result in “ellohere”.
5. How would you print the following? All "good" people should come to the aid of their
country. (ie: you’ll have to research how to print the double quote character)
6. Write code that will produce the following printout using only a single println().
Hello
Hello again
7. Write code that will produce the following printout.
A backslash looks like this \, ...right?
8. What is output by the following?
String pq = "Eddie Haskel";
int hm = [Link]();
String ed = [Link](hm - 4);
[Link](ed);
10. Given a string input of a date in format, d
d/mm/yyyy, print an output advising the current day, month
and year number.
Casting between data types
Because variables in Java are strictly typed, a common task is to
need to convert the value in one variable to that of another type.
For instance, if we have a String that contains the text of a number,
we need to convert it to a numeric variable before we can perform
calculations on it. This process of conversion is known as casting.
The table shows you how to cast between the common data types.
For example… to convert a number that is contained within a string to
a long, so you can perform a calculation on it, and then convert it
back again…
class Main {
public static void main(String[] args) {
String s1 = "12345";
long a = [Link](s1);
a = a * 2;
s1 = [Link](a);
[Link](s1);
}
}
5. If
The power of programming comes from letting the computer do work for us. To do that it needs to make
decisions. We can have Java make decisions on the basis of comparing one value to another. These
comparisons should always generate a boolean result, that is true or false. We can then instruct Java to
execute code based on whether a comparison is true or false.
Numeric comparisons
To compare the values of any numeric values or variables, the following operators exist:
if (a == b) { // ... is equal to
if (a != b) { // ... is not equal to
if (a > b) { // ... greater than
if (a >= b) { // ... greater than or equal to
if (a < b) { // ... less than
if (a <= b) { // ... less than or equal to
Note that a and b can either be a value or a variable, and that the surrounding set of parenthesis is required.
For example...
boolean result;
int a = 10, b = 3;
result = ( a == b );
[Link]( result );
result = ( a != b );
[Link]( result );
result = ( a > b );
[Link]( result );
result = ( a < b );
[Link]( result );
Take careful note of the difference in punctuation between setting a value to a variable, and comparing two
values! Setting a variable to a given value uses the single equal sign =
whereas comparing two values or
variables uses the double equal sign ==.
String comparisons
There are a variety of functions suitable for comparing the values of strings as the following illustrates:
[Link] keyb = new [Link]([Link]);
[Link]("Type string 1: ");
String s1 = [Link]();
[Link]("Type string 2: ");
String s2 = [Link]();
[Link]( [Link](s2) ); // also [Link](s1, s2)
[Link]( [Link](s2) );
[Link]( [Link](s2) );
[Link]( [Link](s2) );
[Link]( [Link](s2) );
[Link]( [Link]() );
You will notice they all return boolean results except .compareTo() which returns an integer result indicating
how closely the two strings compare or differ. Specifically, it will return:
● zero when string values match
● negative when the parent object (s1) is alphabetically before the parameter (s2)
● positive when the parent object (s1) is alphabetically after the parameter (s2)
(The size of the positive or negative number indicates the value of the number of characters different. For
example "a".compareTo("d") will return -3 because the letter a is three values before the letter d)
Multiple comparisons
Boolean logic can be used to daisy chain multiple comparisons into one instruction.
● The AND operator is the double ampersand &&.
● The OR operator is the double pipe ||.
● The NOT operator is the exclamation !.
The following is a valid example:
int a = 13;
int b = 4;
int c = 10;
boolean result;
result = ( (a > b) && (a < c) );
result = ( (a > b) || (a < c) );
result = ( (a != b) && (a < c) || (b == c) );
Where you are uncertain about order of precedence, it is recommended to use an additional set of
parentheses to enforce your intended outcome.
Having determined how to have Java compare values one against the other, we can now build on that by
using if statements to selectively execute code based on the result of the comparison.
The overall syntax is:
if ( condition ) {
doSomething;
doSomething;
} else if ( condition ) {
doSomething;
doSomething;
} else {
doSomething;
doSomething;
}
Let's make a simple example:
import [Link];
class Main {
public static void main(String[] args) {
boolean result;
Scanner keyb = new Scanner([Link]);
[Link]("a: ");
double a = [Link]();
[Link]("b: ");
double b = [Link]();
if ( a == b ) {
[Link]("a and b are equal");
} else if (a < b) {
[Link]("a is less than b");
} else {
[Link]("a is greater than b");
}
}
}
Problems
1. Create a program that asks for two people's names and their ages. Print the name of the oldest
person (or if they might be twins?!)
Person 1 name: Jack
Person 1 age: 16
Person 2 name: Mary
Person 2 age: 17
Mary is older
2. Create a program that will input three integers and print the highest of them.
3. Suppose you ask the user what the temperature is. Create a program that will respond as follows:
If the temperature is between 20 and 27, say that it is "Just right"
If the temperature is below 20, say that it is "too cold"
If the temperature is above 27, say that it is "too hot"
4. Create a program that allows the user to input the sides of any triangle, and then print True/False to
indicate if the triangle is a Pythagorean Triple or not.
5. Create a program that will input two Strings and alert if they have the same last character.
6. Write a program to check if a triangle is equilateral, isosceles or scalene. An equilateral triangle is a
triangle in which all three sides are equal. A scalene triangle is a triangle that has three unequal sides.
An isosceles triangle is a triangle with (at least) two equal sides.
7. Create a program that will input three Strings and will print them out into alphabetical order.
String 1: hi
String 2: there
String 3: have a great day
have a great day
hi
there
6. Loops
Looping is more technically known as iteration or repetition. It is where we ask Java to repetitively execute a
block of code while a condition is being met. There are two main types, the w hile loop a
nd the for loop.
The basic syntax of a "while loop" is as follows:
while ( comparison ) {
instructions();
}
The following is a simple example of the while() loop that will count from 0 to 9.
int a = 0;
while ( a < 10 ) {
[Link]( a );
a = a + 1;
}
The basic syntax of a "for loop" is:
for ( initialization ; comparison ; iterationIncrementer ) {
instructions();
}
Here is the for() loop counting from 0 to 9
for (int i=0 ; i<10 ; i=i+1 ) {
[Link]( i );
}
Problems
1. Write a program which will find all such numbers which are divisible by 7 but are not a multiple of 5,
between 2000 and 3200 (both included).
2. Write a program which iterates the integers from 1 to 50. For multiples of three print "Fizz" instead of
the number and for the multiples of five print "Buzz". For numbers which are multiples of both three
and five print "FizzBuzz".
3. Write a program to construct the following pattern, using a nested for loop.
*
* *
* * *
* * * *
* * * * *
4. The fibonacci sequence is created by summing the two previous numbers together. The first 10
numbers in the sequence are 1, 1, 2, 3, 5, 8, 13, 21, 34, 55.
Use a loop to create a program that will calculate the n-th number of the sequence. For instance, if
asked for the 8th number, it should provide the answer of 21.
5. Write a program to check the validity of password input by users. The rules for a valid password are:
At least 1 letter between [a-z] and 1 letter between [A-Z].
At least 1 number between [0-9].
At least 1 character from [$#@].
Minimum length 6 characters.
Maximum length 16 characters.
6. Write a program that will allow a user to input his name. The prompt and input data would look
something like this:
Please enter your name: Peter Ustinov.
Using a for-loop and the String method substring() print the reversal of the name. For example, the
name Peter Ustinov would be: vonitsu retep. Ensure that the printout is in all lower-case.
7. Create a simple number guessing game. The program needs to work as follows:
The computer picks a random number and stores it as a secret number (random numbers help)
Ask the user to guess the number
If the guess is higher than the secret number, print the message "too high"
If the guess is lower than the secret number, print the message "too low"
If the guess is correct, print the message "you are correct!"
To use a while loop to keep the game going until the correct guess has been made
Bonus points: Can you keep count of the number of guesses it takes the player to get it correct?
7. Arrays
Note: In this section I will limit discussion to using arrays of primitive data types of one dimension. Two
dimensional arrays, and arrays of custom objects will be addressed later.
So far we've talked about numbers, strings and Booleans where each variable just stores one thing at a time.
What happens if we want to manage a shopping list? or a list of students in my class... and we want to be
able to manage that entire list of things together? Java allows us to do this by creating arrays. So instead of
creating variables student1, student2, student3, etc, we can have one variable called students and use that in
our code.
There are two main types of arrays in Java. The classic static array has a size that is fixed at declaration.
Once the memory space has been allocated, they can not be resized. The other type is known as ArrayLists
and is a dynamically resizable construct available when the size of the array is not known in advance. For
now, we will focus on the static array.
Why use arrays?
It might be easiest to think of an array as the technical term for a list. It allows us to store a set of values all
assigned to one variable identifier. They are very useful when we have a collection of values that are similar in
nature and that will be processed in the same manner.
For example, what if we are supposed to keep records of test scores obtained by a group of students.
Without a list we could use something like the following:
double score1 = 59.0;
double score2 = 92.0;
double score3 = 85.0;
double score4 = 61.0;
double score5 = 78.0;
To then calculate the highest, lowest and average score? That would look like...
double highest = score1; // Initially set highest to the first value
if (score2 > highest) { highest = score2; }
if (score3 > highest) { highest = score3; }
if (score4 > highest) { highest = score4; }
if (score5 > highest) { highest = score5; }
double lowest = score1; // Initially set lowest to the first value
if (score2 < lowest) { lowest = score2; }
if (score3 < lowest) { lowest = score3; }
if (score4 < lowest) { lowest = score4; }
if (score5 < lowest) { lowest = score5; }
double average = (score1 + score2 + score3 + score4 + score5) / 5
[Link]("The highest score was "+highest+", the lowest was "+lowest+" and
the average was "+average);
You can see that the whole process will quickly get very tedious. There will be a lot of
copy-and-pasting-and-renaming of code going on. Imagine if we needed to scale this up to 100 students for
an entire year group? Unmanageable and error prone!
Enter the array!
The equivalent task using an array might look like
double[] scores = {59.0, 92.0, 85.0, 61.0, 78.0};
double highest = scores[0]; // Initially set highest to the first value
double lowest = scores[0]; // Initially set lowest to the first value
double total = 0; // Running total for calculating the average later
for (double val : scores) { // Iterate through each `value` within `scores`
if (val > highest) {
highest = val;
}
if (val < lowest) {
lowest = val;
}
total = total + value;
}
double average = total / [Link];
[Link]("The highest score was "+highest+", the lowest was "+lowest+" and
the average was "+average);
Our scores array can easily contain 1000s of records and we would not have to change a single line of the
calculations code! Arrays can be extremely useful!
Declaring an array
We'll start by looking at the static array. There are two methods to declare a static array.
Method 1
int[] primes = new int[10];
primes[0] = 1;
primes[1] = 2;
primes[2] = 3;
primes[3] = 5;
primes[4] = 7;
primes[5] = 11;
primes[6] = 13;
primes[7] = 17;
primes[8] = 19;
primes[9] = 23;
Method 2
int[] primes = {1,2,3,5,7,11,13,17,19,23};
Iterating arrays
There is a special "for loop" for iterating through an array. The following two loops produce the same output.
The for loop you are used to…
for (int i=0; i<[Link]; i++) {
[Link]( primes[i] );
}
The special for loop for arrays...
for (int item : primes) {
[Link]( item );
}
Functions and properties of arrays
● These functions require you to i
mport [Link];
Check if two arrays are filled with matching values
if ( [Link]( primes, other )) {
[Link]("The two arrays match");
}
Length of an array
int len = [Link];
Sort an array in ascending order
[Link]( primes );
Create a string listing the contents of the array
// will output: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]
[Link]( [Link]( primes ));
Problems
For these problems, I used [Link] to create 2 sets of unsorted random
integers, and h
ttps://[Link]/random-words to create the list of words. You can use my sets
below, or create your own.
int[] numbers1 = {936, 489, 845, 959, 550, 687, 776, 604, 244, 694, 546, 322, 753, 1000,
294, 18, 405, 271, 550, 759};
int[] numbers2 = {989, 463, 472, 730, 1, 419, 591, 185, 884, 318, 547, 222, 694, 71, 468,
451, 310, 407, 498, 132};
String[] words1 = {"wave", "room", "gentle", "search", "true", "board", "fowl", "upbeat",
"name", "hug", "vengeful", "observe"};
Exercises:
1. Given an array of integers, sum all integers and find the average value.
2. Given an array of integers, find the maximum and minimum number in the array.
3. Given an array of strings, print all items with length of at least 5 characters, and where the first and
last character do not match.
4. Given an array of integers, print any duplicates in the array (ie: values that appear more than once).
5. Given two arrays of integers, print any values that exist in both arrays.
6. Given two arrays of integers, print any values that only appear in one array.
7. Given an array of integers, reverse the array and print the result. ie: The array { 6, 21, 10, 13 } should be
converted to { 13, 10, 21, 6 }. * *CHALLENGE**
8. Given an array of integers, sort the array into ascending order and print the result (without using
[Link]()). * *CHALLENGE**
8. Functions
We have been using a lot of various functions that exist within Java already but haven't created any of our
own, other than using m ain().
Functions are a useful way of abstracting complexity in our project. Functions will generally require one or
more inputs, and then provide a returning result.
Functions are blocks of code that you assign a name to. You can use that name to easily run that code again
whenever you need.
Functions are very useful for separating common tasks out from your main code. It allows you to avoid
repeating yourself all the time which makes your code easier to maintain. Tasks like reading from a file,
saving to a file, etc are all ideally suited to being chopped off into a separate function.
Think of an Icecreamary
Lots of different possible flavours, toppings, numbers of scoops, choice of waffle or regular cone, etc.
One person could order a double scoop of chocolate fudge and vanilla on a waffle cone, where as the
next customer might ask for a cup of raspberry sorbet with nut sprinkles. The salesperson calculates
the cost for each and advises each customer on the price. In order to calculate that cost there are a
number of inputs (number of scoops, type of cone, etc) and an output (price). How it is actually
calculated is not important, provided it is trustworthy and works reliably.
In this way a function can provide a "black box" model through which we can create an abstraction to
represent our problem.
Programmers need to know how to:
a. use other peoples abstractions and
b. be able to create their own.
For now, the abstraction we are concerned with is creating a function.
This is an example function that will convert the mathematical function A = πr2 to Java:
public static double getAreaOfCircle( double radius ) {
double val = [Link] * radius * radius
return val;
}
Let's look at this bit by bit. Don't code it yet.
● public - is known as an access modifier. We'll discuss the role of access modifiers more when we
look at classes. For now just make sure you specify it when you create a function.
● static - again understanding the function of this keyword will be further explained in the classes
section.
● double - this is the data type that the function will return. Functions can provide a value back to the
code that calls it, and the function must specify what type of data it will return.
● getAreaOfCircle - this is the name we are assigning the function.
● (double radius) - immediately following the name of the function is the list of parameter values we
will expect to be supplied to the function. In this case, we are expecting one value of type double,
which we will refer to internally within the function via the name radius. This name does not have any
relation to any variable that may be used outside the function. To accept more than one parameter,
we comma separate them.
● { .... } - The code to be executed by our function is enclosed within the braces.
● return - This is where we specify the value to be returned to the code that called the function. Once
Java encounters a return statement, it will exit the function regardless of any further code you may
have written. Your function must provide a return value unless you specify the function data type as
void (like we do with main).
Your 1st function
import [Link];
class Main {
public static double getAreaOfCircle(double radius) {
double val = [Link] * radius * radius;
return val;
}
public static void main(String[] args) {
Scanner keyb = new Scanner([Link]);
[Link]("Radius? ");
double r = [Link]();
double a = getAreaOfCircle(r); // Run our new function
[Link](a);
}
}
Your 2nd function
This next example illustrates two ideas:
● Creating a function that requires two parameters.
● Using a function we created elsewhere. We will reuse our previous areaOfCircle function without
having to rewrite it. This is one of the coolest reasons to write functions, we can start reusing
previous code!
import [Link];
class Main {
public static double getAreaOfCircle(double radius) {
double val = [Link] * radius * radius;
return val;
}
public static double getAreaOfCylinder(double radius, double length) {
return length * areaOfCircle(radius);
}
public static void main(String[] args) {
Scanner keyb = new Scanner([Link]);
[Link]("Radius? ");
double r = [Link]();
[Link]("Length? ");
double l = [Link]();
double a = getAreaOfCylinder(r, l); // Run our new function
[Link](a);
}
}
User input validation functions
Functions can be a handy way to require the user to comply with our wishes to enter information in a
particular manner.
By the time we write the checking/validation code and the loop, user input checks can run to several lines,
and it would be quite common within a simple program to want to validate the same style of input several
times. Functions make a handy way to reuse code for this purpose.
For instance, study the following and predict its behaviour before coding it.
public static String confirm( String prompt ) {
String response = ""
[Link] keyb = new [Link]([Link]);
while (true) { // what will `while (true)` do?
[Link]( prompt );
response = [Link]();
if ([Link]("y") || [Link]("n")) {
return response; // note the `return` is not at the end!
} else {
[Link]("Only 'y' or 'n' are accepted. Please try again.");
}
}
}
Problem set for functions
1. Create a function getAreaRightAngleTriangle(base, height) that returns the calculated area.
2. Create a function getAreaTriangle(base, height, angle) that returns the calculated area for a
non-right angled triangle (remember you will need to convert the angle to radians before using it with
the sine function).
3. Create a function pythagoras(a, b) that returns the length of the side c for a pythagorean triangle.
4. Create a user input validation function, i nputDate() that requires the input of a date in the
dd/mm/yyyy format. Bonus points if you ensure that the dd, mm and yyyy values make sense (ie: day
should be between 1 and 31).
5. Revisiting your array skills, create a function, a
verage(data) that receives an array of integers and
returns the average.
6. Create a function indexOf(data, searchFor) that receives an array of integers, and a search value,
and returns the index number at which the search term is found within the array, or -1 if it does not
exist. For example, if given the array { 10, 13, 17, 21, 25 } and the search term 17, the function should
return 2.
9. Exceptions
An exception is a critical event that should be foreseeable by a programmer that Java expects you to
program a response to. Examples situations include:
● Attempting to divide by zero
● Attempting to cast a string to an integer when it doesn't contain a number
● Attempting to read a file beyond its end point
● Attempting to write to a file that is read-only, or has a full disk, or has other issues
● Attempting to access an array beyond the number of elements it contains
Let's make an example:
import [Link];
public class Main{
public static void main( String args[] ) {
Scanner keyb = new Scanner([Link]);
// First input
[Link]("Input a number:");
String s1 = [Link]();
int i1 = [Link]( s1 );
// Second input
[Link]("Input another number:");
String s2 = [Link]();
int i2 = [Link]( s2 );
// Perform division
int result = i1/i2;
// Output result
[Link](result);
}
}
The above code will compile and execute just fine until....
● What happens if you enter "ten" as one of the inputs?
● What happens if you enter "0" as the second input?
The first will give you the message, Exception in thread "main" [Link].
The second should give you the message, E xception in thread "main"
[Link]: / by zero
Java expects us to catch these exceptions so our program can deal with them gracefully instead of causing
the program to fail.
We do this by adding the try / catch construct to our program.
The general rule looks like…
try {
// do something that could generate an error
} catch (Exception e) {
// code how to respond to an error
}
The following illustrates how to fix it through the simple use of try and catch.
import [Link];
public class Main{
public static void main( String args[] ) {
Scanner keyb = new Scanner([Link]);
try {
// Input 1st number
[Link]("Input a number:");
String s1 = [Link]();
int i1 = [Link]( s1 );
// Input 2nd number
[Link]("Input another number:");
String s2 = [Link]();
int i2 = [Link]( s2 );
// Perform division
int result = i1/i2;
// Output result
[Link](result);
} catch(Exception e) {
[Link]("An exception happened.");
[Link]("Exception type: "+[Link]().toString());
[Link]("Message: "+[Link]());
}
}
}
A better solution is to check for the type of exception so a more meaningful message can be given to the
user.
import [Link];
public class Main{
public static void m
ain( String args[] ) {
Scanner keyb = n ew Scanner([Link]);
try {
// Input 1st number
[Link]("Input a number:");
String s1 = [Link]();
int i1 = [Link]( s1 );
// Input 2nd number
[Link]("Input another number:");
String s2 = [Link]();
int i2 = [Link]( s2 );
// Perform division
int result = i1/i2;
// Output result
[Link](result);
} catch(NumberFormatException e) {
[Link]("An input could not be converted to an integer");
} catch(ArithmeticException e) {
[Link]("You attempted to divide by zero");
} catch(Exception e) {
[Link]("An unknown exception happened.");
[Link]("Exception type: "+[Link]().toString());
[Link]("Message: "+[Link]());
}
}
}
To use this second method, we need to know the individual exception types. This is more work but it allows
for a more precise response to the error.
Not sure what the likely exceptions are called? The simple way is to not catch them, then run your code so as
to generate the exception, and then Java will tell you the exception names!
Finally, a more complete solution would be to actually check for exceptions at each point they could occur
and to provide the user a way to fix their inputs if possible.
The following shows this.
import [Link];
public class Main{
public static void m
ain( String args[] ) {
Scanner keyb = n ew Scanner([Link]);
int i1, i2;
// Input and convert first number
while (true) {
try {
[Link]("Input a number:");
String s1 = [Link]();
i1 = [Link]( s1 );
break; // break out of the while loop
} catch (NumberFormatException e) {
[Link]("Not an integer. Please try again.");
}
}
// Input and convert second number
while (true) {
try {
[Link]("Input another number:");
String s2 = [Link]();
i2 = [Link]( s2 );
break; // break out of the while loop
} catch (NumberFormatException e) {
[Link]("Not an integer. Please try again.");
}
}
// Perform division
try {
int result = i1/i2;
[Link](result);
} catch (ArithmeticException e) {
[Link]("Can not divide by zero");
}
}
}
You can see here that using a function would be the better way to input the number and convert it to an
integer with the try/catch. It would obey the rule of DRY - don't repeat yourself.
10. Files
Reading and writing files in Java is a bit problematic. It is far more complicated than it needs to be. A
considerable part of the problem is that as soon as you start searching for anything to deal with file handling
in Java, you will quickly encounter a lot of different ways of doing it. Just to prove the point, these are all valid
yet different ways to read files in Java:
● [Link]() - reads in one character at a time, without any buffering. It’s meant for
reading text files.
● [Link]() - reads an entire line at a time,
● [Link]() - reads in one byte at a time, without any buffering. While it’s
meant for reading binary files such as images or audio files, it can still be used to read text files.
● [Link]() - reads a set of bytes all at once into an internal byte array
buffer
● [Link]() - The Files class is part of the new Java I/O classes
introduced in jdk1.7. It only has static utility methods for working with files and directories.
● [Link]() - The Files class is part of the new Java I/O classes
introduced in jdk1.7. It only has static utility methods for working with files and directories.
● [Link]() - The Files class is part of the new Java I/O classes introduced in
jdk1.7. It only has static utility methods for working with files and directories.
● [Link]() - can be used to read from files or from the console (user input)
● [Link]() – Apache Commons
● [Link]() – Google Guava
Which method is "most" correct? Which method do you use when?
To be honest, at this point in your programming journey, don't worry too much about speed or memory
efficiency issues, find a method that seems "logical" to you and stick with it.
If you really want to learn about any of the above methods that I won't discuss here, check this good
resource, [Link]
The following are some simple "recipes" I suggest you use to get started.
Reading a text file
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class Main {
public static void main(String [] args) {
try {
String fileName = "[Link]";
// Open the file
File file = new File(fileName);
// Load the content of the file assuming UTF-8
List<String> dataList = [Link]([Link](),
StandardCharsets.UTF_8);
// Convert the list to an array
String[] dataArray = [Link]();
// Use the array like normal
for(String line : dataArray) {
[Link](line);
}
} catch (Exception e) {
[Link]([Link]());
}
}
}
Writing a text file
import [Link];
import [Link];
import [Link];
import [Link].*; // import it all
import [Link].*; // import it all
public class Main {
public static void main(String [] args) {
Scanner keyb = new Scanner([Link]);
String[] data = new String[10];
for (int i=0; i<10; i++) {
[Link]("Type line #"+i+":");
data[i] = [Link]();
}
try {
String fileName = "[Link]";
// Open the file
Path path = [Link](fileName);
// Convert array to list
List<String> dataList = [Link](data);
// Write to file
[Link](path,dataList,[Link]());
} catch (Exception e) {
[Link]([Link]());
}
}
}
Folder walk
If you want a list of files in a folder, Java can help you out with that too.
// From: [Link]
import [Link];
public class Main {
public static void walk( String path ) {
File root = new File( path );
File[] list = [Link]();
if (list == null) return;
for ( File f : list ) {
if ( [Link]() ) {
[Link]( "Dir:" + [Link]() );
walk( [Link]() );
}
else {
[Link]( "File:" + [Link]() );
}
}
}
public static void main(String[] args) {
walk("c:\\" );
}
}
Problems
1. Read a text file into a list of strings, and print out the number of lines in the file.
2. Ask the user for the name of a file they'd like to create. Using a while loop, keep ask the user to type
an input and only stop when they enter an empty input. Save all the lines entered as the content of the
file.
3. Read a list of strings from a text file. Tell the user how many lines there are and ask them to enter a
line number indicating one they would like to read. Print just the content of that line to the user.
4. Read a list of strings from a text file. Tell the user how many lines there are and ask them to enter a
line number indicating one they would like to change. Prompt the user for the new content of the
relevant line. Write to the file the new list of strings.