Using Text Files

A weather club records the high temperature every day. So far, every program you have written got its data from values typed into the code, such as int[] temps = {72, 68, 75};, or from a Scanner built on a string. Both have the same problem: to use a new week of temperatures, someone has to edit the program and run it again. And when the program ends, every variable and every array disappears. Nothing the program held survives to the next run.

Real programs keep their data somewhere else: in a file. A file is storage for data that persists, meaning it stays saved when no program is running, even after the computer is turned off. A program can open the file while it runs and pull the data out. The club can add next week’s temperatures to the file without touching the program at all, and the same program will read whatever the file holds that day.

Think of the program as a recipe and the file as the pantry. The recipe says what to do with the ingredients; the pantry holds the ingredients between meals. You can restock the pantry without rewriting the recipe.

This chapter uses text files: files that hold ordinary characters you could read in any text editor, arranged in lines. Here is the club’s file, named temps.txt. It is shown exactly as it is stored:

72 68 75
80 77

To Java, this is not five numbers yet. It is a sequence of characters: a 7, a 2, a space, a 6, and so on, with a line break after 75 and another after 77. A Scanner turns those characters into values the same way it did for strings in Topic 1.14: it splits the text into tokens, chunks separated by whitespace. Whitespace means spaces, tabs, and line breaks; all three count as separators, and several in a row count as one separator.

72
68    75

80 77

Lee 12
  Kim   9 true
Ana

You already know how to pull tokens out of text with a Scanner. The only new step is pointing the Scanner at a file instead of at a string or the keyboard. Java uses two classes for this.

• The File class represents a file by its name. The constructor File(String pathname) takes the file’s name, called its pathname, as a String. A plain name such as "temps.txt" means “the file with this name in the folder the program runs from.”
• The Scanner class has a constructor Scanner(File f) that takes a File object and connects the scanner to that file for reading.

Together, these two steps open the file: they make its contents available for the program to read. After that, nextInt, next, and the other methods work exactly as they did on a string.

Both File and the exception class IOException (explained in 4.6.3) live in the java.io package, the part of the Java library for input and output. Scanner lives in java.util. None of them are in java.lang, so, as in Topic 1.7, each needs an import statement at the top of the file.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class FirstFileRead
{
    public static void main(String[] args) throws IOException
    {
        File dataFile = new File("temps.txt");
        Scanner input = new Scanner(dataFile);
        int monday = input.nextInt();
        int tuesday = input.nextInt();
        System.out.println("Monday: " + monday);
        System.out.println("Tuesday: " + tuesday);
        input.close();
    }
}

Monday: 72
Tuesday: 68

The File variable on line 9 is used only once, to build the scanner. Most programs skip the variable and create the File object right inside the Scanner constructor call. This version does that and reads one more value:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class OneLineOpen
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("temps.txt"));
        int first = input.nextInt();
        int second = input.nextInt();
        int third = input.nextInt();
        System.out.println("Sum of first three: " + (first + second + third));
        input.close();
    }
}

Sum of first three: 215

Line 9 evaluates new File("temps.txt") first, producing a reference to a new File object, and passes that reference straight to new Scanner(...). The result is the same open file as before. Lines 10 to 12 read 72, 68, and 75, and 72 + 68 + 75 is 215. The rest of this chapter uses this one-line form.

Earlier topics built scanners on System.in to read the keyboard. Reading keyboard input is not part of the AP exam; reading files is. That is why this chapter reads files; only the split examples in 4.6.8 work on plain strings.

import java.util.Scanner;

public class ScannerOnName
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("temps.txt");
        String first = input.next();
        System.out.println("First token: " + first);
        input.close();
    }
}

First token: temps.txt

import java.io.IOException;
import java.util.Scanner;

public class MissingFileImport
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("temps.txt"));
        System.out.println(input.nextInt());
        input.close();
    }
}

MissingFileImport.java:8: error: cannot find symbol
  symbol:   class File

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class PauseTempsDiff
{
    public static void main(String[] args) throws IOException
    {
        Scanner reader = new Scanner(new File("temps.txt"));
        int a = reader.nextInt();
        int b = reader.nextInt();
        int c = reader.nextInt();
        int d = reader.nextInt();
        System.out.println(d - a);
        System.out.println(b + c);
        reader.close();
    }
}

8
143

Reading a string can never fail to start: the string is right there in the code. A file is different. The name might be misspelled, the file might have been moved or deleted, or it might never have been created. When the program tries to open a file that is not there, it cannot continue normally.

Java will not let you ignore that possibility. When code uses the File class to open a file, Java requires the method to say what should happen if the file cannot be opened. In this course, you do that by writing throws IOException at the end of the opening method’s header. An IOException is the kind of exception Java uses for input and output problems, such as a missing file. Writing throws IOException in the header announces “this method might run into an input or output problem, and if it does, it will not handle it; it will pass it along.” For main, passing it along means the program stops.

Why does Java insist? For most mistakes, such as dividing by zero, Java trusts you to write correct code. A missing file is not a mistake in the code; it depends on what is on the disk when the program runs, so even correct code can hit it. Java makes you acknowledge that risk where everyone reading the method header can see it.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class NoThrows
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(new File("temps.txt"));
        System.out.println(input.nextInt());
        input.close();
    }
}

NoThrows.java:9: error: unreported exception FileNotFoundException; must be caught or declared to be thrown

Now suppose the code is correct but the file is not there. This program has a typo: it asks for temp.txt, but the file is named temps.txt.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class MissingFile
{
    public static void main(String[] args) throws IOException
    {
        System.out.println("Opening the file...");
        Scanner input = new Scanner(new File("temp.txt"));
        System.out.println("First value: " + input.nextInt());
        input.close();
    }
}

The program compiles, because the compiler does not look at what files exist. When it runs, line 9 prints its message, then line 10 tries to open the file and fails:

Opening the file...
Exception in thread "main" java.io.FileNotFoundException: temp.txt (No such file or directory)

(The part in parentheses varies between computers and Java versions.) Line 11 never runs. Because main declared throws IOException, the exception is passed out of main, and the program terminates. The fix is to use the file’s real name, temps.txt.

Notice where the crash happens: at the Scanner constructor, which is where Java actually tries to open the file. Creating a File object only records a name, so new File("temp.txt") by itself succeeds even when no such file exists.

Methods that call file-reading methods

The rule applies to every method that opens a file, not just main. Here a helper method opens the file, so its header has throws IOException. main calls it, so main needs it as well:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class HelperRead
{
    public static int firstValue(String fileName) throws IOException
    {
        Scanner input = new Scanner(new File(fileName));
        int value = input.nextInt();
        input.close();
        return value;
    }

    public static void main(String[] args) throws IOException
    {
        System.out.println("First temperature: " + firstValue("temps.txt"));
    }
}

First temperature: 72

Take away throws IOException from line 15 and the program no longer compiles:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class HelperMainNoThrows
{
    public static int firstValue(String fileName) throws IOException
    {
        Scanner input = new Scanner(new File(fileName));
        int value = input.nextInt();
        input.close();
        return value;
    }

    public static void main(String[] args)
    {
        System.out.println("First temperature: " + firstValue("temps.txt"));
    }
}

HelperMainNoThrows.java:17: error: unreported exception IOException; must be caught or declared to be thrown

firstValue’s header warns that calling it might produce an IOException. Line 17 calls it, so main faces the same risk and must declare it too. The warning travels up to every caller.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class PauseMissingScores
{
    public static void main(String[] args) throws IOException
    {
        System.out.println("Start");
        File scores = new File("scores.txt");
        System.out.println("File object made");
        Scanner input = new Scanner(scores);
        System.out.println("Reading");
        input.close();
    }
}

Files usually mix kinds of data. A game might save each player as a name, a level, an accuracy percentage, and whether the player is online, all in one line. To use those values, the program has to read each token as the right type: the name as text, the level as a whole number, and so on.

You have met most of the reading methods already. Here is the full set of token readers on the AP Java Quick Reference:

Each of these skips any whitespace, reads one token, and moves the scanner past it. They never return the whitespace itself. nextBoolean is the only new one: it turns the token true into the boolean value true and false into false.

Maya 17 88.5 true

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class ReadPlayer
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("player.txt"));
        String name = input.next();
        int level = input.nextInt();
        double accuracy = input.nextDouble();
        boolean online = input.nextBoolean();
        System.out.println("Name: " + name);
        System.out.println("Level: " + level);
        System.out.println("Accuracy: " + accuracy);
        System.out.println("Online: " + online);
        input.close();
    }
}

Name: Maya
Level: 17
Accuracy: 88.5
Online: true

Now change only the spacing. player-spread.txt holds the same four tokens scattered over four lines, with extra spaces and an empty line:

Maya
   17

88.5      true

ReadPlayerSpread is ReadPlayer with only the file name changed:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class ReadPlayerSpread
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("player-spread.txt"));
        String name = input.next();
        int level = input.nextInt();
        double accuracy = input.nextDouble();
        boolean online = input.nextBoolean();
        System.out.println("Name: " + name);
        System.out.println("Level: " + level);
        System.out.println("Accuracy: " + accuracy);
        System.out.println("Online: " + online);
        input.close();
    }
}

Name: Maya
Level: 17
Accuracy: 88.5
Online: true

The output is identical. Every token reader skips all whitespace, including line breaks and blank lines, before its token. For token reading, only the order of the tokens matters.

One more variation: nextDouble accepts a whole number. Reading the first token of temps.txt with nextDouble returns 72.0, a double:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class WholeAsDouble
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("temps.txt"));
        double first = input.nextDouble();
        System.out.println(first);
        input.close();
    }
}

72.0

The reverse is not true. nextInt will not accept 88.5; it does not round or drop the decimal part.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class WrongOrder
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("player.txt"));
        int level = input.nextInt();
        String name = input.next();
        System.out.println(name + " is level " + level);
        input.close();
    }
}

Exception in thread "main" java.util.InputMismatchException

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class BooleanYes
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("answer.txt"));
        boolean agreed = input.nextBoolean();
        System.out.println(agreed);
        input.close();
    }
}

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class PauseTokens
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("player.txt"));
        String who = input.next();
        int level = input.nextInt();
        double accuracy = input.nextDouble();
        boolean online = input.nextBoolean();
        if (online)
        {
            System.out.println(who + " is online");
        }
        System.out.println(accuracy + level);
        input.close();
    }
}

Maya is online
105.5

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class TooBigInt
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("city.txt"));
        String city = input.next();
        int population = input.nextInt();
        System.out.println(city + ": " + population);
        input.close();
    }
}

roster.txt lists club members, one full name per line:

Ada Lovelace
Grace Hopper
Alan Turing

Each name contains a space. Token readers treat that space as a separator, so next() would split every name in two. When each line of a file is one record, you want the whole line at once.

That is what nextLine() does, as you saw in Topic 1.4: it returns everything from the scanner’s current place up to the end of the line, spaces included, as a String. The line break itself is not part of the result; the scanner moves past it to the start of the next line.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class ReadRoster
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("roster.txt"));
        String first = input.nextLine();
        String second = input.nextLine();
        String third = input.nextLine();
        System.out.println("1: " + first);
        System.out.println("2: " + second);
        System.out.println("3: " + third);
        input.close();
    }
}

1: Ada Lovelace
2: Grace Hopper
3: Alan Turing

Now change one thing: read the same file with next() instead of nextLine(). Nothing else in the program changes.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class ReadRosterNext
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("roster.txt"));
        String first = input.next();
        String second = input.next();
        String third = input.next();
        System.out.println("1: " + first);
        System.out.println("2: " + second);
        System.out.println("3: " + third);
        input.close();
    }
}

1: Ada
2: Lovelace
3: Grace

next() stops at any whitespace, so the space inside Ada Lovelace ends the first token. Three calls get through only a name and a half. Side by side:

Dune,Frank Herbert,1965
Kindred,Octavia Butler,1979
Hatchet,Gary Paulsen,1986

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class PauseBookLine
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("books.txt"));
        String line = input.nextLine();
        line = input.nextLine();
        System.out.println(line.length());
        System.out.println(line.substring(0, 7));
        input.close();
    }
}

27
Kindred

Every program so far knew exactly how many values the file held. But the point of a file is that its contents can change: the weather club adds a temperature every day. A program that makes exactly five nextInt() calls will miss the sixth day, and if a file has only four values, a fifth call will crash. The program needs to ask, before each read, “is there anything left?”

hasNext() answers that question. It returns true if the scanner has another token to read and false if only whitespace (or nothing) is left. It does not read anything or move the scanner; it only looks ahead.

That makes it a natural condition for a while loop (Topic 2.7): keep reading while there is something to read.

while (input.hasNext())
{
    // read one value and use it
}

Each pass checks for more data, reads one item, and processes it. When the last item has been read, hasNext() returns false and the loop ends, whether the file held five values or five hundred.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class SumTemps
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("temps.txt"));
        int total = 0;
        int count = 0;
        while (input.hasNext())
        {
            int temp = input.nextInt();
            total += temp;
            count++;
        }
        input.close();
        System.out.println("Readings: " + count);
        System.out.println("Total: " + total);
        System.out.println("Average: " + (double) total / count);
    }
}

Readings: 5
Total: 372
Average: 74.4

The same loop shape works with nextLine(). This program numbers every line of roster.txt:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class NumberedRoster
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("roster.txt"));
        int lineNumber = 1;
        while (input.hasNext())
        {
            String line = input.nextLine();
            System.out.println(lineNumber + ". " + line);
            lineNumber++;
        }
        input.close();
    }
}

1. Ada Lovelace
2. Grace Hopper
3. Alan Turing

Each pass reads one whole line. After Alan Turing nothing but a line break remains, so hasNext() is false and the loop stops.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class FixedCountLoop
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("temps.txt"));
        for (int day = 1; day <= 6; day++)
        {
            System.out.println("Day " + day + ": " + input.nextInt());
        }
        input.close();
    }
}

Day 1: 72
Day 2: 68
Day 3: 75
Day 4: 80
Day 5: 77
Exception in thread "main" java.util.NoSuchElementException

int words = 0;
while (input.hasNext())
{
    words++;
}

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class PauseAboveCount
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("temps.txt"));
        int warmDays = 0;
        int last = 0;
        while (input.hasNext())
        {
            last = input.nextInt();
            if (last > 74)
            {
                warmDays++;
            }
        }
        input.close();
        System.out.println(warmDays + " " + last);
    }
}

3 77

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class WarmPrintWrong
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("temps.txt"));
        while (input.hasNext())
        {
            if (input.nextInt() > 74)
            {
                System.out.println(input.nextInt());
            }
        }
        input.close();
    }
}

int temp = input.nextInt();
if (temp > 74)
{
    System.out.println(temp);
}

While a program has a file open, the computer’s operating system keeps track of it, and an open file can stay tied up until the program ends. A program that opens many files, or runs for a long time, should hand each file back as soon as it is finished with it. It is like returning a library book when you are done instead of keeping it until you move away.

The method close() does this. Calling input.close() closes the scanner and the file it was reading. After that call, the scanner cannot be used again.

Where does close() go? After the last read, which in a hasNext() loop means after the loop, as in SumTemps line 18. Closing is good practice in every program that reads a file, even short ones.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class ReadAfterClose
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("temps.txt"));
        int first = input.nextInt();
        input.close();
        System.out.println("First: " + first);
        int second = input.nextInt();
        System.out.println("Second: " + second);
    }
}

First: 72
Exception in thread "main" java.lang.IllegalStateException: Scanner closed

The second most common placement mistake is putting close() inside a loop. Then the first pass closes the file, and the loop’s next hasNext() check fails. You will debug that program in the review questions.

Many data files store one record per line, with the fields separated by a punctuation mark. books.txt uses commas:

Dune,Frank Herbert,1965
Kindred,Octavia Butler,1979
Hatchet,Gary Paulsen,1986

nextLine() can read "Dune,Frank Herbert,1965" as one string, but the program wants the title, the author, and the year separately. Token readers will not help: they split at spaces, which would cut Frank Herbert in half and leave the commas attached. You could find each comma with indexOf and cut with substring (Topic 1.15), but that is a lot of index arithmetic for every line.

The String method split does this in one call. Its header is String[] split(String del). The parameter is the delimiter, the string that separates the pieces. split returns a new array of Strings (Topics 4.3 to 4.5) holding the pieces between the delimiters, in order. The delimiters themselves are not included in any piece, and the original string is unchanged, as always for strings.

String line = "Dune,Frank Herbert,1965";
String[] parts = line.split(",");
System.out.println(parts.length);
System.out.println(parts[0]);
System.out.println(parts[1]);
System.out.println(parts[2]);

index:   0        1                2
piece:   "Dune"   "Frank Herbert"  "1965"

3
Dune
Frank Herbert
1965

Change only the delimiter and the pieces change completely:

String line = "Dune,Frank Herbert,1965";
String[] bySpace = line.split(" ");
System.out.println(bySpace.length);
System.out.println(bySpace[0]);
System.out.println(bySpace[1]);
String[] bySemicolon = line.split(";");
System.out.println(bySemicolon.length);
System.out.println(bySemicolon[0]);

2
Dune,Frank
Herbert,1965
1
Dune,Frank Herbert,1965

Split on " ", the line has one space, so there are two pieces, and the commas stay inside them. Split on ";", which never appears, there is nothing to split around, so the array has one element: the whole string. split always returns an array with at least one element.

Two more rules show up in real data:

• The delimiter is matched exactly. Splitting "Ada, 92" on "," leaves the space at the start of the second piece. Splitting on ", " (comma and space) removes both.
• Two delimiters in a row make an empty piece. In "red,,blue,green", nothing sits between the two commas, so that piece is the empty string "".

String entry = "Ada, 92";
String[] pieces = entry.split(",");
System.out.println("[" + pieces[1] + "]");
String[] fixed = entry.split(", ");
System.out.println("[" + fixed[1] + "]");

[ 92]
[92]

The brackets are printed around each piece so you can see the space. The first piece holds three characters, a space and 92; the second holds just 92.

Now put split to work on a file. Read each line with nextLine() in a hasNext() loop, then split it:

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class BookList
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("books.txt"));
        while (input.hasNext())
        {
            String line = input.nextLine();
            String[] parts = line.split(",");
            String title = parts[0];
            String year = parts[2];
            System.out.println(title + " (" + year + ")");
        }
        input.close();
    }
}

Dune (1965)
Kindred (1979)
Hatchet (1986)

Each pass: line 12 reads one record, line 13 splits it into a three-element array, and lines 14 and 15 pick out the title at index 0 and the year at index 2. A new array is built on every pass, sized to fit that line’s pieces.

String colors = "red,,blue,green";
String[] parts = colors.split(",");
System.out.println(parts.length);
System.out.println("[" + parts[1] + "]");
System.out.println(parts[parts.length - 1]);

4
[]
green

Two programs combine the chapter’s tools with arrays from Topics 4.3 to 4.5.

Reading numbers into an array

grades.txt stores how many grades follow, then the grades:

5
88 92 75 100 81

Storing the count first is a common file layout: it tells the program how big an array to create before reading.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class GradeReport
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("grades.txt"));
        int count = input.nextInt();
        int[] grades = new int[count];
        for (int i = 0; i < grades.length; i++)
        {
            grades[i] = input.nextInt();
        }
        input.close();

        int total = 0;
        int highest = grades[0];
        for (int grade : grades)
        {
            total += grade;
            if (grade > highest)
            {
                highest = grade;
            }
        }
        System.out.println("Grades read: " + grades.length);
        System.out.println("Average: " + (double) total / grades.length);
        System.out.println("Highest: " + highest);
    }
}

Grades read: 5
Average: 87.2
Highest: 100

The file can be closed as early as line 16 because the data now lives in the array, and the analysis loop never touches the scanner. A for loop is fine for the reading here, because the file itself said how many grades there are. Without that count, a hasNext() loop would be needed, and since an array’s size is fixed when it is created, the program would have no way to know how big to make the array in advance.

Splitting records and filtering

signups.txt stores each student’s name and chosen club:

Ada Lovelace,chess
Grace Hopper,robotics
Alan Turing,chess
Katherine Johnson,math
Mark Dean,chess

The program lists everyone who chose chess and counts them.

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class ChessSignups
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("signups.txt"));
        int chessCount = 0;
        while (input.hasNext())
        {
            String line = input.nextLine();
            String[] parts = line.split(",");
            if (parts[1].equals("chess"))
            {
                System.out.println(parts[0]);
                chessCount++;
            }
        }
        input.close();
        System.out.println(chessCount + " signed up for chess");
    }
}

Ada Lovelace
Alan Turing
Mark Dean
3 signed up for chess

The names have spaces, so the program reads lines (nextLine), not tokens, and never mixes the two. Line 15 uses equals, not ==, to compare string contents (Topic 2.6). The close() on line 21 comes after the loop, once every line has been read.

Each of these was taught in context above. This table collects what Java reports, so you can recognize the message when it appears.

• A file stores data that persists when no program is running. A program reads it while running, so the data can change without changing the code.
• To open a file, import java.io.File, java.io.IOException, and java.util.Scanner, then write new Scanner(new File("name.txt")). Every method that opens a file, and every method that calls one, needs throws IOException; if the file cannot be opened, the program terminates with a FileNotFoundException.
• nextInt, nextDouble, nextBoolean, and next skip whitespace and read one token of their type, throwing an InputMismatchException on a mismatch. nextLine reads the rest of a line, spaces included. Use one style or the other on a given file.
• A while (input.hasNext()) loop reads a file of any length; every pass must read something. Call close() after the last read.
• split(del) returns a String array of the pieces between delimiters, with the delimiters removed. Pair it with nextLine to read records whose fields are separated by commas or other plain punctuation.

import java.io.IOException;
import java.util.Scanner;

public class MissingFileImport
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("temps.txt"));
        System.out.println(input.nextInt());
        input.close();
    }
}

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class LongWords
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("words.txt"));
        int longCount = 0;
        while (input.hasNext())
        {
            String word = input.next();
            if (word.length() > 4)
            {
                System.out.println(word);
                longCount++;
            }
        }
        input.close();
        System.out.println("Long words: " + longCount);
    }
}

quick
brown
jumps
Long words: 3

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class RevTokenOrder
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("player.txt"));
        String name = input.next();
        double first = input.nextDouble();
        System.out.println(name + " " + first);
        int second = input.nextInt();
        System.out.println(second);
        input.close();
    }
}

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class CloseInsideLoop
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("roster.txt"));
        while (input.hasNext())
        {
            String name = input.nextLine();
            System.out.println("Welcome, " + name);
            input.close();
        }
    }
}

while (input.hasNext())
{
    String name = input.nextLine();
    System.out.println("Welcome, " + name);
}
input.close();

Welcome, Ada Lovelace
Welcome, Grace Hopper
Welcome, Alan Turing

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class RevAuthors
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("books.txt"));
        String result = "";
        while (input.hasNext())
        {
            String[] parts = input.nextLine().split(",");
            String[] names = parts[1].split(" ");
            result += names[1].substring(0, 1);
        }
        input.close();
        System.out.println(result);
    }
}

HBP

String names = "Lee, Kim, Ana";
String[] parts = names.split(",");
System.out.println(parts.length);
System.out.println("[" + parts[2] + "]");
System.out.println(parts[2].length());

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class RevMinScore
{
    public static void main(String[] args) throws IOException
    {
        Scanner input = new Scanner(new File("grades.txt"));
        int[] grades = new int[input.nextInt()];
        for (int i = 0; i < grades.length; i++)
        {
            grades[i] = input.nextInt();
        }
        input.close();

        int lowest = grades[0];
        int over90 = 0;
        for (int i = 1; i < grades.length; i++)
        {
            if (grades[i] < lowest)
            {
                lowest = grades[i];
            }
            if (grades[i] > 90)
            {
                over90++;
            }
        }
        System.out.println(lowest + " " + over90);
    }
}

75 2

• I can explain why data stored in a file persists when the program is not running. Reread
• I can open a file with the File and Scanner classes and name the imports it needs. Reread
• I can explain why a method that opens a file needs throws IOException, and what happens when the file is missing. Reread
• I can predict what nextInt, nextDouble, nextBoolean, and next return, and when they throw an InputMismatchException. Reread
• I can choose between nextLine and next, and explain why one file should not mix them. Reread
• I can trace a while loop that uses hasNext to read every item in a file. Reread
• I can place close() correctly and explain what happens if a closed Scanner is used. Reread
• I can predict the array that split returns, including empty pieces and leftover spaces. Reread