String and related classes in Java

Strings in Java

However, DrinksMachine is not a built-in type of Java, to use it you had to have a copy of the file DrinksMachine.class in your directory. The class String is provided as part of Java, it is always available for you to use in any Java program you write. To use most types provided with Java you have to use an import statement (we mentioned these briefly here), but a few are regarded as so common that you don't even have to import them, String is one of these (the others are all those in the java.lang package). In fact every type in Java defines a type of object and has an associated class with it, with the exception of the numerical types, int, double and so on, the type boolean and the type char. These non-object types are known as the primitive types.

One reason you have not seen strings as objects is that, unlike any other type of object, there is a special way of representing string values, that is the representation using the quote characters enclosing the characters that make up the string. You can also make new string objects by Java's use of + to mean string joining. So there is little need to create new strings using a constructor. However, for example, there is a constructor in class String which takes an array of characters as its argument and produces a string where each character in the string is equal to the character in the same position in the array. So if a is a variable of type char[], and has been set to refer to an array object, then new String(a) will return the equivalent string.

Strings in Java (unlike, for example, the language C) are not the same thing as arrays of characters. If we have a variable a of type char[] and a variable str of type String, then for any expression i which evaluates to an integer, a[i] gives the ith character of the array referred to by a, while str.charAt(i) gives the ith character of the string referred to by str. As we saw here, we can use a[i] as a variable, so we can put it on the right hand side of assignment statement and assign a value to it. For example, a[3]='x' will change the fourth character of the array referred to by a (remembering the first character is indexed by 0) to lower-case 'x'. However, str.charAt(i) is a method call, and you cannot assign a value to a method call. The Java compiler will give a error message if you attempted to compile code with the statement str.charAt(3)='x' in it. So string objects can't be changed in the way array objects can be changed, in fact string objects are immutable: they cannot be changed at all, you can only create new ones.

A minor but perhaps rather annoying difference between arrays and strings in Java is that the length of an array a is given by a.length and the length of a string str is given by str.length(). The difference is the () at the end of str.length() which indicates this is just a method call, the zero-argument method length, called on the object str.

Methods in class String in Java

As an example, the method replace acts in a similar way to the method change we discussed previously with arrays. It takes a string and two characters and returns the result of replacing all occurrences of the first character by the second character in the string. It does this constructively rather than destructively, that is it returns a new string representing the change, it does not change the string it is called on. In fact the class String has no destructive methods, this ensures that String objects are immutable, there is no method that can be called on them to change them, there are only methods that can be called on them to return new strings representing a change.

With the constructive method change we developed for arrays of integers, if a1 and a2 were of type int[] and n1 and n2 were of type int then the statement a2=change(a1,n1,n2) causes a2 to be set to an array which represents the effect of changing all occurrences of the integer n1 to the integer n2 in the array a1. With the method replace in class String, if str1 and str2 are variables of type String and ch1 and ch2 are variables of type char, then the statement str2=str1.replace(ch1,ch2) causes str2 to be set to a string which represents the effect of changing all occurrences of the character ch1 to the character ch2 in the string str1. For example, if str1 holds a reference to the string "happy", and ch1 hold the character 'p' and ch2 holds the character 'r', then str1.replace(ch1,ch2) will return a reference to the string "harry".

The difference in construct between str1.replace(ch1,ch2) and change(a1,n1,n2) is because our change was a static method while the replace method in class String is not a static method. So the array being changed had to be passed as one of the arguments to the method change, and this method was not called attached to any object. The method replace has to be called attached to a String object, which is the object to be changed, and this is done instead of the object being passed as one of the arguments to the method call.

Other useful methods in class String which return strings based on transforming the string they are called on include:

• trim returns the string with all blank characters at either end removed. So if str represents "  Hello World   " then the call str.trim() will return the string "Hello World".
• toUpperCase returns the string with all lower case letters replaced by the equivalent upper case letters. So if str represents "Hello World" then str.toUpperCase() will return the string "HELLO WORLD".
• toLowerCase returns the string with all upper case letters replaced by the equivalent lower case letters. So if str represents "Hello World" then str.toLowerCase() will return the string "hello world".
• substring takes two integers as arguments and returns the portion of the string it is called on which starts with the character indexed by the first integer and goes up to but does not include the character indexed by the second integer. So if str represents "Hello world", and p1 stores 3 and p2 stores 8 then str.substring(p1,p2) will return "lo wo". A second version of substring takes just one integer argument and returns the portion of the string indexed by that integer argument up to the end of the string. So with the same value of str and with p storing 4, the call str.substring(p) would return "o world".

static String replace(String str1,char ch1,char ch2)
// Returns the string resulting from replacing all occurrences
// of ch1 by ch2 in str.
{
 String str2="";
 for(int i=0; i<str1.length(); i++)
    if(str1.charAt(i)==ch1)
       str2=str2+ch2;
    else
       str2=str2+str1.charAt(i);
 return str2;
}

The reverse of the constructor for class String which takes an array of strings as its argument and produces the equivalent String object is the method toCharArray. If str references a string, then str.toCharArray() returns an object of type char[], that is an array of characters of the same length as the string, where the characters in the array are the same and indexed in the same order as the characters in the string.

You can find code which demonstrates some of these methods in the directory ~mmh/DCS128/code/strings. See the files Test1.java, Test2.java, Test3.java, Test4.java, Test5.java, Test6.java and Test7.java.

Input in Java

However, in this course we will use the input methods provided with Java so that you are no longer reliant on non-standard code. Up till 2004, the following was recommended as the way to use standard Java to read text from a console window. You created an object of the type BufferedReader using the following construction:

BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

The problem with this is that it only reads single characters or whole lines. If you wanted it to read an integer, you would have to write code which got the user to type the integer on a line of its own, and write code to convert the string of characters returned by readLine() into an integer. If you wanted to read several integers on one line, you would have to write code to break the string representing the whole line into smaller strings representing the integers and then code to convert them. Also the methods read and readLine may throw a checked exception of type IOException. So any method which contains a call to either of them must have throws IOException added to its header unless it uses Java's exception-catching mechanism to catch the exception.

The classes BufferedReader, InputStreamReader and IOException are all in the Java library package java.io. So they need to be imported to any file which uses them, this can be done by adding the line

import java.io.*;

The version of Java introduced in 2004 officially known as "Java 2 Standard Platform Edition 5.0" or J2SE5.0 introduced something which really ought to have been in the earlier versions of Java, a simple reader object. Had this been done earlier on, authors of introductory programming textbooks could have used it as the standard rather than introducing their on simple reading mechanisms. We have already used this in our example code, you saw it first here. An object of type Scanner is created by a call to one of its constructors, if the argument to the call is System.in it creates a Scanner object which reads from the console window. As we saw from our example, the class Scanner is in the java.util package, but nothing else from that package is required to make it work, so importing just that class with

import java.util.Scanner;

Scanner input = new Scanner(System.in);

String Tokenizing

import java.util.Scanner;
import java.io.*;

class TestScanner1
{
 public static void main(String[] args) throws IOException
 {
  BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
  System.out.println("Enter some words: ");
  String words = input.readLine();
  Scanner splitter = new Scanner(words);
  System.out.println("\nThe words you entered are: ");
  while(splitter.hasNext())
      System.out.println(splitter.next());
 }
}

A similar effect can be obtained by the use of the method split in class String. Calling split on an object of class String returns an object of type String[], that is an array of strings, where the strings in the array are the separate word the string it was called on breaks up into. So if the variable str refers to the string "Hello world, how are you?", the variable declaration and assignment

String[] words = str.split(" ");

Here the punctuation symbols are treated as normal characters and so are treated as part of the words they are next to. The argument to the method split tells it what it must treat as word delimiters. So str.split(" ") tells it to treat the space character as spacing between words, and all other characters as normal characters. If we made it str.split(",") it would tell it to split the string up treating the comma character as the separating characters. So in the above example, it would split the string into two parts, words[0] would be "Hello world" and words[1] would be " how are you?". The full rules for how this argument to split work use a concept known as "regular expressions", which we won't go into here.

In older notes on Java, you may see reference to and use of objects of class StringTokenizer to split strings of words into individual words. The class StringTokenizer is found in the package java.util. A StringTokenizer object is created from a constructor which takes a string as its argument. Then it works like a Scanner object created with a string argument constructor, except that the method to obtain the next word is nextToken, while the method to check whether there are more words to return is hasMore Tokens. One thing StringTokenizer has which Scanner does not is the method countTokens which returns the number of words in the string. But Scanner when constructed with a string argument still has the methods nextInt and hasNextInt which enable it to be checked whether the next word represents an integer and to return its integer representation, but StringTokenizer doesn't have an equivalent. The process of splitting a string into its individual words is known as string tokenizing, but the class StringTokenizer has been superseded by the more general class Scanner and the String method split.

If you want to convert a string, perhaps obtained from a call of the method split, which represents an integer to the equivalent integer, you need to use the method parseInt which is a static method in the class Integer. Because the class Integer is in the java.lang package it does not have to be imported. If you want to call a static method from another class, the call is attached to the name of the class. So if str refers to a string object all of whose characters are numerical, then Integer.parseInt(str) returns the value of type int it represents. If ch represents the string "6315" then int n=Integer.parseInt(str) will declare the variable of type called n and set it to the number 6315. You need to be aware that "6315" is just the string of four characters '6', '3', '1' and '5', it is an entirely separate thing from the number 6315 which on the computer isn't even represented using decimal digits. If you call Integer.parseInt(str), but str is not a string which represents an integer, it will cause an exception of type NumberFormatException to be thrown. The static method parseDouble in class Integer works in a similar way to praseInt, but coverts strings that represent double values (that is, floating point numbers) to the actual double value they represent.

Wrapper Classes

Wrapper classes exist because in some places in Java you can only use types which are not primitive types. A variable of type Integer refers to an object which holds a value of type int inside it, so it is a different thing from a variable of type int which holds the value directly. In older versions of Java, if i is of type int, to create the Integer equivalent you would have to use the constructor, so Integer n = new Integer(i) would create a new variable of type Integer called n and set it to refer to an object which contains the value of i. The reverse conversion would use the method called intValue in class Integer, so int j = n.intValue() would declare a variable of type int called j and set it to the int value inside the object referred to by n. In Java 5.0, however, the conversion is automatic. Integer n=i has the same effect as Integer n = new Integer(i), and int j=n has the same effect as int j = n.intValue(). In general in Java 5.0, you can use references to objects of type int whenever a value of type Integer is required, and it will be converted automatically (referred to as boxing) and you can use a value of type Integer whenever a value of type int is required (referred to as unboxing).

The wrapper classes also contain a number of static methods dealing with values of the primitive type they wrap. For example, the static method toBinaryString in class Integer takes an int argument and returns a string of '1' and '0' characters representing its binary equivalent. So if variable n of type int holds the value 21 then Integer.toBinaryString(n) will return "10101". In the class Character, the static method toUpperCase takes a value of type char and returns its upper case equivalent, so if variable ch holds 'q' then Character.toUpperCase(ch) will return 'Q'. Class Character has various static methods for determining the category of characters. For example, Character.isUpperCase(ch) will return true if ch stores an upper case letter, and false otherwise.

In the directory ~mmh/DCS128/code/strings the file Test8.java demonstrates the toBinaryString method of class Integer and Test9.java demonstrates some methods from class Character.

Recursion with Strings

 public static boolean startsWith(String str1,String str2)
 // Returns true if str1 starts with str2, false otherwise
 {
  if(str2.length()==0)
     return true;
  else if(str1.length()==0)
     return false;
  else if(str1.charAt(0)!=str2.charAt(0))
     return false;
  else
     return startsWith(str1.substring(1),str2.substring(1));
 }

For comparison, here is the same operation performed using loops (which to contrast with "recursion" we call iteration):

 public static boolean startsWith(String str1,String str2)
 // Returns true if str1 starts with str2, false otherwise
 {
  int i;
  for(i=0 ;i<str1.length()&&i<str2.length(); i++)
      if(str1.charAt(i)!=str2.charAt(i))
         break;
  return i==str2.length();
 }

 public static boolean startsWith(String str1,String str2)
 // Returns true if str1 starts with str2, false otherwise
 {
  while(str2.length()!=0&&str1.length()!=0&&str1.charAt(0)==str2.charAt(0))
      {
       str1=str1.substring(1);
       str2=str2.substring(1);
      }
  return str2.length()==0;
 }

Not all recursive code can be converted so easily to iterative code. The startsWith code is an example of what is called tail recursion, which is when the return statement has just a recursive call as its return value. A more complicated example is when something is done with the result of the recursive call to get the return value. For example, above, we saw an iterative method which took a string and two characters and returned the string resulting from changing all occurrences of the first character to the second. A recursive method which does the same thing is given below:

 public static String replace(String str,char ch1,char ch2)
 // Returns the string resulting from replacing all occurrences
 // of ch1 by ch2 in str.
 {
  if(str.equals(""))
     return "";
  else
     {
      String str1 = replace(str.substring(1),ch1,ch2);
      if(str.charAt(0)==ch1)
         return ch2+str1;
      else
         return str.charAt(0)+str1;
     }
 }

The reason this can't be converted so easily into a loop is that you need to keep the old value of the string argument variable, str in this case, for use after the recursive call, so you cannot just reassign the variable and thus lose its old value. Tail recursion can convert easily into iteration, because we do not need to go back and use values from previous environments. With recursion where something is done after each recursive call, it will be done in the previous environment as it is returned to.

Last modified: 27 January 2006