Back

Activity 5.9 — File Input with Scanner

Introduction

Activity 5.9

Reading Data from Text Files

Why read from a file?

Real programs often process data that already exists.
A file is like “pre-entered input” you can reuse anytime.
We can analyze, sort, and summarize file data with arrays.

What changes vs console input?

Console input uses new Scanner(System.in)
File input uses new Scanner(new File("name.txt"))
You still use nextInt(), next(), etc.

File Scanner Setup

Create the file in your project folder.
Open it with File + Scanner.
Always close the scanner when done.

1
// Figure 1 — File Scanner setup (read-only)
2
// This reads from a text file in your project folder.
3

4
import java.io.File;
5
import java.util.Scanner;
6

7
public class Program
8
{
9
    public static void main(String[] args) throws Exception
10
    {
11
        File file = new File("numbers.txt");
12
        Scanner input = new Scanner(file);
13

14
        while (input.hasNextInt())
15
        {
16
            int value = input.nextInt();
17
            System.out.println(value);
18
        }
19

20
        input.close();
21
    }
22
}

Reading safely: check before reading

hasNextInt() checks if the next token is an integer
hasNext() checks if there is another token
This prevents reading past the end of the file

1
// Figure 2 — hasNext vs next
2
// Always check BEFORE you read.
3

4
while (input.hasNext())
5
{
6
    String token = input.next();
7
    // token is the next "word" in the file
8
}

Two common patterns

Fixed-size files: you know how many values are coming
Unknown-size files: you read until you run out of data

1
// Figure 3 — Reading a fixed amount into an array
2
// If you know how many values are in the file.
3

4
int[] data = new int[10];
5

6
for (int i = 0; i < data.length; i++)
7
{
8
    data[i] = input.nextInt();
9
}

Data Processing Workflow

Read data into an array
Compute stats (sum/avg/min/max)
Optionally copy and sort a separate array
Print useful results

Common mistakes

File name mismatch (wrong spelling or wrong folder)
Reading ints when the next token is text
Forgetting to close the scanner
Assuming the file has the exact format you expect

Today’s tasks

Warmup: read numbers and count them
Read 10 scores into an array + stats
Copy + sort file data (using your sorting algorithm)
Read a mini gradebook dataset (names + scores)

'F' → Fullscreen

Objectives

Read integers and strings from a text file using Scanner.
Use hasNext methods to safely read file data.
Store file data into arrays for processing.
Compute summary statistics and sort a copied dataset.

Activity Tasks

Create a new project named Activity5_9_FileInput.
Complete Tasks 1–4.
Create the required text files in the same folder as your .java file.

Figures: Reference Examples

1
// Figure 1 — File Scanner setup (read-only)
2
// This reads from a text file in your project folder.
3

4
import java.io.File;
5
import java.util.Scanner;
6

7
public class Program
8
{
9
    public static void main(String[] args) throws Exception
10
    {
11
        File file = new File("numbers.txt");
12
        Scanner input = new Scanner(file);
13

14
        while (input.hasNextInt())
15
        {
16
            int value = input.nextInt();
17
            System.out.println(value);
18
        }
19

20
        input.close();
21
    }
22
}

1
// Figure 3 — Reading a fixed amount into an array
2
// If you know how many values are in the file.
3

4
int[] data = new int[10];
5

6
for (int i = 0; i < data.length; i++)
7
{
8
    data[i] = input.nextInt();
9
}

1
// Figure 4 — Helpful utilities used in this activity
2

3
public static void printArray(int[] arr)
4
{
5
    for (int v : arr)
6
    {
7
        System.out.print(v + " ");
8
    }
9
    System.out.println();
10
}
11

12
public static int sum(int[] arr)
13
{
14
    int total = 0;
15

16
    for (int v : arr)
17
    {
18
        total += v;
19
    }
20

21
    return total;
22
}
23

24
public static int max(int[] arr)
25
{
26
    int best = arr[0];
27

28
    for (int i = 1; i < arr.length; i++)
29
    {
30
        if (arr[i] > best)
31
        {
32
            best = arr[i];
33
        }
34
    }
35

36
    return best;
37
}
38

39
public static int min(int[] arr)
40
{
41
    int best = arr[0];
42

43
    for (int i = 1; i < arr.length; i++)
44
    {
45
        if (arr[i] < best)
46
        {
47
            best = arr[i];
48
        }
49
    }
50

51
    return best;
52
}

Task 1: Read + Count Numbers

Create numbers.txt with one integer per line.
Read until the file ends and count how many values you read.

1
// Task 1 — Numbers from a file (warmup)
2
//
3
// Create a file named: numbers.txt
4
// Put ONE integer per line.
5
//
6
// Example file contents:
7
// 12
8
// 5
9
// 19
10
// 8
11
// 3
12
//
13
// Program requirements:
14
// 1) Read every number from numbers.txt
15
// 2) Print each number as it is read
16
// 3) Keep a running count of how many numbers were read
17
// 4) Print: "Count: X" at the end
18

19
import java.io.File;
20
import java.util.Scanner;
21

22
public class Program
23
{
24
    public static void main(String[] args) throws Exception
25
    {
26
        File file = new File("numbers.txt");
27
        Scanner input = new Scanner(file);
28

29
        int count = 0;
30

31
        while (input.hasNextInt())
32
        {
33
            int value = input.nextInt();
34
            System.out.println(value);
35
            count++;
36
        }
37

38
        System.out.println("Count: " + count);
39

40
        input.close();
41
    }
42
}

Task 2: Read 10 Values into an Array + Stats

Create scores10.txt with exactly 10 integers.
Read all 10 into an array, then compute stats.

1
// Task 2 — Fixed-size file into an array + stats
2
//
3
// Create a file named: scores10.txt
4
// Put EXACTLY 10 integers (one per line).
5
//
6
// Program requirements:
7
// 1) Read all 10 numbers into an int[] array of length 10
8
// 2) Print the array on one line
9
// 3) Print the sum, average, min, and max
10
//
11
// Hint: average should be a double.
12

13
import java.io.File;
14
import java.util.Scanner;
15

16
public class Program
17
{
18
    public static void main(String[] args) throws Exception
19
    {
20
        File file = new File("scores10.txt");
21
        Scanner input = new Scanner(file);
22

23
        int[] scores = new int[10];
24

25
        for (int i = 0; i < scores.length; i++)
26
        {
27
            scores[i] = input.nextInt();
28
        }
29

30
        input.close();
31

32
        printArray(scores);
33

34
        int total = sum(scores);
35
        double avg = (double) total / scores.length;
36

37
        System.out.println("Sum: " + total);
38
        System.out.println("Average: " + avg);
39
        System.out.println("Min: " + min(scores));
40
        System.out.println("Max: " + max(scores));
41
    }
42

43
    public static void printArray(int[] arr)
44
    {
45
        for (int v : arr)
46
        {
47
            System.out.print(v + " ");
48
        }
49
        System.out.println();
50
    }
51

52
    public static int sum(int[] arr)
53
    {
54
        int total = 0;
55

56
        for (int v : arr)
57
        {
58
            total += v;
59
        }
60

61
        return total;
62
    }
63

64
    public static int max(int[] arr)
65
    {
66
        int best = arr[0];
67

68
        for (int i = 1; i < arr.length; i++)
69
        {
70
            if (arr[i] > best)
71
            {
72
                best = arr[i];
73
            }
74
        }
75

76
        return best;
77
    }
78

79
    public static int min(int[] arr)
80
    {
81
        int best = arr[0];
82

83
        for (int i = 1; i < arr.length; i++)
84
        {
85
            if (arr[i] < best)
86
            {
87
                best = arr[i];
88
            }
89
        }
90

91
        return best;
92
    }
93
}

Task 3: Copy + Sort File Data

Copy the array so you preserve original order.
Sort the copy using selection or insertion sort from Activity 5.8.
Print both arrays.

1
// Task 3 — Sorting file data (Selection or Insertion, your choice)
2
//
3
// Reuse scores10.txt from Task 2.
4
//
5
// Program requirements:
6
// 1) Read the 10 scores into an array
7
// 2) Make a COPY of the array (so you preserve original order)
8
// 3) Sort the copy using selectionSort OR insertionSort (from Activity 5.8)
9
// 4) Print both arrays:
10
//    - Original
11
//    - Sorted copy
12
//
13
// NOTE: Do NOT use Arrays.sort for this task.
14

15
import java.io.File;
16
import java.util.Scanner;
17

18
public class Program
19
{
20
    public static void main(String[] args) throws Exception
21
    {
22
        File file = new File("scores10.txt");
23
        Scanner input = new Scanner(file);
24

25
        int[] original = new int[10];
26

27
        for (int i = 0; i < original.length; i++)
28
        {
29
            original[i] = input.nextInt();
30
        }
31

32
        input.close();
33

34
        int[] sorted = copyArray(original);
35

36
        // Choose ONE:
37
        // selectionSort(sorted);
38
        insertionSort(sorted);
39

40
        System.out.println("Original:");
41
        printArray(original);
42

43
        System.out.println("Sorted:");
44
        printArray(sorted);
45
    }
46

47
    public static int[] copyArray(int[] arr)
48
    {
49
        int[] copy = new int[arr.length];
50

51
        for (int i = 0; i < arr.length; i++)
52
        {
53
            copy[i] = arr[i];
54
        }
55

56
        return copy;
57
    }
58

59
    public static void insertionSort(int[] arr)
60
    {
61
        for (int i = 1; i < arr.length; i++)
62
        {
63
            int elementToInsert = arr[i];
64
            int j = i;
65

66
            while (j > 0 && elementToInsert < arr[j - 1])
67
            {
68
                arr[j] = arr[j - 1];
69
                j--;
70
            }
71

72
            arr[j] = elementToInsert;
73
        }
74
    }
75

76
    public static void selectionSort(int[] arr)
77
    {
78
        for (int i = 0; i < arr.length - 1; i++)
79
        {
80
            int minIndex = i;
81

82
            for (int j = i + 1; j < arr.length; j++)
83
            {
84
                if (arr[j] < arr[minIndex])
85
                {
86
                    minIndex = j;
87
                }
88
            }
89

90
            int temp = arr[i];
91
            arr[i] = arr[minIndex];
92
            arr[minIndex] = temp;
93
        }
94
    }
95

96
    public static void printArray(int[] arr)
97
    {
98
        for (int v : arr)
99
        {
100
            System.out.print(v + " ");
101
        }
102
        System.out.println();
103
    }
104
}

Task 4: Gradebook Dataset (Names + Scores)

Create gradebook.txt using the format shown in the task.
Read each record and print each student’s average.
Track and print the student with the highest average.

1
// Task 4 — Mini Dataset: Gradebook from a file (practical)
2
//
3
// Create a file named: gradebook.txt
4
// Format (exactly like this):
5
//
6
// Ava 90 82 88 100
7
// Ben 70 85 79 92
8
// Chris 95 91 93 89
9
//
10
// Program requirements:
11
// 1) Read each student name (String) and 4 integer scores
12
// 2) Print each student's average
13
// 3) Track and print the highest average student's name
14
//
15
// Hint: Use hasNext() and read name with next()
16

17
import java.io.File;
18
import java.util.Scanner;
19

20
public class Program
21
{
22
    public static void main(String[] args) throws Exception
23
    {
24
        File file = new File("gradebook.txt");
25
        Scanner input = new Scanner(file);
26

27
        String bestName = "";
28
        double bestAvg = -1;
29

30
        while (input.hasNext())
31
        {
32
            String name = input.next();
33

34
            int s1 = input.nextInt();
35
            int s2 = input.nextInt();
36
            int s3 = input.nextInt();
37
            int s4 = input.nextInt();
38

39
            int sum = s1 + s2 + s3 + s4;
40
            double avg = sum / 4.0;
41

42
            System.out.println(name + " average: " + avg);
43

44
            if (avg > bestAvg)
45
            {
46
                bestAvg = avg;
47
                bestName = name;
48
            }
49
        }
50

51
        input.close();
52

53
        System.out.println("Top average: " + bestName + " (" + bestAvg + ")");
54
    }
55
}

Sample Output

Your program output should something similar to the sample output below.

12
5
19
8
3
Count: 5

88 73 95 67 81 90 82 88 100 70
Sum: 834
Average: 83.4
Min: 67
Max: 100

Original:
88 73 95 67 81 90 82 88 100 70
Sorted:
67 70 73 81 82 88 88 90 95 100

Ava average: 90.0
Ben average: 81.5
Chris average: 92.0
Top average: Chris (92.0)

Reflection Questions

You may write your reflection answers as comments at the bottom of your code.

Why do we use hasNextInt() (or hasNext()) before reading?
What happens if the file name is wrong or the file is not in the correct folder?
Why did Task 3 copy the array before sorting?
In Task 4, why do we read the name with next() but scores with nextInt()?
Give one reason file input can be better than typing values into the console.

Submission

Submit your activity and reflection answers to the appropriate dropbox.