Java Documentation Overview

The methods included in these tables are the ones used in this course, and the most commonly useful methods of each class. Links are provided to the complete documentation if you are interested.

FileResource

This class provides methods for accessing a file on your computer. You can create a FileResource in a variety of ways:

• new FileResource(), opens a dialog box prompting you to select a file on your computer
• new FileResource("path/to/file.ext"), uses the given String to find a file on your computer or within your BlueJ project
• new FileResource(existingFile), uses the given File (typically returned by using a DirectoryResource)

For these examples, assume the variable fr has been created for a specific file.

for (String line : fr.lines()) {
    // process each line in turn
}

for (String word : fr.words()) {
    // process each word in turn
}

String contents = fr.asString();

URLResource

This class provides methods for accessing a web page. You can create a URLResource by giving it a complete URL, or web address (note, it must start with either http:// or https://):

• new URLResource("http://www.something.com/file.ext"), uses the given address to download the referenced file
• new URLResource("https://www.something.com/file.ext"), uses the given address to download the referenced file

For these examples, assume the variable ur has been created for a specific URL.

for (String line : ur.lines()) {
    // process each line in turn
}

for (String word : ur.words()) {
    // process each word in turn
}

String contents = ur.asString();

DirectoryResource

This class provides a method for choosing one or more files on your computer. You can only create a DirectoryResource with no parameters:

• new DirectoryResource()

For these examples, assume the variable dr has been created.

for (File f : dr.selectedFiles()) {
    // process each file in turn
}

StorageResource

This class provides methods for storing and accessing a list of strings of any length. Generally you will start by creating an empty StorageResource, then adding string values as you find them in a file or web page:

• new StorageResource(), creates an empty list
• new StorageResource(otherList), creates a list that is an exact copy of otherList

For these examples, assume the variable sr has been created.

sr.add("first!");
sr.add("next ...");

for (String item : sr.data()) {
    // process each string in turn
}

sr.clear();

The methods included in these tables are the ones used in this course, and the most commonly useful methods of each class. Links are provided to the complete documentation if you are interested.

String

This class provides methods for accessing a sequence of characters of any length. Strings are immutable, which means they cannot be changed after they are created. There are two general ways of creating a String:

• String s = new String("Colorful");
• String s = "Colorful";

For these examples, assume the variable s has the value "Colorful"

StringBuilder

Strings are sequences of characters that cannot be changed once they are created. StringBuilder, on the other hand, allows adding and deleting from the sequence dynamically. Just like Strings, each character in the sequence has an index number starting at 0. There are two general ways of creating a new StringBuilder:

• new StringBuilder(), creates a StringBuilder with no characters in it.
• new StringBuilder("Colorful"), creates a StringBuilder initialized with the given characters.

For these examples, assume the variable sb is a StringBuilder with the value "Colorful"

Character

Character is a class that provides basic utility functions for computing with characters (letters, digits, symbols, and so forth). It is a class with static methods, meaning you do not have to create a new object to use the class' functionality.

Random

This class provides methods for generating random numbers. To generate more than one random number, only one Random object needs to be created.

• new Random(), creates a new object for generating random numbers.

For these examples, assume the variable rand is a Random object.

Array

The array is the most basic Java collection. As such, it has limitations in that it has a fixed size and few methods. All elements of an array must have the same type. Like Strings, elements in an array are numbered beginning at 0, and these numbers are referred to as indices.

There are two ways to create an array:

• String[] words = new String[4]; creates an array that can hold Strings with exactly 4 slots. The index of the first slot is 0, and the index of last slot is 3. When arrays are created in this way, the array is filled with default values for each slot. If this were an array of numbers, that would mean that every slot would be initialized with the value 0. Since this is an array of objects, it means that every slot is initialized with a null value.
  
  
• String[] words = {"this", "is", "an", "array"};creates an array of 4 Strings as well. The difference is that the slots are initialized with the given words.

For these examples, assume the variable words is an array initialized as in the second line.

ArrayList

Like arrays, ArrayLists are collections. Unlike arrays, they have more functionality and their size can change. When you create an ArrayList you declare what kind of object it holds using < > notation.

• ArrayList<String> list = new ArrayList<String>(); creates an empty collection

For these examples, assume the variable list is an ArrayList of Strings and has the words "this", "is", "a", "list" inserted.

for (String s : list) {
    // process each item in turn 
} 

HashSet

A set is a collection that is not intended to have any duplications. Like ArrayLists, the <> notation tells the type of object being stored.

• HashSet<Integer> set = new HashSet<Integer>(); creates an empty collection

For the following examples, assume the set has the values 101, 202, and 303 in it.

for (Integer i : set) {
    // process each item in turn 
} 

HashMap

A map is a collection that works as a lookup table. The collection is kept as pairs of keys and their values. Like ArrayLists, the < > notation tells the type of object used as keys and the type used as values. For example, suppose we want to keep a collection of names with ID numbers. We can create a HashMap like this:

• HashMap<String, Integer> map = new HashMap<String, Integer>(); creates an empty collection

For the following examples, assume the map variable has two entries:

• "Robert" maps to 101
• "Drew" maps to 252

for (String s : map.keySet()) {
    // process each key in turn 
} 

for (Integer v : map.values()) {
    // process each value in turn 
}