The ArrayList Class and File IO

The ArrayList Class and File IO
CS0007: Introduction to Computer Programming
The ArrayList Class
 Array data structure:
 Pro: Can access any element with its index
 Con: Cannot add or remove elements (statically sized)
 Linked list data structure
 A linked list is a data structure in which an element of the list is a node that
references the next element in the list.
 A node in a linked list is made up of some data and a reference to another node.
 Pro: Can add and remove elements (dynamically sized)
 Con: Have to traverse list from beginning to find an element
 Arrays are weak where linked lists are strong, and vice versa. Is there
any data structure to take advantage of this.
 Answer: Yes
 The Java API provides a class called ArrayList.
 An ArrayList is a data structure that is a combination of an array and a linked
The ArrayList Class
 ArrayLists contain elements that can be accessed by their index,
but also have advantages over arrays:
 An ArrayList automatically expands as items are added to it.
 An ArrayList automatically shrinks as items are removed from it.
 To use an ArrayList, you must import it from the java.util
import java.util.ArrayList;
 The declaration and creation of an ArrayList follows this form:
ArrayList<dataType> identifier = new ArrayList<dataType>();
 So If I wanted to create an array list whose elements are of type
ArrayList<String> myList = new ArrayList<String>();
 Important Note: An ArrayList can only hold elements that are
 That means an ArrayList cannot hold elements of a primitive type.
The ArrayList Class
 You can add items to the end of an ArrayList by using the add
 This will make "Eric" the first element, "Bob" the second element,
and "Steve" the third element.
 Like in an array, these elements have indices starting at 0.
 To get the number of items stored in the ArrayList, use the size
 To get an element by its index, use the get method
 Example:
Enhanced for Loop and ArrayLists
 As stated previously, the enhanced for loop iterates through
the elements of any collection.
 We’ve seen this with arrays before:
String[] names = {"Eric", "Thomas", "Steve"};
for(String name : names) {
 We can also do this with ArrayLists.
 Example:
The toString Method and
 Every class in Java inherits methods from a base class called
 If you were to create a class, it would automatically inherit these
 These methods are placeholders and do nothing meaningful when you inherit
 The point of these methods is to override them.
 When you override an inherited method, you replace a previous
implementation of that method with another.
 One of these methods is called toString.
 toString is a method whose purpose is to return a String
representation of an object.
 ArrayList has its own implementation of this.
 Example:
Inserting, Removing and Replacing
 To remove an element from a list you use the remove method with the index of the
element you want to remove:
 Note: This will remove the second element and all elements behind that element will
move up in the list.
 For example: If an element has index 5 before we remove the element at index 1, after the removal, it
will have index 4.
 To insert an element into a specific index you use the add method (similar to adding an
element to the end of the list):
myList.add(3, "Chris");
 This will add "Chris" to the list at index 3 and all elements with indices greater than 2
will move back one.
 For example: If an element has index 5 before we add the element at index 3, after the addition, it will
have index 6.
 Finally, you can replace an element by using the set method:
myList.set(2, "Joe");
 This will replace the value of the element at index 2 with the value "Joe".
 Example:
Java File Input and Output
 So far we have written programs, data could not be saved in between runs of
the program.
 This is because the data we’ve used in our programs have been stored in RAM.
 Once our program is done running the data stored in RAM disappears.
 In order for us to save data for use outside our programs or for different runs of
our programs, we must save our data outside of RAM.
 The most simple way of doing this is writing to a text file on the computer’s hard drive.
In a text file all data is encoded as text, such as Unicode.
 That way, when our program is finished executing, we will still have a file with our data.
 The steps taken when reading or writing to a file:
 Open the file.
 This opens a connection between the file and a program (often called a stream)
 Data is written or read from a file.
 When the program is finished with the file, the file must be closed.
 Two kinds of files in input and output:
 Input File – File in which data is read from.
 Output File – File in which data is written to.
Writing to a File
 The Java API provides a class for writing to a file called
 You must import the PrintWriter class.
 The general form to create a PrintWriter object:
PrintWriter identifier = new PrintWriter(fileName);
 What is fileName?
 It is the file you want to write to.
 Text files typically have a .txt suffix
 The file will be created in the directory in which the program was compiled
o Note: This may be different places depending on the IDE you use.
 If the file already exists, it will be erased and overwritten!
 So to create a FileWriter object that opens a file called
PrintWriter outputFile = new PrintWriter("myFile.txt");
Writing to a File
 Important Note: Creating a PrintWriter object throws an
exception that must be handled.
 We will not discuss exception handling in this course at length, so just
perform the following steps to allow your program to compile:
 Add the words “throws FileNotFoundException” to the end of the main method’s
public static void main(String[] args) throws FileNotFoundException
 Import
 There are two methods that can be used to write to a file:
 println – prints its argument to the file and ends with a new line
 print – prints its argument to the file
 When you are finished writing to the file, you must close it using the
close method of the PrintWriter object.
 Example:
Reading from a File
To read from a file we need to use both the Scanner class and another class in the Java API called
 The File class is Java’s way of representing a file in code.
 For this we need to import both Scanner and File classes:
import java.util.Scanner;
Also we have to perform the steps to handle the FileNotFound exception, like when we
wrote to a file.
 Next, we need to create both a File and Scanner objects:
File theFile = new File("myFile.txt");
Scanner inputFile = new Scanner(theFile);
 This creates a File object that is associated with the file “myFile.txt”.
 For now make sure this file is in the same directory that you compile your program from.
 Again, this could be different depending on which IDE you use.
 If the file does not exist, it will cause an error!
To read a single line from a file we can use the nextLine method on the Scanner object.
 Finally, to close the file we use the close method on the Scanner object.
 Example:
Detecting the End of a File
 It is often the case we want to read all of the contents of the
file, or simply keep reading from the file until the end.
 There is a method in the Scanner class that detects if there is
anything left to read in a file called hasNext.
 hasNext returns true if there is more to read in a file, or false if
there is not.
 So this can be used in a loop to read all of the lines in a file…
o Example:

similar documents