IT 114: Introduction to Java

IT 114: Introduction to Java
Class 24

Topics

Review

Records
Reading Records from a File
Running Programs and the Operating System
How the Interpreter Uses Process Memory
Parameters
Local Variables
Methods Calling Methods
The Variables a Method Can See

New Material

Reading a File More Than Once
Storing Values Read from a File
ArrayLists
Creating an ArrayList Object
Loading Values into an ArrayList
Looping Through an ArrayList
Classes for Primitive Values
Creating Objects of Class Integer
Creating an ArrayList of Numbers
Creating an ArrayList from a File
Working with an ArrayList of Numbers
Multiple Passes Through an ArrayList
Being a Good Citizen

Homework 8

Homework 8 is due this Sunday at 11:59 PM.

You will find the assignment here.

If you have a problem or a question, make a post on the Class Discussion Area.

Review

Records

For any sporting event involving teams we have at least 5 pieces of information
- Date
- Home team
- Opposing team
- Home team score
- Opposing team score
The collection of data about a specific event is called a record
The individual pieces of data within a record are called fields

Reading Records from a File

To work with a text file containing m any records on a line we can use a while loop like this

Scanner input = new Scanner(file);
while (input.hasNextLine()){
	System.out.println(input.nextLine());
}

To break up the line into field values we can use the split() string method on a line

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

public class ReadFields {
    public static void main (String[] args)
        throws FileNotFoundException {
        File file = new File(args[0]);
        Scanner input = new Scanner(file);
        String line;
        String [] fields;
        while (input.hasNextLine()){
            line   = input.nextLine();
            fields = line.split(" ");
            for (int i = 0; i < fields.length; i++)
                System.out.print(fields[i] + " ");
            System.out.println();
        }
    }
}

Running Programs and the Operating System

There is a special part of the operating system that deals directly with hardware
This program is called the kernel and it is always running in RAM
Programs need to interact with the hardware
They cannot do this by themselves
Instead they have to ask the kernel to do it for them
When you are working at the command line you are running a special type of program called the shell
The shell allows you to ask the kernel to run a program for you
A running program is called a process
And it has it's own bit of memory
No other program can use this memory and this keeps programs from interfering with each other
Each running Java program runs in its own bit of RAM

How the Interpreter Uses Process Memory

The Java interpreter runs inside the RAM for the program process
It goes through the lines of the program statement by statement
Starting with the main method
Each method gets it's own section of RAM to do its work
The variables for each method are stored in this section of RAM
The memory given to the method disappears when the method quits
This means that the variables inside the method are not permanent
Giving each method its own space in memory keeps the method isolated from other parts of the program

Parameters

A parameter is a variable that only exists in the method's memory
But it gets its starting value from the arguments of the method call
Here is a program that contains a method, cheer

Which is called by the main method

public class Cheer1 {
    public static void main (String[] args){
        cheer("Sox");
    }

    public static void cheer(String team){
        System.out.println("Go " + team + "!");
    }
}

$ java Cheer1 
Go Sox!

Let's see what happens in memory as the program runs
When the main method is loaded into memory we have

When the main method calls cheer this method gets its own memory space

The variable team is a parameter
It is a variable created inside the memory space for cheer
It gets its value from the method call
Here is the picture in memory

The memory space for cheer disappears once it finishes

Local Variables

Method variables only exist when the method is run
And they are contained in the memory space for that memory call
These variables are said to be local variables
Local variables are invisible outside the method
Parameters are local variables
But they are special because they get their values from the arguments in the method call
But methods can also have variables that are not parameters
Here is another program with a different version of the cheer method
Here team is a local variable
But it is not a parameter

Because no parameter is declared in the method header

public class Cheer2 {
    public static void main (String[] args){
        cheer();
    }

    public static void cheer(){
        String team = "Sox";
        System.out.println("Go " + team + "!");
    }
}

$ java Cheer2 
Go Sox!

The picture in memory when main is first run is

When we call cheer it gets its own memory space

But nothing changes

Until we declare a local variable

Methods Calling Methods

Each time a one method calls another method a new section of RAM is created for each method to do its work
These sections of memory stack up one on top of the other
Until the last method finishes
Then each method in turn finishes its work and give up it piece of RAM

Let's see what happens in RAM when we run the following code

public class Cheer3 {
    public static void main (String[] args){
        print_cheer("Sox");
    }

    public static void print_cheer(String team){
        System.out.println(cheer(team));
    }

    public static String cheer(String team){
        return "Go " + team + "!";
    }
}

First we have only the main method in RAM

Then print_cheer is called
And it gets its own memory space

Then the parameter team is initialized

And cheer is called

cheer has its own cheer parameter
Which is now initialized

When cheer finishes it looses its section of RAM

The same thing happens when print_cheer ends

The Variables a Method Can See

Every method gets its own section of RAM for its own variables
No method can see the variables in another method's RAM space
So you can have two variables with the same name in two different methods with different value

Here is an example

public class Cheer4 {
    public static void main (String[] args){
        String team = "Pats";
        cheer(team);
        System.out.println(team);
    }

    public static void cheer(String team){
        System.out.println("Go " + team + "!");
    }
}

$ java Cheer4 
Go Pats!
Pats

Here is the picture in memory when cheer is running

New Material

Reading a File More Than Once

As you saw from the last class, some problems force you to go through the data in a file more than once
For small files this is not a problem
But but for very long lists, reading a file twice would make the code very inefficient
Computers are very fast, but some operation are faster than others
Operations that use RAM and the CPU are the fastest
But disk operations are much slower
And files live on disks
So operations with files slow down your code
That means you want to do this as little

Storing Values Read from a File

To make your programs efficient you want to read in a file once
And store the information in RAM
The easiest way to do this is to read in values from the file into an array
But this poses a major problem
You need to know the size of an array to declare it
And you cannot know the size you need until you have read the file

ArrayLists

What we really need is an array that we can expand and contract as needed
Java provides a class which will do this
It is called an ArrayList
An ArrayList object is dynamic so you do not have to specify a size when creating them
The data contained in an ArrayList object is actually stored in a an array
When first created an ArrayList object contains an array of a certain size
But if the object needs more space it simply creates a bigger array
Then is copies all the data in the original array into this new array
This is all done automatically
You do not have to do anything to make this happen
You can treat an ArrayList object as a list that expands and contracts as needed

Creating an ArrayList Object

An Array object can only hold data of one data type
And that data type must appear in the declaration of the array variable
This is also true of an ArrayList object
But there is one important difference
Remember, there are two groups of data types
- Primitive data types
- Classes
Primitive data types can only hold one piece of information
And they do not have methods
Primitive data types include
- int
- double
- char
- boolean
The data types used when creating an ArrayList object must be classes
To create an ArrayList of strings you would write
```
ArrayList<String> list = new ArrayList<>();
```
The use of angle brackets, < and >, is something you have not seen before
A full explanation of why they are needed is beyond the scope of this course
But will touch briefly on this below
The ArrayList class is contained in the java.util package
So you must have the following import statement at the top of your code
```
import java.util.ArrayList;
```

Loading Values into an ArrayList

When you first create an ArrayList object it has no values
This is different from an Array object where all elements are a default value
The simplest way to load a value into an ArrayList object is to use the add method
This method adds a single value to the end of the list

Here is an example

import java.util.ArrayList;

public class ArrayListString {
    public static void main (String[] args){
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < args.length; i++){
            list.add(args[i]);
        }
        System.out.println(list);
    }
}

$ java ArrayListString foo bar blecth
[foo, bar, blecth]

Notice that you can print an ArrayList object with System.out.println()

Looping Through an ArrayList

Just as with arrays, you can using indexes to loop through the values in an ArrayList object
Once again, the indexes start with 0
And end with one less than the length of the ArrayList

The size method returns the length of its ArrayList

import java.util.ArrayList;

public class ArrayListString2 {
    public static void main (String[] args){
        ArrayList<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        System.out.println("The length of the list is " + list.size);
    }
}

$ java ArrayListString2
The length of the list is 5

To get the value at any index position, we use the get method

With size and get we can easily write a for loop to move through the values

import java.util.ArrayList;

public class ArrayListString3 {
    public static void main (String[] args){
        ArrayList<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        for (int i = 0; i < list.size(); i++){
            System.out.println(list.get(i));
        }
    }
}

$ java ArrayListString3
one
two
three
four
five

Classes for Primitive Values

ArrayLists hold objects
That's fine when we want to work with strings
But what about numbers?
Variables of type int and double are primitives not objects
To deal with situations like this Java has wrapper classes
These classes contain, or "wrap", a single primitive value
Such as int or double

So instead of writing

ArrayList<int> list = new ArrayList<>();

we write

ArrayList<Integer> list = new ArrayList<>();

These wrapper classes also contain useful static methods
We used one of these when we needed to convert a string of text digits into values of type int
We called the static method parseInt
```
int num = Integer.parseInt(args[0]);
```

Creating Objects of Class Integer

You can create an Integer object with a statement similar to the way we created a

public class IntegerCreate {
    public static void main (String[] args){
        Integer number = new Integer(5);
        System.out.println(number);
    }
}

$ java IntegerCreate
5

But this is very cumbersome
New versions of Java come out from time to time
These versions introduce new features to make life easier for Java programmers
One such feature was called "autoboxing"
It allows us to create and initialize an Integer object the same way we create and initialize a value of type int
So just as we can create an int variable like this
```
int number = 5;
```
we can create an Integer variable like this
```
Integer number = 5;
```

This makes it easier to use Integer objects

public class IntegerCreate2 {
    public static void main (String[] args){
        Integer number = 5;
        System.out.println(number);
    }
}

$ java IntegerCreate2.java 
5

Creating an ArrayList of Numbers

Autoboxing makes using an ArrayList object of integers much easier
We can create numbers the usual way
Say in a for loop
And simply use the add method to store them in the object

Here is an example

import java.util.ArrayList;

public class ArrayListInteger {
    public static void main (String[] args){
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++){
            list.add(i);
        }
        System.out.println(list);
    }
}

$ java ArrayListInteger
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Creating an ArrayList from a File

Reading a file into an ArrayList object of numbers is straight forward
Create an ArrayList object
Create Scanner object on a file
Loop through the file with using hasNextInt method on the Scanner object

Here is an example

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

public class ArrayListIntegerFile {
    public static void main (String[] args)
        throws FileNotFoundException {
        ArrayList<Integer> numbers = new ArrayList<>();
        File file = new File(args[0]);
        Scanner input = new Scanner(file);
        while (input.hasNextInt()){
            numbers.add(input.nextInt());
        }
        System.out.println(numbers.size());
    }
}

$ java ArrayListIntegerFile numbers.txt 
30

Working with an ArrayList of Numbers

Once we create an ArrayList object from a file of numbers, we can process it similar to the way we work with arrays
Set a variable total to 0
Loop through the list adding entries to total using the get method
Divide total by the size of the list

This is best done in a separate average method

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

public class AverageArrayList {
    public static void main (String[] args)
        throws FileNotFoundException {
        ArrayList<Integer> numbers = new ArrayList<>();
        File file = new File(args[0]);
        Scanner input = new Scanner(file);
        while (input.hasNextInt()){
            numbers.add(input.nextInt());
        }
        System.out.println(average(numbers));
    }

    public static int average(ArrayList<Integer> numbers){
        int total = 0;
        for (int i = 0; i < numbers.size(); i++){
            total += numbers.get(i);
        }
        return total/numbers.size();
    }
}

$ java AverageArrayList numbers.txt 
26

Multiple Passes Through an ArrayList

Once you have an ArrayList object holding numbers, you can run as many operations on it as you like

Let's add a method to the code above to count now many numbers are above average

    public static int above_average(ArrayList<Integer> numbers, int average){
        int numbers_above = 0;
        for (int i = 0; i < numbers.size(); i++){
            if (numbers.get(i) > average) {
                numbers_above += 1;
            }
        }
        return numbers_above;
    }

Similarly we can create a method to count how many numbers are below average

    public static int below_average(ArrayList<Integer> numbers, int average){
        int numbers_below = 0;
        for (int i = 0; i < numbers.size(); i++){
            if (numbers.get(i) < average) {
                numbers_below += 1;
            }
        }
        return numbers_below;
    }

You can see the full code here

Being a Good Citizen

The first of the general ethical principles of the ACM is

Contribute to society and to human well-being, acknowledging 
that all people are stakeholders in computing

I think this breaks down into two responsibilities
- Make the world a better place
- Make sure what you do benefits everyone
Every day technology makes our lives easier
Weather reports help us plan our day
Remote connections allow us to work from anywhere on the planet
We can get detailed directions to anywhere we want to go
We are lucky to live when we do and enjoy these conveniences
We enjoy these benefits because the people who came before us made it happen
We owe them a debt
But the debt is not to them, but to those who come after us
We repay our debt by working on improvements that will benefit future generations
But we must be sure that the benefits go to all levels of society
Not just to the affluent and well-connected
Certain groups do not enjoy the same benefits of technology as the majority
IT work is well paid
And those who work in it tend to associate with other well paid people
This can make the important needs of some people invisible
We must not let our good fortune blind us to the needs of others
This is particularly important now when immigrants are vilified
When people of color are considered less than human by some
If you are not part of the solution, you are part of the problem