Lecture 5: Strings, Arrays and Math

What You Will Learn Today

1. Use basic object data structures such as strings, arrays, ArrayLists and vectors.
2. Use Math objects and random numbers.
3. Identify the scope of a variable in a given program, and differentiate local and global scope.
4. Convert a procedural program into an object-based program.
5. Create a menu-driven interface.
6. Redirect and pipe input and output, and use text files and shell scripts.
7. Explain the structure and use of the Java SDK and API documentation.

Strings

• A string is an immutable list of characters (cannot be changed).
• constructor: String myString = new String("Hello"); // same as String myString = "Hello";
• length() returns the number of characters in the string
  • the empty string "" has length 0
• the + operator concatenates (joins) two strings
  • a string + another data type becomes a string, e.g. "b" + 4 produces "b4"
• Integer.parseInt(string) converts string to an int
  • Double.parseDouble(string) and Float.parseFloat(string) work similarly
• substring(start, pastEnd) returns pastEnd characters starting from start position
• string1.equals(string2) returns true if the characters in string1 and string2 are identical
  • String s1 = "Hello"; String s2 = "Hello";
  • boolean equals1 = s1.equals(s2); // equals1 is true (s1 and s2 have same characters)
• common error: using == to compare strings
  • boolean equals2 = s1 == s2; // equals2 is false (s1 and s2 have different addresses)
  • String s3 = s1; boolean equals3 = s1 == s3; // equals3 is true (s1 and s3 point to the same string)
• equalsIgnoreCase returns true if the strings are equal ignoring case
  • "HTML".equalsIgnoreCase("html") // returns true
• toLowerCase() and toUpperCase() convert all letter characters in the string to small or capital letters
  • "HTML".equals("html".toUpperCase()) // returns true
• charAt(position) returns the character at the specified position in the string
  • "Java".charAt(0) // returns 'J'

Arrays

• An array is a fixed-size list of numbers.
• constructor: type[] variablename = new type[number];
  • double[] x = new double[10]; // x is an array of 10 double-precision numbers
  • int y[] = new int[n]; // y is an array of n integers; [] can come after the type or variable name
• Arrays can be initialized by supplying a list of values in braces.
  • int[] primes = { 2, 3, 5, 7, 11 }; // an array of prime numbers
• The length of an array is an instance variable.
  • int i = x.length; // i is 10
• To access array elements use variablename[index]
  • double z = x[3]; // set z equal to the double in position 3
  • The array index starts at 0 and ends with length-1
  • Going beyond the array bounds produces an exception (run-time error), e.g. z = x[10];
• Use a companion variable arraySize to store the number of array positions actually containing data.
  • while (i = Keyboard.readInt() > 0) { y[arraySize++] = i; }

Copying Arrays

• Copying an array reference only copies the address of the array, not the contents.
  • array2 = array1; // array1 and array2 are references to the same array
  • array1[5] = 32; // array2[5] is also 32
• To create an independent copy of an array, use the clone() method and cast to array of type.
  • double[] prices = (double[]) data.clone(); // prices is a copy of data
• When you run out of space in an array, create a new larger array and copy the old values into it.
  • int[] b = new int[2 * a.length]; for (int i = 0; i < a.length; i++) b[i] = a[i];

ArrayLists

• ArrayLists store references to objects and are useful for collecting lists of objects.
  • Although you can store numbers in an ArrayList, it is less efficient than an array because you must convert numbers to objects.
• If you have two or more arrays that you are using in parallel, you should probably create an ArrayList of objects.
• constructor: To create an ArrayList, use a statement ArrayList myList = new ArrayList();
• add(i, object) adds object in position i in the array.
• remove(i) removes the object in position i.
• (type) get(n) returns the nth object in the ArrayList and casts it to an object type.
• size() returns the number of elements in the ArrayList.

Vectors

A vector is a list with limited capacity that can be increased (doubled by default). Methods include:

• addElement(element) adds element to the end of the vector.
• removeElement(element) removes the first occurrence of the element.
• firstElement() and lastElement() return the first and last element.
• isEmpty() returns true if the vector contains no elements, false otherwise.
• contains(searchKey) returns true if the search key is in the vector, false if not.
• indexOf(element) returns the first location of the argument.
• size() returns the number of elements in the vector.
• capacity() returns the number of elements that can be stored.
• trimToSize() reduces the capacity of the vector to its current size.

Math Class

The Math class contains no objects; all its methods are class methods.

Most of the following methods take a double parameter and return a double.

• double sqrt(double x) // square root, e.g. sqrt(4.0) returns 2.0
• double pow(double x, int y) // x to the power y, e.g. pow(2, 3) returns 8.0
• double sin(double x) // sine of x, e.g. sin(0) returns 0 (cos is cosine, tan is tangent, asin is arcsine, etc.)
• double toRadians(double x) // converts degrees to radians, e.g. toRadians(180) returns 3.14159...
• double toDegrees(double x) // converts radians to degrees, e.g. toDegrees(Math.PI) returns 180
• double exp(double x) // e to the power x, e.g. exp(1) returns 2.7182818...
• double log(double x) // logarithm of x, e.g. log(1) returns 0
• double round(double x) // rounds to the nearest integer (ceil rounds up, floor rounds down)
• double abs(double x) // absolute value of x; same as (x < 0 ? -x : x)

Random Numbers

• A random number is a number chosen unpredictably from a range or set of numbers.
  • double x = Math.random(); // x is double precision number where 0 <= x < 1
• You can generate random integers by multiplying by an integer and casting the result to int.
  • int i = (int)Math.random() * n // i is an integer from 0 to n - 1
  • int i = (int)Math.random() * n + 1; // i is an integer from 1 to n
• Random numbers are very useful for creating simulations of real-world phenomena.
  • Computer-based simulations can be much cheaper than experiments with real world objects.

Variable Scope

• The scope of the variable is the area in the code where the variable exists in memory.
• Instance and class variables of an object have the same scope as the object; they are available to all methods of the class.
• A local variable's scope starts where the variable is defined and finishes when returning from the current method.
• A local variable's scope does not go beyond the block statement (braces that enclose it).

Converting Procedural Programs to Object-Based Programs

• Example: Circumference.java is procedural; Circle.java and CircleTest.java are object-based.
• Procedural thinking focuses on steps; object-based thinking focuses on the structure of the data.
• Many of the example programs are procedural or sequential; they get inputs, perform calculations and display outputs.
• An object-oriented program should create a new object whose private variables are the inputs.
• Each calculation should be a method of the object, and the results should be returned by the method.
• The output should be printed to the screen only by the main method of a test object, not in the original object.
• If you want to display the contents of an object for testing, use a method named toString().
• Objects are often reusable without any changes; procedural programs are difficult or impossible to reuse.
• Producing redundant copies of procedural code is bad because each copy must be maintained separately.

Menu-Driven Interface

• For interactive text-based programs, it is often useful to display a menu of choices to the user, e.g.

  To select a choice from the menu, type a number and press Enter.

  1. Enter Data: Type data from the keyboard.
  2. Import Data: Read data from a text file.
  3. View Raw Data: Display the entered data.
  4. Display Reports: Display results of calculations.
  5. Help: Display information about the purpose and use of the program.
  6. Exit: Quit the program and return to the shell prompt.
      
• To implement a menu,
  • Loop until the user selects the Exit option.
  • Create a method to display the menu.
  • Use if or select statements to look at the user's input and select the action to perform.
  • Create sub-menus using nested loops.

Redirection and Pipes

• Programs that input from a keyboard or input stream and output to the console can also use redirected input and output.
• java myprogram < input.txt // redirect input of a program to get input from a text file
• java myprogram > output.txt // redirect output of a program to create a text file (overwrites output.txt if it exists)
• java myprogram >> output.txt // append output of a program to the end of an existing text file
• java program1 | java program2 // pipe the output of program1 to be used as the input of program2

Batch Files and Shell Scripts

To run your program on more than one data set, create a DOS batch file or UNIX shell script:

1. Create text files each containing program input, e.g. input1.txt, input2.txt and input3.txt.
2. Type lines like these into a text editor:
   java myprogram < input1.txt
java myprogram < input2.txt
java myprogram < input3.txt
3. Save as a text file with a name like myprogram.bat
4. Change the permissions so the file is executable.
   chmod +x myprogram.bat
5. Run the program.
   ./myprogram.bat

SDK and API Documentation

• The Software Development Kit (SDK) documentation is in java/docs/index.html. It includes many technical documents including:
  • Java Language, Java Virtual Machine, Java Runtime Environment, and Tools (javac, java, javadoc, appletviewer).
• The Java 2 Platform Application Program Interface (API) Specification is in java/docs/api/index.html.
  • The upper left frame lists packages. Click a package to see its classes, or click All Classes.
  • The lower left frame lists classes. Click a class for the selected package.
  • The right frame displays a description of the selected class, including fields and methods.
  • Click Overview to see a list and brief description of all packages.
  • Click Tree to see the hierarchy of classes in the current package. (We discuss inheritance next week.)
  • Click Index and click a letter from A to Z to find packages, classes, methods, fields, etc. by name.

To Do After Class

• Project 1 Design Documentation is due next week Friday.
• Readings: Big Java Ch. 3.4, 3.7, 13.
• Homework 2 and Lab 4 are due Friday.