Array of the type `String`

Introduction
- We have seen many examples of:
- Array of other data types can be defined using very similar syntax as that used in arrays of double.
- In this webpage, we will show you the syntax used to define and access arrays of Strings

Previously discussed: defining and using an array of double

Syntax to define an array of double:

Step 1: double[] a; // The type "double[]" is the // "array object reference" type // The variable a contains an address of // an array of doubles
Step 2: a = new double[5] ; // new double[5] creates an array // of 5 elements of double type // The array elements are named: // a[0], a[1], a[2], a[3], a[4] // Each element is of the type double

Important facts:

An individual array element of the array a is is accessed using the syntax:
An individual array element of the array double a is a variable of the data type double:
Conclusion:

Now let us extrapolate these fact to an array of String
(And we will have learned how to define/access arrays of String)

Defining an array of String

Syntax to define an array of String:

Step 1: String[] a; // The type "String[]" is the // "array object reference" type // The variable a contains an address of // an array of Strings
Step 2: a = new String[5] ; // new String[5] creates an array // of 5 elements of String type // The array elements are named: // a[0], a[1], a[2], a[3], a[4] // Each element is of the type String

Using an array of String

Previously discussed: using a String typed variables (See: click here)

public class String01 { public static void main(String[] args) { String x; x = "Hello World"; // Assign to a String typed variable System.out.println(x); // Print a String typed variable } }

Now apply the fact: Each array element a[i] is a String typed variable !!!

Since each String array element is a String typed variable, we can conclude from the above example:

How to assign and print a String array element a[0]:

a[0] = "Hello World"; // Assign to a String array element System.out.println( a[0] ); // Print a String array element

Example program using String array:

public class String1 { public static void main(String[] args) { /* ------------------------------------- Create a String array of 5 elements ------------------------------------- */ String[] a; a = new String[5]; /* ------------------------------------- Assign a string to each array element ------------------------------------- */ a[0] = "Hello"; a[1] = "World"; a[2] = "How"; a[3] = "are"; a[4] = "you"; /* --------------------------------------------- Print the array elements (with a for loop) --------------------------------------------- */ int i; for ( i = 0; i < a.length; i++ ) { System.out.print( a[i] + " "); } System.out.println(); } }

Example Program: (Demo above code)
- Prog file: click here
How to run the program:
Output of this program:

Internal representation of array of String

The internal representation of an array of String is a bit complicated
But is it not crucial that you know the internal representation
In fact, when we use variables in the Java's library, we often do not know (nor care to know) the internal representaion

Consider the previous Java program:

For the curious student, the following diagram depicts - step-by-step - what happens in the above program:
Note:

Reading in a text file and store the words in an array of String

Problem description:

Write a program that reads in a text file (file containing words)
Store each word in the file (separately) in an element of an array of String.
Store the number of words in the input file in the variable numWords.
You can assume that the file contains at most 100 words.

Example:

Input file contains:

The array of String will contains:

numWords = 5 a[0] = "Hello" a[1] = "World" a[2] = "How" a[3] = "are" a[4] = "you" a[5] = NULL a[6] = NULL .... a[99] = NULL

Previously discussed: Read from a data file (see: click here )

Construct a Scanner object using an opened file:

/* --------------------------------- Open a data file --------------------------------- */ File myFile; // Define a "File" type variable to receive // the opened file myFile = new File("Path-name-of-the-file"); // Open the file /* -------------------------------------------------- Construct a Scanner from the opened file "myFile" -------------------------------------------------- */ Scanner in; // Define a Scanner typed variable in = new Scanner(myFile); // Construct a Scanner that read // data from opened file"myFile"

From this point onwards, you can use

in.nextDouble() to read a floating point number from the data file
in.nextInt() to read an integer number from the data file
in.next() to read a string (word) from the data file

Previously discussed: print the content of a (numeric) data file (see: click here )

Rough algorithm:

Open the file "inp1" Construct a Scanner object using the opened file as long as ( there is data in the Scanner object ) { read a word from the Scanner object; print the word; }

Java program:

import java.io.*; import java.util.Scanner; public class File01 { public static void main(String[] args) throws IOException { File myFile = new File("inp1"); // Open file "inp1" Scanner in = new Scanner(myFile); // Make Scanner obj with opened file String x; // Variable to receive a string while ( in.hasNext() ) { x = in.next(); // Read a string (word) System.out.println(x); // Print string read } System.out.println("Done"); } }

Rough algorithm for reading in words from files into an array of String:

a = String array of 100 elements; int numWords = 0; Open the file "inp1" Construct a Scanner object using the opened file as long as ( there is data in the Scanner object ) { a[numWords] = read next word from the Scanner object; numWords++; // Use the NEXT element in array to store // the next word in file ! } /* -------------------------------------------------------------- We can process the words in the array here if we so desire... -------------------------------------------------------------- */ ... (further array processing) ...

Java program:

import java.io.*; import java.util.Scanner; public class ReadText1 { public static void main(String[] args) throws IOException { String[] a = new String[100]; // Create String array of 100 elem's int numWords; // Count # words in input File myFile = new File("inp1"); // Open file "inp1" Scanner in = new Scanner(myFile); // Make Scanner obj with opened file numWords = 0; while ( in.hasNext() ) { a[numWords] = in.next(); // Read next string (word) numWords++; // Count # words AND use next // array element for next word } System.out.println("Printing the array..."); for ( int i = 0; i < numWords; i++ ) System.out.println( a[i] ); } }

Example Program: (Demo above code)
- Prog file: click here
- Input data file: click here
How to run the program:

Advanced Java/C programming trick

Advanced Java/C programmers write this loop:

while ( in.hasNext() ) { a[numWords] = in.next(); // Read next string (word) numWords++; // Count # words AND use next // array element for next word }

as follows:

while ( in.hasNext() ) { a[numWords++] = in.next(); }

(because numWords++ evaluates to the old value of numWords).

A simple text processing problem using array of String

Problem description:

Write a program that reads in a text file (file containing words) and print the words on lines that are at most 30 characters in length.
The words in one line are separated by exactly one space.

Example:

Input file contains:

We hold these truths to be self-evident, that all men are created equal, that they are endowed by their Creator with certain unalienable Rights, that among these are Life, Liberty and the pursuit of Happiness.

The output will look like this:

123456789012345678901234567890 ------------------------------ We hold these truths to be self-evident, that all men are created equal, that they are endowed by their Creator with certain unalienable Rights, that among these are Life, Liberty and the pursuit of Happiness.

Developing the algorithm: what would you do ?

Take a blank piece of paper (represents the current line that we are trying to form that is ≤ 30 characters long)
If the next word can fit in the 30 character line (with one separating space), then add this word:
Repeat: if the next word can fit in the 30 character line (with one separating space), then add this word:

And so on, until we have:

123456789012345678901234567890 We hold these truths to be

When the next word cannot fit in the 30 character line (with one separating space):

123456789012345678901234567890 We hold these truths to be self-evident,

We do this:

Print the line:
Start a new line with the word that did not fit:

Repeat this process until all words have been printed.

Pseudo Code of the algorithm:

Read in the words and store the words in an array "a" of String; // An array give us easy access to the words in the file // BTW, we have discussed this step previously /* -------------------------- Process every word -------------------------- */ line = ""; // Start with an empty sheet of paper for ( i = 0; i < numWords; i++ ) { if ( a[i] fits in line ) { add a[i] (+ a separating space) to line; } else { Print line; Start a new line with a[i] in the line; } }

Refine the abstract description into programmable actions:

Testing: a[i] fits in line

line.length() = the length of the text in the variable line
a[i].length() = the length of the word in the variable a[i]

a[i] fits in line if:

line.length() + 1 + a[i].length() ≤ 30

(We add 1 for the separating space)

How to perform: add a[i] (+ a separating space) to line
How to perform: Start a new line with a[i] in the line

Initial Java program: (has some problems)

import java.io.*; import java.util.Scanner; public class FormatText1 { public static void main(String[] args) throws IOException { String[] a = new String[100]; // Create String array of 100 elem's int numWords; // Count # words in input File myFile = new File("inp2"); // Open file "inp2" Scanner in = new Scanner(myFile); // Make Scanner obj with opened file /* ----------------------------------------- Read in the text file and store in array ----------------------------------------- */ numWords = 0; while ( in.hasNext() ) { a[numWords] = in.next(); // Read next string (word) numWords++; // Count # words AND use next // array element for next word } /* ===================================== Format algorithm ===================================== */ String line; // 1 line line = ""; // Start with empty line for ( int i = 0; i < numWords; i++ ) { if ( line.length() + 1 /* space */ + a[i].length() <= 30 ) { line = line + " " + a[i]; // Add a[i] to line } else { System.out.println(line); // Print line line = a[i]; // Start new line with a[i] } } } }

Example Program: (Demo above code)

Prog file: click here
Input data file (inp2): click here

How to run the program:

Right click on links and save in a scratch directory
To compile: javac FormatText1.java
To run: java FormatText1

Result of the execution:

Input file

Output of program

We hold these truths to be self-evident, that all men are created equal, that they are endowed by their Creator with certain unalienable Rights, that among these are Life, Liberty and the pursuit of

Conclusion: the algorithm has 2 problems

The first word in the text is preceeded by a SPACE

Fix: add a test to detect an empty line

if ( s.length() == 0 ) { s = a[i]; // No space before first word } else if ( s.length() + 1 /* space */ + a[i].length() <= 30 ) { s = s + " " + a[i]; // Space is added before a[i] } else { System.out.println(s); // Next word can't fit s = a[i]; }

The last (incomplete) line was not printed

Fix: print the line after the for-statement ends

for ( int i = 0; i < numWords; i++ ) { if ( s.length() == 0 ) { s = a[i]; } else if ( s.length() + 1 /* space */ + a[i].length() <= 30 ) { s = s + " " + a[i]; } else { System.out.println(s); // Next word can't fit s = a[i]; } } System.out.println(s); // Print last (incomplete) line

Revised Java program:

import java.io.*; import java.util.Scanner; public class FormatText2 { public static void main(String[] args) throws IOException { String[] a = new String[100]; // Create String array of 100 elem's int numWords; // Count # words in input File myFile = new File("inp2"); // Open file "inp2" Scanner in = new Scanner(myFile); // Make Scanner obj with opened file numWords = 0; while ( in.hasNext() ) { a[numWords] = in.next(); // Read next string (word) numWords++; // Count # words AND use next // array element for next word } String line; // 1 line line = ""; for ( int i = 0; i < numWords; i++ ) { if ( line.length() == 0 ) { line = a[i]; } else if ( line.length() + 1 /* space */ + a[i].length() <= 30 ) { line = line + " " + a[i]; } else { System.out.println(line); // Next word can't fit line = a[i]; } } System.out.println(line); // Print last line } }