Initial Tools Setup

Getting the JDK

Next, you will need to download the Java Development Kit (JDK). We will use the latest long-term support release, JDK 21, but any version newer than JDK 11 is fine too.

JDK for Windows

Go here to download JDK 21 for Windows. Click the download link next to “x64 Installer”. Run the downloaded program to install the JDK on your computer.

Updating Path for Windows

Next, Windows users will need to update their computer’s Path variable so it knows about the Java compiler you installed. Go to:

C:\Program Files\Java\jdk-21\bin

Copy the full path location.

(If you have a different version of the JDK, you may find a jdk folder with a different number. That’s fine.)

Then, press the Start Windows icon and type “environment variables”. You should see an option that says, “Edit the system environment variables.” In the popup dialog, select “Environment Variables…”

Under “System variables”, select “Path” and then click “Edit”. In the resulting dialog, click “New”.

Paste in the full address of the JDK (something like C:\Program Files\Java\jdk-21\bin). Press OK to finish adding to the path, then OK two more times to dismiss the other two dialogs.

Un-hiding file extensions

Windows will automatically hide extensions of known file types, like .java or .txt. This can sometimes lead to mistakes where it looks like a file is saved as something like Hello.java, but it is actually saved as Hello.java.txt. I highly recommend changing your settings so you can see these file extensions.

Press the Windows Start button, type Control Panel, and hit Enter. Click “Appearance and Personalization” and then “File Explorer Options”. Click “View” in the resulting dialog. Find the option that says “Hide extensions for known file types”. Uncheck that option, and click “Apply”.

JDK for macOS

Go here to download JDK 21 for macOS. Click the download link next to “ARM64 DMG Installer”. From either the browser Downloads window or the File browser, double click the .dmg file. This will open a Finder window with the “JDK 21.pkg” icon – double-click that to start the isntallation.

Note: if you have an older x64 version of macOS, you will want to use that download link instead.

VS Code

We will use the VS Code text editor to develop and run our Java programs. If you don’t already have VS Code installed, you can download it here. Click the download button associated with your operating system and install the downloaded file. When you install it, I recommend selecting the “Open with code” action for both files and directories.

VS Code extensions

There are several VS Code extensions associated with Java programs – namely, the “Extension pack for Java” and “Java by Red Hat”. We will not use either of these extensions in CIS 200 in order to focus on working with the terminal and the basics of how Java programs are compiled and run. You are welcome to install whatever extensions you want on your own computer, but make sure you test your programs with javac and java from the terminal (as that is how they will be graded).

Folder structure

In order to practice good organization, we will use a particular folder structure in CIS 200:

On the first day of class, you will clone a GitHub repository that contains the following folder structure:

- cis200repo
    - tutorials
    - labs
    - projects

We will use this repository for all class work. When you start on an assigned tutorial, lab, or project, you will navigate inside the corresondping tutorials, labs, or projects folder and create a new folder for that assignment. (Individual assignments will give more details on naming requirements.) Inside your new assignment folder, you will create the files needed for that assignment.

I recommend that you store the top-level cis200repo folder on your One Drive to be able to easily access it from multiple locations, but you are welcome to store it anywhere.

Using VS Code

VS Code is a text editor designed for programming. You can use VS Code for lightweight development in many programming lanugages.

Opening VS Code

To open VS Code, navigate in a file explorer to the folder you wish to open (most likely, it will be cis200repo). Right click the folder and select “Open with Code”.

Alternatively, you can open VS Code as you would other applications. It will automatically open to the last folder you worked with, which will likely be cis200repo. If it is not opened to the correct folder, you can choose File->Open Folder and select your folder that way.

Parts of VS Code

The VS Code user interface includes:

• A text editor display for a current document in the upper-right. There can be multiple document tabs open at once.
• The solution explorer on the left side, which shows all the files and subfolders within the currently open folder.
• A terminal display at the bottom, which is where we will type the instructions for compiling and running our programs. By default, the terminal opens to the same top-level folder as is opened in the solution explorer.

Here is an example:

If the solution explorer does not automatically appear, you can click the icon that looks like sheets of paper in the upper left. If the terminal doesn’t automatically appear, you can choose View->Terminal.

Creating a new subfolder

To create a new subfolder, go to the solution explorer and right-click on what you want to be the containing folder. Select “New Folder…” and enter the name of the folder. For example, I could create the tutorial1 subfolder in tutorials by entering tutorial1 as the name:

If an outer folder only contains one subfolder, then VS Code will abbreviate the display (as in tutorials\tutorial1). If I added a tutorial2 subfolder inside tutorials, it would display:

Creating a new file

To add a new file, go to the solution explorer and right-click on what you want to be the containing folder. Select “New File” and type the name of your new file (including the extension). For example, here is what I see after creating the file Tutorial1.java inside the tutorial1 folder:

Notice that the new file is opened automatically in the text editor.

Using the terminal

A side goal of this class is for students to become more comfortable with using the terminal. With practice, you will find that you are faster at navigating folders, creating files/folders, compiling/running programs, using tools stuch as git, etc. using the terminal than you are using a GUI. Familiarity with a terminal is especially useful in system administration and web development.

We will use the integrated terminal to compile and run our Java programs, as well as to add/commit/push our changes to our GitHub repository.

If the terminal isn’t already displayed at the bottom of VS Code, you can open it with View->Terminal. It will automatically open to the top-level folder in the solution explorer.

Common terminal commands

Here is a summary table of the most common terminal commands for this course:

Other terminal tips

When you are typing a directory name or file name in the terminal, you can type a few letters and hit Tab – the terminal will attempt to autocomplete the rest of the name.

To recall a command you recently typed in the terminal, you can use the up or down arrows. This saves you from typing the same commands over and over.

Opening the terminal to a subfolder

You can open a new terminal to a subfolder by right-clicking the folder in the solution explorer and selecting “Open in integrated terminal”.

Using git

GitHub account

First, you will need to create a GitHub account here. If you already have one, you can use your existing account.

git installation

You will likely already have a command-line version of git installed on your machine. To check, open a folder in VS Code, display the integrated terminal, and type:

git --version

You should see a version number printing out. If you see that, git is already installed.

If you see an error that git is unrecognized, then you will need to install it. Go here to download and install the latest version.

Windows users may need to add the git.exe location to the system Path environment variables. Most likely, git.exe will be installed to C:\Program Files\Git\bin. Check this location, copy its address, and type “Environment variables” in the Windows search. Click “Environment Variables” and find “Path” under System variables. Click “Edit…”. Verify that C:\Program Files\Git\bin (or whatever your git location) is the last item listed. If it isn’t, add a new entry for C:\Program Files\Git\bin.

Clone class repository

On the first day of class, you will create your initial GitHub repository for CIS 200 and clone it to a “cis200repo” folder on your One Drive. You shouldn’t need to clone your class repository again after that unless you want to store it in a different location.

In the case that you DO want to re-clone your repository, go to your GitHub repository in a browser. Click the green “Code” button and then click the copy icon next to the URL name. This will copy the URL of your GitHub repository.

In a File Explorer, navigate to where you want to store your class work. Create a new folder called “cis200repo”. Right-click that new folder and select “Open with Code”.

Then open the Terminal within VS Code by selecting “Terminal->New Terminal”. The terminal should automatically display the empty cis200 folder you just created.

Clone your GitHub repository to your new, empty cis200 folder by typing in the terminal:

git clone {repository-url} ./

Where {repository-url} is the URL you copied from your GitHub repository (leave off the ``{and}when you insert your URL). The./` tells git to clone the repository to the current directory.

Adding, committing, pushing changes

I recommend that you add/commit/push your changes to GitHub every time you reach a stopping point in development, even if you’re not finished with the assignment. This will both ensure that you have a backup of your work as well as create a snapshot of your current progress that you can revert back to if you make other unwanted changes.

First, be sure that all your work is saved. All unsaved changes are ignored by git, and won’t be added to your remote repository (and by extension won’t be submitted as part of your assignment). Before adding/committing/pushing, be sure to save all your files (File-Save or Ctrl-S). Make sure none of the open file tabs have a solid circle next to the file name – this is an indication that they are unsaved.

Once everything is saved and you are ready to commit your changes, type the following in the integrated terminal:

git add .

This will add all changes to the current commit. Then type:

git commit -m "descriptive message"

to create a local commit, where “descriptive message” is replaced with a message describing your changes (you DO need to include the quotations). Finally, push your local commit to the current branch:

git push

If you go to your GitHub repository URL, you should see the latest changes.

Compiling and Running

Open folder in terminal

First, open your folder in VS Code and ensure the integrated terminal is displayed.

Next, make sure the path listed in the terminal matches the FULL path (including all subfolders!) to the file(s) you want to compile. You can do this either with the cd command or by right-clicking the correct subfolder in the solution explorer and choosing “Open in integrated terminal”.

Example

Suppose I want to compile my “Example.java” program:

The current path listed in the terminal does NOT match the full path to “Example.java”, as it is missing the labs\example subfolders. I can use cd to change into those two subfolders like this:

Compile your program

To compile a one-file Java program, type in the integrated terminal:

javac Example.java

Replacing Example.java with the name of your Java file. If you get an error that the file is not found, double-check that:

• The path listed in the terminal matches the full path to the Java file
• You spelled the name of the file correctly, including capitalization

If your program correctly, you should see the class file Example.java (or something similar to match the name of your Java file). If you made any mistakes in your program, the copmiler will print error messages describing the problems.

If you want to compile a Java program that has several classes in the same folder, do this instead:

javac *.java

This will compile ALL your classes and will generate class files for every .java file. (NOTE: this compilation command will only work if you have exactly one class that includes a main method in the current folder. We will discuss other compilation options for multiple files later in the semester.)

NOTE: terminal commands interact with the current saved version of a file, NOT with the version that appears in the text editor. If you make changes to a program and then compile it without saving, the compiler will not see any of your recent changes. Before compiling, be sure to save all your files (File-Save or Ctrl-S). Make sure none of the open file tabs have a solid circle next to the file name – this is an indication that they are unsaved.

Running your program

Suppose you just compiled your Example.java program and have the class file Example.class. To run your program, type:

java Example

in the terminal (again, after changing directories to the folder where Example.class is). If you compiled a program with several files, then use the name of the class file that contains the main method.

Java Program Structure

Hello, World program in Java

Here is a very simple Java program that prints out “Hello, World!” to the screen:

public class Hello 
{
    public static void main(String[] args) 
    {
        System.out.println("Hello, World!");
    }
}

This text is stored in the file Hello.java. We will learn much more about what everything means as the course progresses, but for now let’s discuss each line separately:

• public class Hello – this line begins a class in our program. For now, just remember that the name you give the class (in this case, “Hello”) must match the name of the file (in this case, “Hello.java”). Capitalization matters – we could not name the class “hello”.

• { – this bracket opens up the class

• public static void main(String[] args) – this line declares the main method for our program, which is where the program begins. For now, just copy this line into all your programs.

• { – this bracket opens up the main method

• System.out.println("Hello, World!"); – this line prints “Hello, World!” to the console

• } – this bracket ends the main method

• } – this line ends the class

Compiling Java programs

Once you have written a computer program, you need to compile it. This process does two things:

• Checks to see if your program has any errors
• Converts your program into an executable file that the computer can run

To compile your program, open the terminal in VS Code (View->Terminal). In the terminal, you can compile your program like this:

javac Name.java

(where Name.java is the name of your program). For example, to compile the Hello, World program you would do:

javac Hello.java

If your program has any errors, the compiler will print a list of what is wrong and where the problem is. If there are no errors, it will create the file Name.class (where Name is the name of the program file). For example when you compile the Hello, World program it will generate the file Hello.class.

If you get an error saying that the javac command is not recognized, please refer to the Tools guide in chapter 0.

Executing Java programs

After you have compiled your program in the VS Code terminal and generated a class file, then you are ready to run it. In the terminal, type:

java Name

where Name.class is the name of your class file. To run the Hello, World program you would type:

java Hello

to run the program.

Interactive Development Environments (IDEs)

For this class, we will write our programs in the VS Code text editor and compile and run from its terminal. Working with the terminal in particular will be a useful skill in other computer science courses and in the workplace.

However, if you are interested in trying out a more interactive development environment that with additional features such as a debugger, I recommend either IntelliJ or Eclipse.

Comments

A comment is text in your program that is not actually part of the program itself.

It is often useful to add comments to explain what different parts of your program are doing. This can be useful to remind you how certain sections work, and can be helpful explanation to any teammates or coworkers who may not have written the code themselves.

Later, we will learn how to write organized comments called documentation that explain both the structure and purpose of different parts of code.

One-line comments

A one-line comment begins with a //. For example:

//This is a one-line comment

Here, all the text on the line beginning with // is ignored by the compiler.

Multi-line comments

A multi-line comment begins with a /* and ends with a */. For example:

/*This comment spans
 multiple lines */

Here, all text after the /* and before the matching */ is ignored by the compiler, even though this might span a number of lines.

Brackets

We will talk more about the structure of computer programs later on, but for now all your programs should have the following format:

public class Name
{
    public static void main(String[] args)
    {
        //statements, such as printing
    }
}

Again, this program should be stored in the file Name.java. The brackets in programs do not have to be arranged like the example above – there are many different styles that people use.

For example, this is the bracketing style that I prefer:

public class Name {
    public static void main(String[] args) {
        //statements, such as printing
    }
}

Additionally, your program does not have to be spaced like the example above. The following program is also valid Java code:

public class Name
{public static void main(String[] args){
//statements, such as printing
}}

However, this program is much more difficult to read. It is a good idea to always indent (with a tab) every time you open a bracket. When you type the matching closing bracket, do not tab over that line.

Variables

In your programs, you can declare variables that help you store information. These storage devices are called variables because you can vary the information stored there.

Data types

Java is a strongly typed and statically typed programming language. This means that whenever we declare a variable we must give it a data type, and this type cannot change over the course of the program. The data type specifies what kind of information you plan to store in the variable.

Below is a table of common types in Java and their uses:

There are other types in Java, but these are the ones we will use most in CIS 200.

Declarations

You can declare a variable like this:

type name;

Here, type is one of the types in the table above, and name is the name we’re giving the variable. We must follow these rules when we name a variable:

• The name should be a sequence of upper-case letters, lower-case letters, numbers, and underscores
• The first character in the name must be either a letter or an underscore

Here are some examples of variable declarations:

int num;
double val1;
char _letter;
String Name;
boolean check_done;

Variables in Java are case-sensitive. This means that if you change the capitalization in a variable name, then it does NOT refer to the same variable. For example, we can do this:

int num;
int Num;

and num and Num will be two different variables. (Note: this practice is not recommended because it causes confusion.)

Assignments

After we have declared a variable, we can assign it a value. We CANNOT use a variable in any way before it has been declared. A variable assignment looks like this:

name = value;

Here, name is the name of the variable that you declared, and value is the value you’re giving it. The value you assign a variable must have the same type as the variable. (For example, if the variable is an int, then you can’t store a number like 2.34 in it.)

Here are some examples of valid assignments using the variables declared above:

num = 42;
val1 = 3.21;
_letter = 'A';
Name = "Fred";
check_done = true;

Notice that single characters (chars) must be encolosed in single quotes, while strings must be enclosed in double quotes. We can also declare a variable and assign it a value at the same time. For example, we can do:

double pi = 3.14159;

Type casting

We cannot give a value to a variable if it does not have the appropriate type. For example, we cannot do:

//This is illegal!
int num = 2.3;

However, sometimes we want to convert a value to have the appropriate type. We can do this by putting the type we want in parentheses in front of the value. For example:

int num = (int) 2.3;

This statement converts 2.3 into an int, so that num now has the value 2. We can do a similar thing to convert the types of variables:

double x = 6.75;
int y = (int) x;

Now y has the value 6. This conversion of one type to another is called type casting.

Literals

A literal is a constant value of a particular type, written the way it would appear in a program.

Here are some examples of literals of different types:

Notice that character literals must be enclosed in single quotes, and string literals must be enclosed in double quotes.

Operations

Now that we can declare variables and assign them values, we want to be able to perform calculations with them.

Mathematical operations

These operations deal with numerical data (ints and doubles). Here are the mathematical operators that you can use:

+: addition
-: subtraction
*: multiplication
/: division
%: modulus (returns the remainder of dividing one whole number by another)

Here are some examples:

//gives num the value 6
int num = 2*3;

//gives x the value 3.3
double x = 6.6/2.0

//this is integer division, so we drop the decimal portion
//gives result the value 2
int result = 7/3;

//7/3 is 2 remainder 1
//gives mod the value 1
int mod = 7%3;

We can also use multiple mathematical operators at once, and we can involve variables in the expressions.

Here are some more examples:

int x = 3;
double y = 4.4;
int z = 10;

//gives result1 the value 29
int result1 = x*z – z%x;

//gives result1 the value 26
result1 = (int)(z/y + 73/x);

Notice that these examples are NOT the same as equations in algebra. In an equation, the expression on the left-hand side equals the expression on the right-hand side. In these examples, we are assigning a variable (the left-hand side) to have the VALUE from the expression on the right-hand side.

We can also do something like this:

int num = 1;
num = num + 1;

This updates the value of num to be one bigger than the old value of num. Now num has the value 2.

We CANNNOT do things like this:

//Illegal!
num + 1 = num;

//Illegal!
5 = num;

The left-hand side must be a single variable, and we are updating that variable’s value to be the result of the right-hand side.

Expressions

An expression is a computation of variables and constant values (literals) using mathematical or other operators. When we evaluate an expression, we get a value as a result. For example, variable assignments might look like:

variable = expression;

For example:

int x = 7*(3-2)+1;

Here, 7*(3-2)+1 is an expression. We evaluate it first, and then the result is stored in the x variable.

Shortcuts

There are several simple operations that you will find yourself doing over and over, such as adding one to a variable or multiplying a variable by a single value.

For example:

int num = 6;

//gives num the value 8
num += 2;

This statement adds 2 to num, so that num now has the value 8. It is equivalent to the statement:

num = num + 2;

We can also do something similar with -=, *=, /=, and %=. Here are some examples:

int x = 1;

//gives num the value 7
num -= x;

//gives num the value 35
num *= 5;

//gives num the value 11
num /= 3;

//gives num the value 1
num %= 2;

There are other shortcuts we can use if we want to add one to a variable or subtract one from a variable:

int val = 4;

//adds one to val, now val is 5
val++;

//subtracts one from val, now val is 4
val--;

The statement val++ is equivalent to:

val += 1;

It is also equivalent to:

val = val + 1;

A similar comparison is true for the statement val--.

Conditional operations

There is another group of operators we can apply to boolean variables (variables that can be either true or false). Here is a list of these conditional operators:

Here are some examples:

boolean a = true;
boolean b = false;
int x = 4;
int y = 3;
int z = 3;

//result is set to false (x does not equal y)
boolean result = (x == y);

//result is set to false (y does equal z)
result = (y != z);

//result is set to false (x is not less than z)
result = (x < z);

//result is set to false (z is less than x, but a does not equal b)

result = (z < x) && (a == b);
//result is set to true (z is less than x – it doesn't matter whether a equals b)

result = (z < x) || (a == b);

//result is set to true (!b is true, and a is true)
result = !b && a;

Printing

We have already seen how to print text, but this section will review printing and go into more detail about what you can do.

Print statements

There are two commands for printing text:

System.out.println("Hello");
System.out.print("Hello");

The first command prints “Hello” to the screen, and then moves down to the next line. This way, if you print something else it will appear on the line below. The second command prints “Hello”, but stays on the same line. If we printed something else, it would appear on the same line as “Hello”.

Of course, we can substitute any string we like for “Hello”. The string we want to print must be in "" quotes, but the quotes do not actually get printed.

Printing variables

In addition to printing strings enclosed in “”, we can also print the values of variables. To do this, we just put the variable name inside the System.out.println or System.out.print parentheses. When that line is executed, the VALUE of the variables gets printed to the screen.

Here are some examples:

int num = 4;
char c = ‘A';
double val = 7;
boolean flag = true;
String s = "Cat";

//prints 4
System.out.print(num);

//prints A on the same line as 4
System.out.println(c);

Concatenating

We can output text that has both variable values and regular strings with a single System.out.println statement. This can be accomplished by using the concatenation (+) operator.

Here’s an example:

String name = "Fred";
int age = 20;
System.out.println(name + " is " + age + " years old");

This prints out: “Fred is 20 years old”. Notice that if you want to print the value of a variable, just list the variable (not in quotes). If you want to print normal text, put the text in quotes. To combine variables and text, separate them by a +. This plus concatenates the variables and text by pushing them together to form one big string.

Formatted printing

As an alternative to the concatenation approach, we can also use the System.out.printf command to print a combination of text and variable values. This command also allows us to format our output by adding spacing or rounding doubles to some number of decimal places.

Format specifiers

Printing variables works a bit differently with the System.out.printf command. In this approach, weneed to use a format specifier to specify the kind of variable that’s going to be printed.

Here are the different format specifiers:

It’s easiest to see an example to figure out how formatted printing works. Here’s how to print the value of an integer to the terminal:

int num = 4;
System.out.printf("The value of num is %d%n", num);

Notice that where we want to print a variable, we put the format specifier (%d for int). After we’ve listed the entire text we want to print, we put the corresponding variable names in a comma-separated list.

The above example will print:

"The value of num is 4" 

to the terminal. It will also end with a newline character, so that the next thing we printed would appear on the line below.

We can also print several variables at once:

char letter = 'A';
int val = 27;
System.out.printf("The letter is %c and the number is %d%n", letter, val);

This prints:

"The letter is A and the number is 27"

to the screen. Notice that the %c corresponds to the letter variable, and the %d corresponds to the val variable.

Formatting output with System.out.printf

The System.out.printf command also allows you some control over formatting your output. For example, if you want a value to take up exactly 6 spaces (padded with space characters on the left, if necessary), put a 6 between the % and the format specifier.

For example:

int num = 4;
System.out.printf("The value of num is %6d%n", num);

This will print:

"The value of num is      4" 

to the terminal (note the padding on the left of the 4).

You can also only display a certain number of digits for doubles. For example, put a .2 in between the % and the format specifier character to only display two decimal places.

For example:

double val = 3.14159;
System.out.printf("Pi is %.2f%n", val);

This will display:

"Pi is 3.14" 

You can specify both the width of the output (for example, six spaces) and the number of decimals to display by doing something like this:

double val = 3.14159;
System.out.printf("Pi is %6.2f%n", val);

User Input

We can get user input by printing a prompt to the command-line, and then having the user type the information right after the prompt.

Basic user input instructions

Here’s how to get user input:

• Add the following to the top of your file:

import java.util.*;

• Create a Scanner to help you read in the input. For now, just add this line ONCE, before any user input. (Don’t do this again even if you want more input.)

Scanner s = new Scanner(System.in);

• Print out a descriptive prompt (use System.out.print so it will be on the same line as the input):

System.out.print("Enter name: ");

• Read in the input with the command s.nextLine(). This command returns the String that was typed by the user.

String name = s.nextLine();

Here’s the full program:

import java.util.*;
public class ConsoleInput {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.print("Enter name: ");
        String name = s.nextLine();
        //now the name variable holds the name typed by the user
    }
}

Conversions

We don’t always want to read in strings from the user. We may also want to read in numbers. To do that, we need a way to convert from a string to a type like an int or double. We cannot convert from strings to ints or doubles by using type casting. We will discuss this more later on, but strings are object variables while other types of variables have primitive types. For now, just remember that strings are treated differently.

There are special parsing methods available to turn a string into a double or int. Here’s how to use them:

String str1 = "345";
String str2 = "3.76";
String str3 = "A";

//converts from a string to an int

int num1 = Integer.parseInt(str1);

//converts from a string to a double
double num2 = Double.parseDouble(str2);

Now that we know how to convert strings to different types, we can read in things like numbers and characters. Here is an example:

Scanner s = new Scanner(System.in);
System.out.print("Enter your age: ");
String str = s.nextLine();
int age = Integer.parseInt(str);

At the end of this example, the age variable holds the number typed by the user.

We can also read in the value typed by the user and convert it to the appropriate type all in one line:

Scanner s = new Scaner(System.in);
System.out.print("Enter your age: ");
int age = Integer.parseInt(s.nextLine());

Reading numbers without parsing

We can also use the nextInt() and nextDouble() commands for reading in ints and doubles from the user without doing a separate parsing step.

Here is an example reading in an int from the user:

Scanner s = new Scaner(System.in);
System.out.print("Enter your age: ");
int age = s.nextInt();

And here is an example reading in a double from the user:

Scanner s = new Scaner(System.in);
System.out.print("Enter your GPA: ");
double gpa = s.nextDouble();

NOTE: When you get a number from the user using either nextInt() or nextDouble() and then get a string from the user with nextLine(), the program’s behavior can be unexpected.

When you type a user input number like “4”, you really type the 4 and then hit Enter to submit the input. The “4” gets processed by the nextInt() command, but the newline character that came from hitting Enter stays in the input buffer. When you next do the nextLine() command, the program reads what was left in the input buffer (the newline character)…WITHOUT waiting for you to type any input.

You can avoid this behavior by always using the nextLine() command together with parsing to get your user input, as this will not leave anything in the input buffer.

Examples

We have now seen how to perform operations on variables, and how to get user input. Let’s practice with two complete example programs.

Area of a rectangle

Suppose we want to ask the user for the length and width of a rectangle, and then print out the area of the rectangle.

Here are the steps we will need:

• Declare all the variables for the program. This includes the length, width, and area of the rectangle.
• Set up a Scanner since we will need user input.
• Ask the user to enter the width. Read what was typed into the width variable.
• Ask the user to enter the length. Read what was typed into the length variable.
• Assign area to be the width times the length (which is how the area of a rectangle is computed)
• Print the area to the screen

Here is the complete program:

import java.util.*;
public class Rectangle
{
    public static void main(String[] args)
    {
        Scanner s = new Scanner(System.in);
        int length;
        int width;
        int area;
        System.out.print("Enter the width: ");
        width = s.nextInt();
        System.out.print("Enter the length: ");
        length = s.nextInt();
        area = length*width;
        System.out.printf("The area is: %d%n", area);
    }
}

Temperature calculator

Next, suppose we want to ask the user for a temperature in Celsius, and then print out the result in Fahrenheit. Here are the steps we will need:

• Declare all the variables for the program. This includes the temperature in Fahrenheit (f) and the temperature in Celsius (c).
• Set up a Scanner since we will need user input.
• Ask the user to enter the temperature in Celsius. Read what was typed into the c variable.
• Assign f to be 9/5*c + 32 (that is the formula for converting from Celsius to Fahrenheit)
• Print the temperature in Fahrenheit (f) to the screen

Here is the complete program:

import java.util.*;
public class Temperature
{
    public static void main(String[] args)
    {
        Scanner s = new Scanner(System.in);
        double f;
        double c;
        System.out.print("Temperature in Celsius: ");
        c = s.nextDouble();
        f = (9.0/5.0)*c + 32;
        System.out.printf("In Fahrenheit: %f%n", f);
    }
}

Note that we changed the conversion formula to be 9.0/5.0*c + 32 instead of 9/5*c + 32. Can you think why that would be? (Remember integer division – if we divide two whole numbers, the decimal portion of the result is cut off. Since 9 and 5 are both whole numbers, 9/5 is just 1, the whole number portion. However, 9.0 and 5.0 have decimals, so 9.0/5.0 is 1.8, as we want.)

If Statements

An if statement allows us to do something only if some condition is true.

If statement syntax

Here is the syntax for an if statement:

if (condition) 
{
    //statements
}

Here, condition is either a boolean variable or an expression that evaluates to true or false. The statements inside the if- tatement are things that we ONLY want to happen if our condition is true. Finally, the brackets {} around the body are optional if there is only one statement inside.

If statement example

For example, suppose we want to get the user’s name and age as input. In any case, we want to then print out a greeting. We also want to print “You are an adult” if the user is 18 or older.

Here is the full program:

import java.util.*;
public class HelloAdult 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        System.out.print("Enter your name: ");
        String name = s.nextLine();

        System.out.print("Enter your age: ");
        int age = s.nextInt();

        System.out.printf("Hello, %s%n", name);
        if (age >= 18) 
        {
            System.out.println("You are an adult");
        }
    }
}

When the program runs, it will ask the user for their name and age and read those values into the name and age variables. It will then print Hello and the person’s name. Finally, if the person is 18 or older, the program will print “You are an adult”. If the user is under 18, the program will not print the “You are an adult” line.

If...Else Statements

An if…else statement allows us to do one thing if a condition is true, and a different thing if the condition is not true.

If…else statement syntax

Here is the syntax of an if…else statement:

if (condition)
{
    // first set of statements
}
else
{
    //second set of statements
}

Here, we will check condition – if it is true, we will execute the first set of statements. If condition is false, we will execute the second set of statements. In any case, exactly one set of statements is executed.

If…else example

For example, suppose we want to print out whether a number is even or odd. We can tell if a number is even by checking to see if it is divisible by two (i.e, we can use the modulo operator, %, to see if the remainder of a number when dividing by two is 0).

Scanner s = new Scanner(System.in);
System.out.print("Enter a number: ");
int num = s.nextInt();

//If the remainder of num/2 is 0, then num is even
if (num % 2 == 0) 
{
    System.out.printf("%d is even%n", num);
}
else 
{
    System.out.printf("%d is odd%n", num);
}

(Note: this is not a complete program. We would need to put this code inside a class declaration and inside the main method.) When this code is executed, it will first ask the user for a number, and store the result in the num variable. It will then compute num%2 (the remainder of num/2). If it is 0, then it will print that the number is even. If it is anything else, it will print that the number is odd. Each time, exactly one of the statements will be printed.

If...Else If Statements

An if…else if statement allows us to do differently things for several cases.

If…else if statement syntax

Here is the syntax for an if…else if statement:

if (condition1) 
{
    //first set of statements
}
else if (condition2) 
{
    //second set of statements
}
...
else 
{
    //last set of statements
}

In this structure, we first evaluate condition1. If it is true, then we execute the first set of statements and leave the if…else if statement. If condition1 is false, then we step down and evaluate condition2. If it is true, then we execute the second set of statements and move on in the program. If it is false, we move down to evaluate the next condition. This process continues until we run out of conditions to check. If none of the conditions were true, then the statements inside the else are executed.

We can have as many “else if” conditions as we want in this structure (which is denoted by the …). Furthermore, the else" portion is optional – we don’t have to have a special section that executes if none of the conditions were true.

If…else if example 1

For example, suppose we want to print out an age category for the user:

Scanner s = new Scanner(System.in);
System.out.print("Enter your age: ");
int age = s.nextInt();

if (age <= 12) 
{
    System.out.println("You are a child");
}
else if (age < 19) 
{
    System.out.println("You are a teenager");
}
else 
{
    System.out.println("You are an adult");
}

In this example, exactly one of the statements will be printed, depending on the user’s age.

If…else if example 2

As another example, suppose you want to ask the user for 5 tests grades (out of 100) so that you can calculate their overall letter grade (90% and up is an A, 80-90% is a B, etc.) Here is a fragment of the program:

Scanner s = new Scanner(System.in);
System.out.print("Enter a test score: ");
int grade1 = s.nextInt();
System.out.print("Enter a test score: ");
int grade2 = s.nextInt();
System.out.print("Enter a test score: ");
int grade3 = s.nextInt();
System.out.print("Enter a test score: ");
int grade4 = s.nextInt();
System.out.print("Enter a test score: ");
int grade5 = s.nextInt();
double avg = (grade1+grade2+grade3+grade4+grade5)/5.0;

if (avg >= 90.0) 
{
    System.out.println("Letter grade: A");
}
else if (avg >= 80.0) 
{
    System.out.println("Letter grade: B");
}
else if (avg >= 70.0) 
{
    System.out.println("Letter grade: C");
}
else if (avg >= 60.0) 
{
    System.out.println("Letter grade: D");
}
else 
{
    System.out.println("Letter grade: F");
}

Error checking

Conditional statements are very useful in handling error conditions in programs. You can check to see if the user’s input is what you expected before performing any calculations. For example, in the grade calculator we just wrote, we expect the test scores to be between 0 and 100. As an error condition, we could add this check after getting all the user input:

if (grade1<0 || grade1>100 || grade2<0 || grade2>100 || grade3<0 ||
    grade3>100 || grade4<0 || grade4>100 || grade5<0 || grade5>100) 
{
    System.out.println("Invalid input");
}
else 
{
    //put the average calculation and the code to print the letter grade here
}

Now, a letter grade will only be printed if all test scores had appropriate values.

Switch Statements

There is a second type of conditional statement in Java called a switch statement. These statements can be used as a shortcut over if statements when checking the value of variables or expressions.

Switch statement syntax

Here is the syntax of a switch statement:

switch (expression) 
{
    case val1:
        //first set of statements
        break;
    case val2:
        //second set of statements
        break;
    ...
    default:
        //last set of statements
}

Here, expression is either an expression or variable that has type char, int, or String (in more recent versions of Java). Inside the statement, val1, val2, etc. are possible values for expression. If expression equals val1, then we execute the statements inside the val1 case. If expression equals val2, then we execute the statements inside the val2 case. We can have as many cases as we want (as denoted by the …).

The default case is executed if expression does not evaluate to any of the case values. This default case is optional. The “break” statements at the end of each case mean that we will leave the switch statement at the end of a case. They are also optional, but if we leave them out then we will continue on to the statements in the next case (WITHOUT checking the case value). We will see an example of this in the next sections.

Switch statement example with ints

Here is an example that gets a month number (1-12) from the user and prints the corresponding month name:

Scanner s = new Scanner();
System.out.print("Enter month number (1-12): ");
int monthNum = s.nextInt();

String monthName;

switch(monthNum)
{
    case 1:
        monthName = "January";
        break;
    case 2:
        monthName = "February";
        break;
    case 3:
        monthName = "March";
        break;
    case 4:
        monthName = "April";
        break;
    case 5:
        monthName = "May";
        break;
    case 6:
        monthName = "June";
        break;
    case 7:
        monthName = "July";
        break;
    case 8:
        monthName = "August";
        break;
    case 9:
        monthName = "September";
        break;
    case 10:
        monthName = "October";
        break;
    case 11:
        monthName = "November";
        break;
    case 12:
        monthName = "December";
        break;
    default:
        monthName = "Invalid month";
        break;
}

System.out.println(monthName);

For example, if we ran our code fragment and entered 4 at the prompt, then the program would print “April”. If we ran it again and entered 13, then the program would print “Invalid month”.

Equivalent if…else if statement

We can always rewrite a switch statement using an if…else if statement that has an else if branch corresponding to each case in the switch. Here is our month name example repeated with an if…else if statement:

Scanner s = new Scanner();
System.out.print("Enter month number (1-12): ");
int monthNum = s.nextInt();

String monthName;

if (monthNum == 1)
{
    monthName = "January";
}
else if (monthNum == 2)
{
    monthName = "February";
}
else if (monthNum == 3)
{
    monthName = "March";
}
else if (monthNum == 4)
{
    monthName = "April";
}
else if (monthNum == 5)
{
    monthName = "May";
}
else if (monthNum == 6)
{
    monthName = "June";
}
else if (monthNum == 7)
{
    monthName = "July";
}
else if (monthNum == 8)
{
    monthName = "August";
}
else if (monthNum == 9)
{
    monthName = "September";
}
else if (monthNum == 10)
{
    monthName = "October";
}
else if (monthNum == 11)
{
    monthName = "November";
}
else if (monthNum == 12)
{
    monthName = "December";
}
else 
{
    monthName = "Invalid month";
}

System.out.println(monthName);

However, the structure of an if…else if statement can require more code that a switch statement (the expression we are evaluating must be retyped in each condition, and we often need to include brackets around each case), so switch statements are a convenient shortcut.

Switch statement example with chars

Here is an example that uses a switch statement to print out comments about a given letter grade:

Scanner s = new Scanner(System.in);
System.out.print("Enter your letter grade: ");

//this technique converts the string to a char 
//by getting the first character from the input string
char grade = (s.nextLine()).charAt(0);

switch (grade) 
{
    case 'A':
        System.out.println("Excellent");
        break;
    case 'B':
        System.out.println("Good");
        break;
    case 'C':
        System.out.println("Average");
        break;
    case 'D':
        System.out.println("Poor");
        break;
    case 'F':
        System.out.println("Failure");
        break;
    default:
        System.out.println("Invalid grade");
        break;
}

Depending on what grade the user entered, exactly one of the case statements will be printed.

Switch statement example without breaks

To see what happens when we leave some break statements out, suppose we want to repeat the letter grade example, but just print out whether the user passed (A, B, or C) or failed (D or F). Here’s what we would do:

switch (grade) 
{
    case 'A':
    case 'B':
    case 'C':
        System.out.println("Pass");
        break;
    case 'D':
    case 'F':
        System.out.println("Fail");
        break;
    default:
        System.out.println("Invalid grade");
        break;
}

If the user enters A, for example, then we will first go to case A in the switch statement. Since there is no break statement, we will go directly to case B (even though the grade entered doesn’t match that case). There is not a break statement in B either, so we will go to case C. There we will print “Pass” (which we should for an A grade) and break out of the switch statement.

Switch statement example with Strings

In more recent versions of Java, we can also use a switch statement to evaluate a String variable or expression. Here is an example that gets a month name from the user and prints out the corresponding month number:

Scanner s = new Scanner(System.in);
System.out.print("Enter a month name: ");

String monthName = s.nextLine();
int monthNum; 

switch (monthName) 
{
    case "January":
        monthNum = 1;
        break;
    case "February":
        monthNum = 2;
        break;
    case "March":
        monthNum = 3;
        break;
    case "April":
        monthNum = 4;
        break;
    case "May":
        monthNum = 5;
        break;
    case "June":
        monthNum = 6;
        break;
    case "July":
        monthNum = 7;
        break;
    case "August":
        monthNum = 8;
        break;
    case "September":
        monthNum = 9;
        break;
    case "October":
        monthNum = 10;
        break;
    case "November":
        monthNum = 11;
        break;
    case "December":
        monthNum = 12;
        break;
    default:
        monthNum = -1;
        break;
}

if (monthNum != -1)
{
    System.out.printf("Month number: %d%n", monthNum);
}
else
{
    //monthNum will be -1 if we went in our "default" switch case above
    System.out.println("Invalid month name");
}

The above example will only work correctly if the user types the month name using the format in our cases (capital first letter, lowercase subsequent letters). A trick to repeating this example WITHOUT checking for a specific format is to first convert the input month to lowercase, and then to change our cases to be in lowercase format:

Scanner s = new Scanner(System.in);
System.out.print("Enter a month name: ");

String monthName = s.nextLine();
int monthNum; 

switch (monthName.toLowerCase()) 
{
    case "january":
        monthNum = 1;
        break;
    case "february":
        monthNum = 2;
        break;
    case "march":
        monthNum = 3;
        break;
    case "april":
        monthNum = 4;
        break;
    case "may":
        monthNum = 5;
        break;
    case "june":
        monthNum = 6;
        break;
    case "july":
        monthNum = 7;
        break;
    case "august":
        monthNum = 8;
        break;
    case "september":
        monthNum = 9;
        break;
    case "october":
        monthNum = 10;
        break;
    case "november":
        monthNum = 11;
        break;
    case "december":
        monthNum = 12;
        break;
    default:
        monthNum = -1;
        break;
}

if (monthNum != -1)
{
    System.out.printf("Month number: %d%n", monthNum);
}
else
{
    //monthNum will be -1 if we went in our "default" switch case above
    System.out.println("Invalid month name");
}

Now, whether the user enters “September”, “september”, or “SePTembER”, the program will always print 9 as the month number.

Examples

This section includes three examples of full programs using conditional statements.

Example 1: max heart rate calculator

There are many different formulas for estimating a person’s maximum heart rate using their age and biological sex. Here is one such estimation:

For men: 220 – age
For women: 206 – 88% of age

(Every such formula is only an estimation, and may or may not be accurate for a particular person.) Below is a complete program that asks for a user’s age and sex, and then prints their maximum heart rate according to the estimation above.

import java.util.*;
public class Example1 
{
    public static void main(String[] args)
    {
        Scanner s = new Scanner(System.in);
        System.out.print("Enter your age: ");

        int age = s.nextInt();
        System.out.print("Enter (m)ale or (f)emale: ");
        char mOrF = (s.nextLine()).charAt(0);

        if (mOrF == 'm' || mOrF == 'M') 
        {
            int max = 220-age;
            System.out.printf("Max HR: %d%n", max);
        }
        else if (mOrF == 'f' || mOrF == 'F') 
        {
            double maxF = 206 – 0.88*age;
            System.out.printf("Max HR: %.2f%n" + maxF);
        }
        else 
        {
            System.out.println("Invalid input");
        }
    }
}

Example 2: minimum of two numbers

In this example, we will get two numbers as input from the user, and we will print out whichever number is smaller. In the case of a tie, it doesn’t matter which number we print.

import java.util.*;
public class Example2 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        System.out.print("Enter the first number: ");
        int num1 = s.nextInt();

        System.out.print("Enter the second number: ");
        int num2 = s.nextInt();

        if (num1 < num2) 
        {
            System.out.println(num1);
        }
        else
        {
            System.out.println(num2);
        }
    }
}

Example 3: temperature converter

In this example, we will ask the user for a temperature and the system being used (Fahrenheit or Celsius). We will then print the equivalent temperature in the other system (i.e., if we start with Fahrenheit then we will convert to Celsius, and vice versa). Here are the formulas that are used to convert between the two (C is Celsius and F is Fahrenheit):

C = (5/9)*(F-32)
F = (9/5)*C+32

Here is our full program:

import java.util.*;
public class Example3 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        System.out.print("Enter the temperature: ");

        double temp = s.nextDouble();
        System.out.print("Enter (f)ahrenheit or (c)elsius: ");

        char system = (s.nextLine()).charAt(0);
        double newTemp;

        if (system == 'f' || system == 'F') 
        {
            newTemp = (5.0/9.0)*(temp-32);
        }
        //we are assuming that the user typed either f or c
        else 
        {
            newTemp = (9.0/5.0)*temp + 32;
        }

        System.out.printf("Converted: %.2f%n", newTemp);
    }
}

While Loops

The simplest kind of loop is a while loop*. This loop executes a set of instructions repeatedly until a given condition becomes false.

While loop syntax

Here is the syntax of a while loop:

while (condition)
{
    //statements
}

Here, condition is evaluated before anything inside the loop is executed. If the condition is false, we immediately skip to the code after the loop. If the condition is true, we execute the statements inside the loop, and then check the condition again. If the condition is false, we leave the loop. If it is still true, we execute the loop again. We repeat this process until the condition becomes false.

While loop example

Here is how we can use a while loop to print the sum of 100 numbers entered by the user:

Scanner s = new Scanner(System.in);

//keep track of the sum of the elements we’ve seen so far
int sum = 0;
//keep track of how many elements we’ve asked for
int count = 0;

//keep looping while we haven’t asked for 100 elements
while (count < 100) 
{
    //ask for the next number
    System.out.print("Enter a number: ");
    int num = s.nextInt();

    //add the number to the sum we have so far
    sum = sum + num;

    //add one to our count (we’ve asked for one more number)
    count = count + 1;
}

//the loop is over – sum now holds the sum of 100 values
//print the sum
System.out.printf("The sum is: %d%n", sum);

Combining loops and conditional statements

We can also put conditional statements inside of loops (or loops inside of conditional statements). In this example, we want to print the sum of 100 positive numbers. If the user enters a negative number, we want to print an error and not add the number to our total:

Scanner s = new Scanner(System.in);

int sum = 0;
int count = 0;

while (count < 100) 
{
    System.out.print("Enter a positive number: ");
    int num = s.nextInt();

    //only add the number if it is positive
    if (num > 0) 
    {
        sum = sum + num;
        count = count + 1;
    }
    //otherwise, print an error
    else 
    {
        System.out.printf("Error: %d is not positive%n", );
    }
}

//the loop is over – sum now holds the sum of 100 values
//print the sum
System.out.printf("The sum is: %d%n", sum);

Do...While Loops

A do…while loop is similar to a while loop, but its condition is evaluated at the end of the loop instead of at the beginning. This means that a do…while loop will always execute at least once, but a while loop might not (because the condition might be false in the beginning).

Do…while syntax

Here is the syntax of a do…while loop:

do 
{
    //statements
} while (condition); //Notice the semi-colon!

The very first thing that happens when we reach a do…while loop is that we execute the statements inside – even if the condition is initially false. At that point, we check the condition – if it is true, we loop back and repeat the statements. We continue this process until the condition becomes false.

Do…while example

Suppose we want to add up a list of numbers typed by the user until they type a 0. Here’s how we could approach the problem:

Scanner s = new Scanner(System.in);

//this declares several variables of the same type (int)
int num, sum; 

sum = 0;
do 
{
    System.out.print("Enter an integer: ");
    num = s.nextInt();
    sum = sum + num;
} while (num != 0);

System.out.printf("The sum is %d%n", sum);

This loop immediately asks for a number before checking any kind of condition. Note that the last number typed by the user (a 0, which ends the loop) IS added to the sum. However, this is OK because adding zero to a number does not change the number.

For Loops

For loops are the most complicated kind of loop, but they are probably used the most often. Many times you use a loop counter to keep track of how many times the loop has executed. If you use a while loop, you initialize the loop counter before the loop, have a while loop with a certain condition, and then update the loop counter somewhere in the loop code. A for loop combines those three steps.

For loop syntax

Here is the syntax of a for loop:

for (initialization; condition; update) 
{
    //statements
}

Example: while loop vs for loop

Here is a while loop that adds the numbers from 1 to 4 and then prints the sum:

int sum = 0;
int count = 1;
while (count < 5) 
{
    sum = sum + count;
    count = count + 1;
}
System.out.printf("Sum: %d%n", sum);

In this example, our loop counter is count. We could rewrite our example using a for loop instead:

int sum = 0;
for (int count = 0; count <= 5; count++) 
{
    sum += num;
}

System.out.printf("The sum is %d%n", sum);

Another for loop example

Here’s another example, that prints out all odd numbers between 1 and 100. Notice that we increment the loop counter by 2 so we can immediately step to the next odd number:

for (int num = 1; num <= 100; num+=2) 
{
    System.out.println(num);
}

Other Loop Information

This section contains additional information for working with loops.

Infinite loops

It is very important that we do something inside the body of the loop that will eventually make the condition false. Otherwise, the loop will execute forever – we call this an infinite loop. For example, consider the loop below, which is supposed to print the sum of the numbers between 1 and 4:

int sum = 0;
int count = 1;
//warning: this is an infinite loop!
while (count < 5) 
{
    sum = sum + count;
}
System.out.printf("Sum: %d%n", sum);

This loop will never finish executing. We told the loop to keep going while count < 5 – but we NEVER change count inside the loop. Thus count is always 1, and the loop never ends. You can usually tell you have an infinite loop if your program just hangs without completing the execution.

Here is the corrected version of the loop:

int sum = 0;
int count = 1;
while (count < 5) 
{
    sum = sum + count;
    //update count so the condition will eventually be false
    count = count + 1;
}
System.out.printf("Sum: %d%n", sum);

Break statements

Recall that a break statement can be used to leave a switch case statement without evaluating any of the other cases. We can also use a break statement in a loop, which will let us immediately exit the loop without finishing the current iteration or checking the loop condition. For example, suppose we want to add up 10 numbers that the user types – unless the user types a 0, in which case we want to immediately stop and report the sum up to that point. Here’s how:

Scanner s = new Scanner(System.in);

int sum = 0;
int count = 0;

while (count < 10) 
{
    System.out.print("Enter a number: ");
    int num = s.nextInt();
    sum += num;

    //Exit loop if num was 0
    if (num == 0) break;
    count++;
}

System.out.printf("Sum: %d%n", sum);

When we run this program, it will ask for numbers either until it has asked 10 times (and the loop ends), or until the user types a 0 (in which case we immediately leave the loop). It then prints the sum.

Continue statements

The continue statement allows us to skip the rest of the code for the current iteration and instead immediately start on the next iteration. For example, suppose we again want to add up 10 numbers that the user types – but if they enter a negative number, we don’t want to add it to our sum. Here’s how:

Scanner s = new Scanner(System.in);

int sum = 0;
int count = 0;

while (count < 10) 
{
    System.out.print("Enter a number: ");
    int num = s.nextInt();

    //Ask for next number if a negative number was entered
    if (num < 0) continue;
    
    sum += num;
    count++;
}

System.out.printf("Sum: %d%n", sum);

This will ask for 10 numbers from the user. If a number is negative, we skip the rest of the loop (the part where we add num to our sum) and start on the next iteration (where we ask for another input number).

Variable Scope

There are rules about when we can use certain variables in our programs. If we declare a variable inside a set of brackets:

{
    //variable declaration
}

Then we can use that variable anywhere (after its declaration) inside those brackets. However, we cannot use the variable outside of the brackets (either before them or after them). These brackets can belong to a class, the main method, an if statement, or a loop – the rules are always the same.

Variable scope example

For example, if we do:

Scanner s = new Scanner(System.in);

int sum = 0;
int count = 0;

while (count < 100) 
{
    System.out.print("Enter a number: ");
    int num = s.nextInt();
    sum = sum + num;
    count = count + 1;
}

//illegal – num is not visible here
System.out.printf("The last number was: %d%n", num);
System.out.printf("The sum is: %d%d", sum);

Then we will get a compiler error. The num variable was declared inside the while loop brackets, and we cannot see it once the while loop has ended. If we did want to be able to print out the last number the user entered, we would have to declare the num variable before the while loop:

Scanner s = new Scanner(System.in);

//now num is visible everywhere in this code fragment
int num = 0;
int sum = 0;
int count = 0;

while (count < 100) 
{
    System.out.print("Enter a number: ");
    int num = s.nextInt();
    sum = sum + num;
    count = count + 1;
}

System.out.printf("The last number was: %d%n", num);
System.out.printf("The sum is: %d%d", sum);

Additionally, declaring the loop variable in a for loop has the same rules as declaring it inside the loop. For example:

for (int i = 0; i < 10; i++) 
{
    //do something
}

The i variable is only visible inside the for loop, just as if it was declared at the beginning of the loop. These requirements are called scope rules. If we are outside the brackets where a variable was declared, then we are outside the scope of that variable.

Redeclaring variables

Because we can’t always see variables that we have declared, we can reuse variable names. For example:

int count = 0;
while (count < 10) 
{
    int num;
    //do something with num
    count++;
}

count = 0;
while (count < 10) 
{
    int num;
    //do something with num
    count++;
}

Here, we have reused the num variable. The first declaration of num is only visible to the first while loop. If we want to use the name num again in the second while loop, we must redeclare it (because we can’t see the other variable). It is perfectly fine (and encouraged) to reuse variable names in this way.

We can also redeclare variables when we CAN still see the original variable, but it has a different result. For example:

int num = 10;
int count = 0;
while (count < 5) 
{
    int num = 2;
    count = count + num;
}
System.out.println(num);

Here, we declared num outside the while loop. Thus the num variable would have been visible inside the while loop as well. However, we declared num AGAIN inside the loop. Now there’s a conflict – we can see the variable outside the loop and the new variable inside the loop. In this case, the compiler always assumes you mean the inner-most variable declaration. So in the while loop, when you add num to your count, it assumes you mean the inner-most num – the one declared inside the loop. So each time in the loop, 2 is added to your count. Once you are outside the loop, the while-loop num is no longer visible. So the print statement prints out the original num value – 10. This type of variable declaration is confusing and not recommended. In general, if a variable with some name is visible where you are, don’t reuse the name for a different variable.

Nested Loops

We can also put one loop inside of another loop – this is called nesting. We tend to want a nested loop when we want to:

Repeat a series of instructions
    For each repetition, repeat a different series of instructions

In a nested loop, the inner loop is completed (going through ALL its iterations) for each repetition of the outer loop.

Nested loop example: printing pattern #1

Nested loops can be tricky, so we’ll start off with two simple examples. Let’s say we want to print the following pattern:

* * * *
* * * *
* * * *
* * * *
* * * *

Notice that we want 5 rows and 4 columns of stars (asterisks – above the 8 key). We will write a nested loop as if we were dealing with an array – the outer loop will step through each of the 5 rows, and the inner loop will step through each of the 4 columns. Inside the inner loop, we will print the next star (*):

for (int i = 0; i < 5; i++) 
{
    for (int j = 0; j < 4; j++) {
        System.out.print("* ");
    }
    System.out.println();
}

We are using the same trick with print statements that we did when printing a two dimensional array. The inner print statement is a print, because we are not done with the current row, and we want to print each row on a single line. The outer statement is a println, because we are done with the current row and want to advance to the next line for the next row.

Nested loop example: printing pattern #2

Let’s continue our printing example, but make it a bit more complicated. Suppose this is what we want to print now:

0 1 2 3 4
0 1 2 3 4
0 1 2 3 4
0 1 2 3 4
0 1 2 3 4

This is very similar to the previous example, except that we now want 5 rows and 5 columns. Also, instead of printing stars, we want to print numbers. Notice that in each case, the number printed is the same as the column number (0 is the leftmost column, then 1, etc.). So, we can change our solution to:

for (int i = 0; i < 5; i++) 
{
    for (int j = 0; j < 5; j++) 
    {
        System.out.printf("%d ", j);
    }
    System.out.println();
}

The only change to this solution is that we are printing out the value of j instead of a *. The loop with j steps through the columns, so if we print j it will be the current column number. And for each row, it will print 0, 1, 2, 3, 4 (because those are the values that j steps through).

Nested loop example: printing pattern #3

This is our third printing pattern, and let’s make it a little more complicated. Suppose now we want to print:

0
0 1
0 1 2 3
0 1 2 3 4

We still want 5 rows, but the columns are a little different. We are still printing the current column number each time, but the number of columns varies with each row. Notice that row 0 has 1 column, row 1 has 2 columns, row 2 has 3 columns, row 3 has 4 columns, and row 4 has all 5 columns. So, the number of columns in each row is the row number + 1. In our for loops, i is keeping track of the current row number. So we can change our code as follows:

for (int i = 0; i < 5; i++) 
{
    for (int j = 0; j < i+1; j++) 
    {
        System.out.printf("%d ", j);
    }
    System.out.println();
}

The only change to this solution is that the loop with j now steps while j < i+1. This controls how many numbers we want to print on the current row, which we decided was the row number plus one. The loop with i counts through the rows, so i+1 is how many elements we want to print on the current row. (For the first row, i+1 will give us 1 column. For the second row, i+1 will give us two columns, etc.)

Nested loop example: factoring a number

In this example, we want to ask the user for a number, and then print out its prime factors. (If the number is prime, then we want to print that fact instead.) For example, if the user enters 20, we want to print something like this:

20 = 2*2*5

We know that we want to loop through possible factors (from 2 up to the number-1) and try seeing if they divide into the number evenly. The trick is that some values will be multiple factors – for example, we need to use 2 twice when factoring 20. So our approach will look something like this:

loop through all possible factors
    factor out the current number as many times as possible

Here is a solution:

import java.util.*;
public class Factor 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        System.out.print("Enter a number to factor: ");
        int num = s.nextInt();
        System.out.printf("%d = ", num);

        //We will divide factors out of cur as we find them
        int cur = num;
        //for each possible factor i
        for (int i = 2; i <= num-1; i++) 
        {
            //as long as i keeps dividing in evenly
            while (cur % i == 0) 
            {
                //print the factor and divide it out
                System.out.printf("%d ", i);
                cur = cur / i;
                if (cur != 1) System.out.print("* ");
            }
            if (cur == num) 
            {
                System.out.println("prime");
            }
            else 
            {
                System.out.println();
            }
        }
    }
}

Examples

This section includes three examples of full programs using loops.

Example 1: smallest of 10 numbers

In this example, we will ask the user for 10 numbers and then print out the smallest number entered.

import java.util.*;
public class Example1 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        System.out.println("Enter 10 numbers.");
        System.out.println("Press Enter after each one.");

        int min = s.nextInt();
        for (int i = 1; i < 10; i++) 
        {
            int next = s.nextInt();
            if (next < min) min = next;
        }
        System.out.printf("Smallest: %d%n", min);
    }
}

Example 2: compute an exponent

In the next example, we will use a loop to help compute an exponent. We will ask the user for the base (b) and the exponent (n), and will compute and print $b^n$.

import java.util.*;
public class Example2 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        System.out.print("Enter base: ");
        int b = s.nextInt();
        System.out.print("Enter exponent: ");
        int n = s.nextInt();

        int exp = 1;
        for (int i = 0; i < n; i++) 
        {
            exp *= b;
        }
        
        System.out.printf("%d^%d = %d%n", b, n, exp);
    }
}

Example 3: compute factorials

In this example, we will ask the user for a positive integer bound (we’ll call it n). Then, we will calculate and print:

1!
2!
...
n!

The ! means factorial. For example, 5! is calculated as follows:

5! = 5*4*3*2*1 = 120

This will require a nested loop. The outer loop will step through the numbers from 1 to n, and the inner loop will find the factorial of the current number.

import java.util.*;
public class Example3 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        System.out.print("Enter a positive integer bound: ");
        int bound = s.nextInt();

        if (bound >=1) 
        {
            for (int i = 1; i <= n; i++) 
            {
                int fact = 1;
                for (int j = i; j >= 1; j--) 
                {
                    fact *= j;
                }
                System.out.printf("%d! = %d%n", i, fact);
            }
        }
        else 
        {
            System.out.println("Bound must be positive.");
        }
    }
}

Single-Dimensional Arrays

A single-dimensional array stores a list of elements of the same type. We can make this list be any size that we want.

Declaring a single-dimensional array

We can declare a single-dimensional array like this:

type[] name;

This will declare an array called name that can hold elements of type type. For example, to declare an array of ints called nums, we can do:

int[] nums;

Before we can add any elements to the array, we need to allocate space for the array (i.e., specify the number of slots we want to reserve). Here’s how:

name = new type[size];

Here, name is the name of the array, type is the type of elements the array holds, and size is a positive integer that specifies how many slots we want in the array. size can be either a constant value (like 10) or an int variable. Here’s how to make our nums array have 10 slots:

nums = new int[10];

We can also declare an array and reserve space for it on the same line, like this:

int[] nums = new int[10];

Default array values

After we have allocated space for an array, all array slots are automatically filled with the default element for the type. In the case of any numeric type, the default value is 0. Here is what our nums array would look like after allocations space for 10 integers:

Initialization

Now that we have space for the array elements, we can start putting values in the array slots. Here’s how to access array elements:

name[index]

This accesses the element in array name at index index. C# array indices start at 0 and go up to size-1 (where size is the number of slots we reserved for the array). For example, here’s how we’d set the first element in our previous nums array to 7:

nums[0] = 7;

Here’s how we’d set the last element in nums to 4:

//9 is the last index since the array size is 10
nums[9] = 4; 

Here is what our nums array would look like after setting the first element to 7 and the last element to 9 (remembering that all other elements would retain the default value of 0)

Looping with an array

Arrays are very naturally processed with for loops. The loop counter is the array index – we start at 0, and we continue looping while the loop counter is less than the array size. Each time, we add one to the loop counter. For example, here’s how we’d use a loop to set every element in the nums array to 10:

for (int i = 0; i < 10; i++) 
{
    nums[i] = 10;
}

We can also retrieve the size of the array with the command:

name.length

where name is the name of the array. We could have rewritten the previous example to use nums.length instead, like this:

for (int i = 0; i < nums.length; i++) 
{
    nums[i] = 10;
}

Here is what our nums array would look like after the loop above:

Array example

Suppose we want to ask the user for 10 numbers, and then we want to print them in reverse order. Here’s how we could do that:

Scanner s = new Scanner(System.in);
int[] nums = new int[10];

for (int i = 0; i < nums.length; i++) 
{
    System.out.print("Enter a number: ");
    nums[i] = s.nextInt();
}
for (int i = nums.length-1; i >= 0; i--) 
{
    System.out.println(nums[i]);
}

Nested Loops with Arrays

When processing arrays, it is sometimes necessary to put a loop inside of another loop – this is called a nested loop.

Suppose we want to ask the user for 10 numbers, store them in an array, and then find and print the mode of the array. (The mode of a list of numbers is the most frequently occurring element. In the case of a tie, we will accept any of the most frequently occurring elements as the mode. For example, the mode of {1,2,4,1,2,1,3} is 1, and the mode of {2,4,1,4,2,4,2} is either 4 or 2.)

Here is the code:

Scanner s = new Scanner(System.in);

//create an array to hold the numbers
int[] nums = new int[10];

//get the input numbers
for (int i = 0; i < nums.length; i++) 
{
    System.out.print("Enter a positive number: ");
    nums[i] = s.nextInt();
}

//the index of (one of) the mode values
int modeIndex = 0;

//the number of times our mode value appears in nums
int modeCount = 0;

//for each element in the array, count how many times that element appears
for (int i = 0; i < nums.length; i++) 
{
    int count = 0;
    //count how many times the element at position i appears
    for (int j = 0; j < nums.length; j++) 
    {
        //did we find another occurrence of the element at nums[i]?
        if (nums[i] == nums[j])
        {
            count++;
        }
    }

    //is our count better than our previous best?
    if (count > modeCount)
    {
        //we have a new best modeCount
        modeCount = count;

        //we have a new mode index
        modeIndex = i;
    }
}

//print the mode
System.out.printf("The mode is %d, which appeared %d times%n", nums[modeIndex], modeCount);

Notice that every time our outer loop executes, we go through each iteration of the inner loop. This allows our outer loop to keep track of which element we are counting, and our inner loop to actually count the number of occurrences of that element.

(Note: the implementation above is not the most efficient way to calculate the mode. We could modify our inner loop to not have to make quite as many iterations, but still compute the correct value. This idea is left as an exercise to the reader. Another even faster implementation is to use a data structure called a hash table, which we will see at the end of the text book.)

Two-dimensional Arrays

The arrays we’ve seen so far have been one-dimensional – that is, just a list of elements. We can also create multi-dimensional arrays, which are really just arrays of arrays. For example, a 2- dimensional array could represent a mathematical matrix, where each element has an associated row and column.

Declaration

Here’s how to declare a 2-dimensional array:

type[][] name;

Here’s how to allocate space for the array spots:

name = new type[numRows][numCols];

This creates a two-dimensional array called name, with numRows rows and numCols columns, that holds elements of type type. Here’s how to create an array called matrix that holds 5 rows and 10 columns of integers:

int[][] matrix = new int[5][10];

Initialization

When we allocate space for an array, all spots are automatically initialized to the default value for the type (which is 0 for integers).

If we want to store different values in our array, we must specify both the row index and the column index. As with single-dimensional arrays, the first row is index 0 and the first column is 0. Here’s how we could set the element at row 2 and column 0 to 6 in our matrix example:

matrix[2][0] = 6;

Multiplication table example

If we want to initialize all elements of a two-dimensional array, we need to use a nested for loop. The outer loop will step through each row, and the inner loop will step through each column in that row. Here’s how to use a two-dimensional array to represent a multiplication table (the entry at row i and column j has the value i*j):

//Declare, create space
int[][] multTable = new int[10][10];

//Fill with multiplication values
for (int i = 0; i < 10; i++) 
{
    for (int j = 0; j < 10; j++) 
    {
        multTable[i][j] = i*j;
    }
}

Now the array looks like this:

| | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |

| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | | 1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | | 2 | 0 | 2 | 4 | 6 | 8 | 10 | 12 | 14 | 16 | 18 | | 3 | 0 | 3 | 6 | 9 | 12 | 15 | 18 | 21 | 24 | 27 | | 4 | 0 | 4 | 8 | 12 | 16 | 20 | 24 | 28 | 32 | 36 | | 5 | 0 | 5 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | | 6 | 0 | 6 | 12 | 18 | 24 | 30 | 36 | 42 | 48 | 54 | | 7 | 0 | 7 | 14 | 21 | 28 | 35 | 42 | 49 | 56 | 63 | | 8 | 0 | 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | | 9 | 0 | 9 | 18 | 27 | 36 | 45 | 54 | 63 | 72 | 81 |

For-Each Loop

There is a fourth kind of loop in Java that is handy for stepping through collections of elements, such as arrays. The syntax is:

for (type name : list) 
{

}

Here, type is the type of elements in the list, name is a variable that will step through each element, and list is the name of the list or array of elements.

Example with single-dimensional array

To see how the for-each loop works, suppose we have declared this array:

double[] vals;

Further suppose that we have allocated space for the array and filled it with initial values. Here is how we could use a for-each loop to print every element in the array:

for (double num : vals) 
{
    System.out.println(num);
}

This loop will step through the array starting and index 0. Each time, num will be given the value of the next element in the array.

Restrictions of for-each loop

One caveat to using a for-each loop is that you CANNOT use it to change any values in the array. For example, we might try to set every value in the vals array back to zero:

for (double num : vals) 
{
    //Won’t change array
    num = 0.0;
}

This code would compile, but it would not change the array. In that for-each loop, num is assigned the value of the first element in the array, then the second, etc. What the above loop does is change the current value of num – not the current array spot. If you want to change elements in an array, use one of the other types of loops.

Example with two-dimensional array

We can also use a for-each loop to step through every element in a two-dimensional array. Just like with other loops, we need an outer loop to step through the rows, and an inner loop to step through the elements on that row. For example:

int count = 0;
int[][] arr = new int[4][5];

//use standard for loops to initialize the array
for (int i = 0; i < 4; i++) 
{
    for (int j = 0; j < 5; j++) 
    {
        arr[i][j] = count;
        count++;
    }
}

/*Now the array looks like:
0 1 2 3 4
5 6 7 8 9
10 11 12 13 14
15 16 17 18 19
*/

//now use a for-each loop to print each element
//elements printed will be 0, 1, 2, etc. ("read" arr like a book)
for (int[] val : arr) 
{
    for (int x : val) 
    {
        System.out.println(x);
    }
}

Examples

This section includes a few more examples of full programs that use arrays.

Example 1: find average, minimum, and maximum

Suppose we want to write a program that asks the user for 20 numbers (doubles), and that calculates and prints the average, minimum, and maximum number from the user.

import java.util.*;

public class Example1 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);

        //get 20 numbers from the user
        double[] nums = new double[20];
        for (int i = 0; i < nums.length; i++) 
        {
            System.out.print("Enter the next number: ");
            nums[i] = s.nextDouble();
        }

        //find the average
        double sum = 0;
        for (int i = 0; i < nums.length; i++) 
        {
            sum += nums[i];
        }
        double average = sum / nums.length;
        System.out.printf("Average: %d%n", average);

        //find the minimum
        double min = nums[0];
        for (int i = 1; i < nums.length; i++) 
        {
            if (nums[i] < min) min = nums[i];
        }
        System.out.printf("Minimum: %d%n", min);

        //find the maximum
        double max = nums[0];
        for (int i = 1; i < nums.length; i++) 
        {
            if (nums[i] > max) max = nums[i];
        }
        System.out.printf("Maximum: %d%n", max);
    }
}

It turns out that we don’t need to write separate code to calculate the average, minimum, and maximum. We can combine those steps into a single loop. (We also don’t need to store the numbers in an array before doing our calculations, but we’ll keep that part since it’s the focus of this chapter.) Here is a shorter way to write the same program:

import java.util.*;

public class Example1 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);

        //get 20 numbers from the user
        double[] nums = new double[20];
        for (int i = 0; i < nums.length; i++) 
        {
            System.out.print("Enter the next number: ");
            nums[i] = s.nextDouble();
        }

        //find the average, minimum, and maximum
        double sum = 0;
        double min = nums[0];
        double max = nums[0];

        //for the min/max, it doesn't *hurt* to start at i=0
        for (int 0 = 0; i < nums.length; i++) 
        {
            sum += nums[i];
            if (nums[i] < min) min = nums[i];
            if (nums[i] > max) max = nums[i];
        }

        double average = sum / nums.length;
        System.out.printf("Average: %d%n", average);
        System.out.printf("Minimum: %d%n", min);
        System.out.printf("Maximum: %d%n", max);
    }
}

Example 2: reverse an array

In this example, we will write a full program that reverses an array in place. We will start by feeling the array with default values (we could get user input for the array values – the next steps would be the same in either case). Then, we will write the code necessary to switch array elements around so that they’re stored in reverse of the original order. Finally, we’ll print the resulting array to show that it will print in reverse order.

public class Example2 
{
    public static void main(String[] args) 
    {
        //could be any values, or could have gotten user input
        int[] nums = {2,4,6,8,10,12,14,16,20};

        //now reverse the order of the array elements
        //front starts at the beginning of the array and steps back
        //back starts at the end of the array and steps up
        //why do we only go halfway? Think about this.

        int back = nums.length-1;
        for (int front = 0; front < nums.length/2; front++) 
        {
            //at each step, swap the current front and back
            int temp = nums[front];
            nums[front] = nums[back];
            nums[back] = temp;
            back--;
        }
    }
}

Example 3: Tic-Tac-Toe

In this example, we will write a full Tic-Tac-Toe program between two players. We will use a 3x3 array of characters to store the board.

import java.util.*;
public class TicTacToe 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);

        char[][] board = new char[3][3];
        //fill with _ for blank spots
        for (int i = 0; i < 3; i++) 
        {
            for (int j = 0; j < 3; j++) 
            {
                board[i][j] = '_';
            }
        }

        //count how many moves have been made
        int moves = 0;
        //keep track of whose turn it is
        char turn = 'X';

        //print the initial board
        System.out.println("Current board: ");
        for (int i = 0; i < 3; i++) 
        {
            for (int j = 0; j < 3; j++) 
            {
                System.out.printf("%c ", board[i][j]);
            }
            System.out.println();
        }
        System.out.println();

        //keep playing while less than 9 moves
        while (moves < 9) {
            System.out.printf("%c, enter row: ", turn);
            int row = s.nextInt();
            System.out.printf("%c, enter column: ", turn);
            int col = s.nextInt();

            //check to see if that is a valid move
            if (row < 0 || row > 2 || col < 0 || col > 2) 
            {
                System.out.println("Invalid row/column");
            }
            else if (board[row][col] != '_') 
            {
                System.out.println("That spot is taken");
            }
            else 
            {
                //it was a good move
                board[row][col] = turn;

                //print the board
                System.out.println("Current board: ");
                for (int i = 0; i < 3; i++) 
                {
                    for (int j = 0; j < 3; j++) 
                    {
                        System.out.printf("%c ", board[i][j]);
                    }
                    System.out.println();
                }
                System.out.println();

                //check for a winner
                boolean win = false;
                for (int i = 0; i < 3; i++) 
                {
                    //found 3 on a row
                    if (board[i][0] == board[i][1] &&
                    board[i][1] == board[i][2] &&
                    board[i][0] == turn) win = true;

                    //found 3 on a column
                    if (board[0][i] == board[1][i] &&
                    board[1][i] == board[2][i] &&
                    board[0][i] == turn) win = true;
                }

                //found 3 on a \ diagonal
                if (board[0][0] == board[1][1] &&
                board[1][1] == board[2][2] &&
                board[0][0] == turn) win = true;

                //found 3 on a / diagonal
                if (board[2][0] == board[1][1] &&
                board[1][1] == board[0][2] &&
                board[2][0] == turn) win = true;

                if (win) 
                {
                    System.out.printf("%c wins!%n", turn);
                    //end the game
                    break;
                }

                //switch whose turn it is
                if (turn == 'X') turn = 'O';
                else turn = 'X';

                //increment number of moves
                moves++;
            }
        }

        //if moves made it to 9, must be a tie
        if (moves == 9) System.out.println("Tie game.");
    }
}

Basics

In this section, we explore some of the basic string operations

Declaring and initializing

Here is how to declare a string variable:

String s1;

Just like any other variable that has been declared but not initialized, s1 currently has no value (and we will get a compilation error if we try to use s1 before initializing it).

We can give s1 an initial value like this:

s1 = "hello";

Or, we can declare and initialize a string at the same time like this:

String s1 = "hello";

Concatenation

String concatenation is pushing two strings together with the + sign – we’ve seen how to concatenate strings when printing things out. Here are some more examples:

int age = 7;
char initial = 'L';
String first = "Bob";
String last = "Jones";

String about = first + " " + initial + ". " + last + ", age " + age;

The string about will now hold the value “Bob L. Jones, age 7”.

Notice that we can concatenate types other than strings, like ints and chars. In fact, we can do this with any variable type. The only confusion is when we’re concatenating several ints – does the + mean concatenation or integer addition?

The answer, of course, is that it can mean both. The compiler interprets expressions by reading from left to right. If it sees a + and has only seen primitive types (like int a double) so far, it will assume you mean mathematical addition. If it has seen a string or object already on that line, it will assume you mean string concatenation. Here are some examples:

//evaluates to "11 hi"
String s1 = 4+7+" hi ";

//evaluates to "hi 47"
String s2 = "hi "+4+7; 

//evaluates to "11 hi 47"
String s3 = 4+7+" hi "+4+7; 

Length

You can get the number of characters in a string by accessing its length. Here’s how:

String s = "Hello";

//count will be set to 5
int count = s.length(); 

charAt

A string is backed by an array of characters, but you can’t access a character in a string by using array notations ( [i] ). Instead, you need to use the charAt command. This returns the character at a particular index in the string. Like an array, the first index in a string is 0, and the last one is the length-1. Here’s an example:

String s = "Hello";

//has value e
char c = s.charAt(1); 

Now that we know the length and charAt commands, we can step through every character in a string. Here’s an example that prints every character in a string:

Scanner s = new Scanner(System.in);
System.out.print("Enter a string: ");
String str = s.nextLine();

for (int i = 0; i < str.length(); i++) 
{
    System.out.printf("Character: %c%n", str.charAt(i));
}

Substring

To extract a piece of a string (either a single character or several characters in a row), use the substring command:

String s = "hello";

//has value "lo"
String sub = s.substring(3); 

Alternatively, we can specify the starting index (inclusive) and the ending index (non-inclusive):

String s = "hello";

//has value "el"
String sub1 = s.substring(1, 3); 

//has value "llo"
String sub2 = s.substring(2, 5); 

//has value "h"
String sub3 = s.substring(0, 1); 

Note that when we extract a single character with substring as we did with s.substring(0, 1) above, we get the result as the string “h” (which must be stored in a String variable). If we were to instead use s.charAt(0), we would get the result as the CHARACTER ‘h’ (which must be stored in a char variable).

String Search

Sometimes we also want to go the other way – get back the index of a character or piece within a string. We can do this with the indexOf command. Here is an example:

String s = "cake";

//has value 1
int index = s.indexOf("a"); 

Notice that we get back 1, which is the index of “a” in the string “cake”. We can also search for a bigger piece of a string:

String s = "cake";

//has value 2
int bigIndex = s.indexOf("ke"); 

Now we get back 2, because the piece “ke” starts at index 2 within “cake”. Here are some more examples:

String second = "hello";

//has value 2
int find1 = second.indexOf("l"); 

//has value -1
int find2 = second.indexOf("x"); 

Notice that “l” appears twice in “hello”, but we get back the index of the FIRST “l”. Also, when we search for something that’s not in the string (like “x”), we get back -1.

StringTokenizer

The Java StringTokenizer class helps you break strings into small pieces. This is helpful if you have a bunch of data stored in a string, separated by commas or spaces. First, you need to import the java.util library:

import java.util.*;

Then, you need to create a new StringTokenizer:

StringTokenizer st = new StringTokenizer(fullString, delimeters);

Here, fullString is the string you want to break into pieces, and delimeters is a string that contains all the characters that separate the pieces in fullString. For example, if you had a list of names that were separated by commas and spaces, then delimeters would be " ,". Here’s an example:

String fullString = "Bob, Joe, Lisa, Katie";
StringTokenizer st = new StringTokenizer(fullString, " ,");

Now, you need to break apart the pieces. You can check if you’ve stepped through all of them by calling the hasMoreTokens() method, which will return true when you’ve read the entire string. You can get the NEXT piece of the string by calling the nextToken() method. Here’s an example that prints all the names in fullString:

while (st.hasMoreTokens()) 
{
    String name = st.nextToken();
    System.out.println(name);
}

This will print:

Bob
Joe
Lisa
Katie

Split

The Java split command also helps you break strings into pieces in a similar manner as StringTokenizer. You can use either technique to break apart a string. The split command is similar to the technique we will be using in C# for this process, so it is especially good to be familiar with both. Suppose you have the following string that you want to break apart:

String fullString = "Bob, Joe, Lisa, Katie";

As before, suppose you want to extract and print each name. We can specify that the names are separated by commas and spaces, and then get a string array of the remaining tokens (in this case, the names:

String[] tokens = fullString.split(", ");

Now, we can loop through the tokens array and print each value:

for (int i = 0; i < tokens.length; i++) 
{
    System.out.println(tokens[i]);
}

This will print:

Bob
Joe
Lisa
Katie

One key difference between StringTokenizer and split is how the delimeters work. In StringTokenizer, the delimeters are individual characters that separate the information we’re interested in. When we reach a delimeter, we keep stepping through the string discarding characters until we reach a non-delimeter.

In split, we specify what separates the tokens using a regular expression. In the case of our example, it matched the string “, " to our list of names, and used it as a separator. If we had put " ,” instead (space then comma), it would not have separated the names at all, because it would have found no occurrence of a space followed by a comma. So for split, when we provide a string as a separator, we look for that ENTIRE string.

There is a lot more we can do with split using regular expressions, including a generic way to process all numbers, or all words matching a particular pattern. That is beyond the scope of this course, although you will likely use regular expressions in later CIS classes. In this class, we will just provide an exact string to split that we want to process.

Comparing Strings

In this section, we will see how to compare strings. This will let us see if two strings have the same characters (are equal) and how they compare alphabetically (to see if one “comes before” or “comes after” another). When we have compared other types (like ints), we have used ==, <, >, <=, >=, etc. – however, this operators will not work the way we want with strings. When we try to use those operators, we will actually be comparing the memory address of the two strings – we want to compare their characters.

Equality

To see if two strings have the same characters, we will use the equals command. Here is an example:

String s1 = "hello";
String s2 = "hello";
if (s1.equals(s2)) 
{
    System.out.println("same");
}

This example compares the strings s1 and s2. If they contain exactly the same characters, the equals command will evaluate to true. Otherwise, it will evaluate to false. Equals does NOT ignore the case of characters, so it will think that “hello” and “Hello” are not equal.

Ordering alphabetically

To how two strings would be ordered alphabetically, we will use the compareTo command. Here is an example:

String s1 = "apple";
String s2 = "banana";
if (s1.compareTo(s2) < 0) 
{
    System.out.printf("%s comes before %s%n", s1, s2);
}

This example is looking to see if s1 comes alphabetically before s2. Since “apple” comes before “banana”, the if-statement is true. In general, if we do:

s1.compareTo(s2)

The result will be:

0, if s1 equals s2
<0, if s1 comes alphabetically before s2
>0, if s1 comes alphabetically after s2

Examples

In this section, we will work several additional examples of full Java programs that involve string manipulation.

Example 1: encryption

Secret messages (such as secure email, online credit card purchases, online banking, etc.) are often transmitted using encryption. When one of these messages is sent, it is encrypted by altering the message in some way that makes it unrecognizable at face value. The recipient can then “undo” this encryption to get back the original message. The idea is that ONLY the recipient can get back the original message (usually because they know some extra piece of information about how the message was transformed), and that others snooping in will just see gibberish.

In this example, we will write a very basic encryption algorithm. For each letter in the message, we will replace it with the letter that comes three after it in the alphabet. For example, ‘A’ becomes ‘D’, ‘B’ becomes ‘E’, etc. When we get to the end of the alphabet, we will wrap around to the beginning (so ‘Z’ becomes ‘C’, etc.). This program will ask for a message and if the user wants to encrypt or decrypt (““ndo” the encryption), and will then print out the resulting message.

import java.io.*;
public class Encrypt 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        System.out.print("Enter a message: ");
        String msg = s.nextLine();

        System.out.println("Enter (e)ncrypt or (d)ecrypt: ");
        char eOrD = (s.nextLine()).charAt(0);

        String result = "";
        String alpha = "abcdefghijklmnopqrstuvwxyz";

        //this program assumes all lower-case characters
        if (eOrD == 'e') 
        {
            for (int i = 0; i < msg.length(); i++) 
            {
                String cur = msg.substring(0,1);

                //get where that letter is in the alphabet
                int index = alpha.indexOf(cur);

                //shift it down 3 (wrapping around)
                index = (index + 3) % 26;

                //get letter at the new spot, add to result
                cur = alpha.substring(index, index+1);
                alpha += cur;
            }
        }
        else if (eOrD == 'd') {
            for (int i = 0; i < msg.length(); i++) 
            {
                String cur = msg.substring(0,1);

                //get where that letter is in the alphabet
                int index = alpha.indexOf(cur);

                //shift it back 3 (wrapping, making sure not <0)
                index = (index – 3 + 26) % 26;
                
                //get letter at the new spot, add to result
                cur = alpha.substring(index, index+1);
                alpha += cur;
            }
        }
        else 
        {
            System.out.println("Invalid input");
        }

        System.out.printf("Result: %s%n", result);
    }
}

Example 2: print all substrings

In this example, we will write a program that gets an input string, and then prints all possible substrings of that string.

import java.util.*;
public class Substrings 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        System.out.print("Enter a string: ");
        String str = s.nextLine();

        //loop through all starting positions
        for (int i = 0; i < str.length(); i++) 
        {
            //loop through all STOPPING positions if we start at i
            for (int j = i+1; j <= str.length(); j++) 
            {
                //get substring from i up to but not including j
                String piece = str.substring(i,j);
                System.out.println(piece);
            }
        }
    }
}

Example 3: Pig Latin

In this example, we will write a Pig Latin converter, where the user enters a sentence and the program translates it to Pig Latin. The rules we’ll use (there are several variations, but we’ll keep it simple) for converting an English word to Pig Latin are as follows:

• If a word begins with a consonant, the consonant is moved to the end of the word and “ay” is added, like this: “cake” -> “ake-cay”
• If a word begins with a vowel, “way” is added to the end of the word, like this: “is” -> “is-way”

import java.util.*;
//this program assumes letters are lower-case and that words are separated only by spaces
public class PigLatin 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        System.out.println("Enter a sentence: ");
        String str = s.nextLine();
        String result = "";

        //y can be a vowel too, but we’re ignoring this case
        String vowels = "aeiou";

        //get each word
        StringTokenizer tok = new StringTokenizer(str, " ");

        while (tok.hasMoreTokens()) 
        {
            String word = tok.nextToken();
            String first = word.substring(0,1);

            //if word begins with a vowel
            if (vowels.indexOf(first) >= 0) 
            {
                //concatenate "way" to end of word
                result += word + "-way ";
            }
            else 
            {
                //word is a consonant
                String rest = word.substring(1,word.length());
                result += rest + "-" + first + "ay ";
            }
        }
        System.out.printf("In Pig Latin: %s%n", result);
    }
}

The way we are constructing the result string is somewhat inefficient because strings are an immutable type. This means that any time we concatenate onto a string, we are actually creating memory for a new string and copying all the characters over. In class, we will also learn about the StringBuilder type, which we can use to build string results much more efficiently.

File I/O Setup

If we want our program to read from a text file or write to a text file, we need to add two import statements:

import java.io.*;
import java.util.*;

We will also need to add the clause throws IOException to the end of the main method (or, when we start writing multiple methods, to the end of whatever method wants to work with a text file). The main method should instead look like this:

public static void main(String[] args) throws IOException
{

}

(We can similarly put throws IOException at the end of a different method.) The throws IOException clause means that interacting with files can cause some unexpected problems (like if the file isn’t there), but that we’re not going to handle them. Later in the course we will discuss how to handle these problems.

Reading from Text Files

If we want to read information from a text file into a program, we first need to open a connection to the file. We do this by creating a Scanner (like we do to get user input). This time, however, we’ll connect the Scanner to a file:

Scanner s = new Scanner(new File(filename));

Here, filename is a string that is the name of the input file. This file should be stored in the same directory as the class that’s using it. Alternatively, you can specify the absolute path of the file (e.g., “C:\Documents and Settings...”). To read a single line in the file, do this:

String line = s.nextLine();

The first line of the file will be stored in the line variable. If we call nextLine() again, it will read the second line, and so on. To see if you’ve reached the end of the input file, use the hasNext() command. This will return false if we’re at the end of the file, and true otherwise. When you’re done reading from a file, you need to close it:

s.close();

Here’s an example that opens the file “in.txt” and prints every line from the file to the screen:

Scanner s = new Scanner(new File("in.txt"));
while (s.hasNext()) 
{
    String line = s.nextLine();
    System.out.println(line);
}
s.close();

If in.txt looked like this:

Hi
Testing
example

Then our program would print to the terminal:

Hi
Testing
example

You will often read files that have a bunch of information on each line – say, a bunch of names separated by spaces. To process each name, read each line (as shown above), and then use a StringTokenizer to break apart each line.

Writing to Text Files

If we want our program to print information to a text file, we first need to open a connection to that file.:

PrintWriter pw = new PrintWriter((filename);

Here, filename is the name of the text file we want to print to. If this file doesn’t exist, it will be created in the same directory as your code. If it does exist, everything in the file will be overwritten.

Now we can write to the file. Here’s how to write a single line of text (and advance to the next line):

pw.println(stuff);

Here, stuff is the String, int, char, or double that you want to write to the file. This function works exactly like System.out.println. To print a line without advancing to the next line, do:

pw.print(stuff);

When you’re done writing to the file, close your connection:

pw.close();

Closing the file is especially important after you’ve written information to it. When you write to a file, the information doesn’t get immediately written. Instead, it gets stored in a temporary buffer. When the buffer gets full, the entire buffer is written to the file at once. When you close the file, it writes whatever is in the buffer to the file. If you forget to close it, then whatever information was still in the buffer will not get written to the file.

Example

These arrays will hold people’s names and ages, respectively:

String[] names;
int[] ages;

Suppose those arrays have been initialized and filled with data. Suppose also that they are the same length, and that names[i] is a person’s name and ages[i] is the same person’s age. We want to print:

name: age

For each person to the file info.txt. Here’s how:

//open a connection to the file
PrintWriter pw = new PrintWriter("info.txt");

//print name: age for each person
for (int i = 0; i < names.length; i++) 
{
    pw.println(names[i] + ": " + ages[i]);
}

//close the file
pw.close();

Note: we could also use the printf command to print formatted values to an output file, just like we use System.out.printf to print formatted information to the console.

Declaring a Method

This section will discuss the format for declaring a method. All methods must have a return type (the type of result the method is computing and giving back), a name, and a number of parameters (also called arguments – pieces of data that the method needs to perform its calculations).

Syntax

Methods are declared inside the brackets for the class, but outside the brackets for the main method. For example:

public class Example 
{
    //Can declare method(s) here

    public static void main(String[] args) 
    {

    }

    //Can declare method(s) here

    //Can declare as many methods as you want
}

Here is the syntax for declaring a method:

public static returnType name(params) 
{
    //code for method goes here
}