IT 114: Introduction to Java

IT 114: Introduction to Java
Class 23

Topics

Review

Reading a File with Scanner
Reading a Text File
Parsing Files with a Scanner object
Java Largest and Smallest Integers
The Spiderman Principle
Professional Responsibility
Responsibility of IT Professionals
The ACM Code of Ethics and Professional Conduct

New Material

Records
Reading Records from a File
Finding the Average From a File of Records
Looping Through a File More Than Once
Running Programs and the Operating System
How the Interpreter Uses Process Memory
Parameters
Local Variables
Methods Calling Methods
The Variables a Method Can See

Homework 7

Homework 7 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.

Tips and Examples

Review

Reading a File with Scanner

A Scanner object has multiple methods that return data

Method	Description
next()	Reads and returns the next token as a String
nextDouble()	reads and returns a `double` value
nextInt()	reads and returns an `int` value
nextLine()	reads and returns the next line of input as a String

For every one of these methods there is another "next" method that tells you whether there is more data in the file
They are boolean methods that return true if the next thing in the file is of the right type

They will all return false when you reach the end of the file

Method	Description
hasNext()	Returns true if there is another token to be read
hasNextInt()	Returns true if there is another integer token to be read
hasNextDouble()	Returns true if there is another decimal token to be read
hasNextLine()	Returns true if there is another line of text to be read

Reading a Text File

All we have to do to read a file of text is use one of the "has" methods in a while loop

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

public class ReadFile {
    public static void main (String[] args)
        throws FileNotFoundException {
        File file = new File(args[0]);
        Scanner input = new Scanner(file);
        while (input.hasNext()){
            System.out.println();
        }
    }
 }

Parsing Files with a Scanner object

Parsing is breaking up some kind of data stream into individual strings called tokens
The Scanner object has to know where one token ends and the next begins
It does this by looking for delimiters, special strings that mark off the individual tokens
If you don't specify a delimiter, Scanner will use whitespace

Java Largest and Smallest Integers

In a computer all numbers are binary
That means the are represented by a series of 1's and 0'
Each digit is a power of 2

So the number 5 can be written 101

Each binary digit is represented by a single bit of RAM
Three bits can hold the numbers 0 through 7
Four bits can hold the numbers 0 through 15
So the size of a chunk of memory used to store a number determines
How large an integer it can hold
The highest value a Java int can hold is 2147483647
The lowest value a Java int can hold is -2147483648

You can get these values in you Java programs using the Integer.MAX_VALUE and Integer.MIN_VALUE

public class MaxMinInt {
    public static void main (String[] args){
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }
}

$ java MaxMinInt 
2147483647
-2147483648

The Spiderman Principle

Many tools can be used for either good or evil
In general the more powerful the skill, the more important it is that it be used for good
This is why Peter Parker learned the Spiderman Principle
With great power comes great responsibility

Professional Responsibility

We live in a world great complexity
We depend on many services
- Doctors
- Dentists
- Pharmacists
- Accountants
We trust these people because we believe they have a sense of what they should and shouldn't do
That they have a sense of professional responsibility

Responsibility of IT Professionals

Unlike doctors, IT professionals do not have to be licensed
But that does not mean that we do not have professional responsibilities
In this course you will learn skills that most people do not have
This will give you access to information
And in today's world information is power
Recent events have shown that abuse of information can sway elections
Or lead Britain to the economic self-destruction known as Brexit
People with IT skills steal databases with millions of user records
Others use various scams to steal identities and commit fraud
IT people do not have to swear an oath
Yet some people with IT skills have done more damage that any doctor every has

The ACM Code of Ethics and Professional Conduct

Unlike doctors there is no professional organization that sets standards for people in IT
The Association for Computing Machinery, ACM, has a Code of Ethics and Professional Conduct which you will find here
The code list 7 general ethical principles
1. Contribute to society and to human well-being, acknowledging that all people are stakeholders in computing
2. Avoid harm
3. Be honest and trustworthy
4. Be fair and take action not to discriminate
5. Respect the work required to produce new ideas, inventions, creative works, and computing artifacts
6. Respect privacy
7. Honor confidentiality
In the coming classes we will be discussing these principles

New Material

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
A text file containing data usually has one record per line

For example, we might have a file of dates and the highest temperature

$ cat temps.txt 
2017-06-01 67
2017-06-02 71
2017-06-03 69
2017-06-04 88
2017-06-05 74
...

Here the fields are
- Date
- Highest temperature

Reading Records from a File

To work with files containing records, like temps.txt we need to use different Scanner methods
Because we need to read an entire line at each pass through the loop
We will need to use hasNextLine in the while loop header
And nextLine() inside the loop

Like this

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

public class ReadRecords {
    public static void main (String[] args)
        throws FileNotFoundException {
        File file = new File(args[0]);
        Scanner input = new Scanner(file);
        while (input.hasNextLine()){
            System.out.println(input.nextLine());
        }
    }
}

$ java ReadRecords temps.txt
2017-06-01 67
2017-06-02 71
2017-06-03 69
2017-06-04 88
2017-06-05 74
...

But how do we get the values for an individual field?
We could create a Scanner object on the string returned by nextLine
And then use the one of the other "next" methods to read the fields
But there is a simpler way
nextLine returns a string
And the string method split turns the string into an array of type String []
split needs a delimiter to know where one field ends
And the next begins
Here the delimiter is a single space, " "

Here is the code

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();
        }
    }
}

$ java ReadFields temps.txt
2017-06-01 67 
2017-06-02 71 
2017-06-03 69 
2017-06-04 88 
2017-06-05 74
...

Notice the for loop used to print the individual fields for each line
I used System.out.print(); so both fields would appear on the same line
But then I had to use System.out.println(); right after the loop
If I had not done that, the output would be a single line
I also had to print a space, " ", after each field

Otherwise the output would look like this

2017-06-0167 
2017-06-0271 
2017-06-0369 
2017-06-0488 
2017-06-0574
...

Finding the Average From a File of Records

Let's find the average for the temperatures in the file used above
The average is the total divided by the number of entries
So we are going to need two variables which will be initialized to 0
- One to hold the total or all temperature
- The other to count the number of lines
We will then read in the file line by line
Incrementing the count for each line
And adding the second field to the total
Finally we will calculate the average and print it

Here is the code

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

public class AverageTemps {
    public static void main (String[] args)
        throws FileNotFoundException {
        File file = new File(args[0]);
        Scanner input = new Scanner(file);
        String line;
        String [] fields;
        int total = 0;
        int count = 0;
        while (input.hasNextLine()){
            count += 1;
            line   = input.nextLine();
            fields = line.split(" ");
            total += Integer.parseInt(fields[1]);
        }
        System.out.println(total/count);
    }
}

$ java AverageTemps temps.txt 
77

Looping Through a File More Than Once

What if we want to determine the number of days when the temperature was above average?
We need to loop through the file more than once to do this
We loop through it once to get the average
Then we loop through it again to count the days with temperatures above average
But that poses a problem
Because a Scanner object can only read in one direction
It cannot go back to the start of the file
And loop through the lines another time
This means we have to create a new Scanner object for each pass through the file
To make things cleaner, we will create two separate methods
Which are both called by main
- average to compute the average
- days_above to calculate the days above average
The main method will create a File object and use it in a call to both methods
average contains the same code as in the previous example
But it returns the average instead of printing it

Because it creates a Scanner object it must have a throws call in the method header

    static int average(File file)
        throws FileNotFoundException {
        Scanner input = new Scanner(file);
        String line;
        String [] fields;
        int total = 0;
        int count = 0;
        while (input.hasNextLine()){
            count += 1;
            line   = input.nextLine();
            fields = line.split(" ");
            total += Integer.parseInt(fields[1]);
        }
        return total/count;
    }

days_above has much the same structure as average
Except the body of the loop has an if statement
Which updates a count variable if the temperature exceeds the average

It also needs a throws clause in the method header

    static int days_above(File file, int average)
        throws FileNotFoundException {
        Scanner input = new Scanner(file);
        String line;
        String [] fields;
        int days_above = 0;
        int temp;
        while (input.hasNextLine()){
            line   = input.nextLine();
            fields = line.split(" ");
            temp   = Integer.parseInt(fields[1]);
            if (temp > average) {
                days_above += 1;
            }
        }
        return days_above;
    }
}

The main method calls both methods

And prints the result

public static void main (String[] args)
        throws FileNotFoundException {
        File file = new File(args[0]);

        System.out.println(days_above(file, average(file)));
    }

You will find the complete program here
When we run it, we get
```
$ java DaysAbove temps.txt 
13
```

Running Programs and the Operating System

There is a special part of the operating system that deals directly with hardware
Things like the processor, RAM and discs
This program is called the kernel and it is always running in RAM
Programs need to interact with the hardware
They need to read from a file
Or created directories
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

Most methods need information from the method call to do their work
They do this using 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