1 Java Strings Dr. Randy M. Kaplan. 2 Strings – 1 Characters are a fundamental data type in Java It is common to assemble characters into units called.

1

Java Strings

Dr. Randy M. Kaplan

2

Strings – 1

Characters are a fundamental data type in Java It is common to assemble characters into units

called strings In C, all of the functions to manipulate strings had to

be implemented Implementing string manipulations routines is so

common that programmers typically created their own libraries of these

3

Strings – 2

Java has two classes that make it unnecessary to implement the string data type String StringBuffer

4

Strings – 2a

Anonymous Strings When a string object appears as a string constant,

for example s1.equals(“hello”) “hello” is referred to as an anonymous string

constant Anonymous string constants having the same

value are only created once to conserve memory

5

Strings – 3

String Constructors

Strings can be constructed in several different ways

s1 = new String(); s2 = new String( s ); s3 = new String( charArray ); s4 = new String( charArray, 6, 3 ); s5 = new String( byteArray, 4, 4 ); s6 = new String( byteArray ); s7 = new String( buffer );

6

Strings – 4

String() An empty string (a string with 0 length) is created

with the constructor without any arguments When a string is created with this constructor, is

can be used in the concatenation operation

7

Strings – 5

String(s) A new string can be created from an existing

string In this case, a new string object is created and the

contents of the argument is copied to the new object

8

Strings – 6

String(charArray) A character array can be used to create a string A character array is an arrays whose elements are

individual characters A string object is created by creating a string whose length

is the same as the number of elements in the character array

The value of the string will be the characters contained in the array, concatenated

9

Strings – 7

String(charArray, 6, 3) A new string can be created by selected particular

characters from the character array The second argument specifies the offset into the array of

the first character of the string The third argument specifies the number of characters in

the character array that will make up the string In this example, the first character of the string will be at

offset 6 in the array, and three characters of the array will make up the string

10

Strings – 8

String(byteArray) String(byteArray, 4, 4)

Just as strings can be formed from character arrays, they can also be formed from byte arrays

The constructor that takes just a byte arrays reference copies the contents of the byte array to make the string

The constructor that takes an offset and the number of characters, works in the same way as the version which uses a character array

11

Strings – 9

String(buffer) A string can also be constructed from a string

buffer The contents of the string buffer are copied to the

new string object

12

Strings – 10

Accessing string contents String Methods

length charAt getChars

13

Strings – 11 public static void main( String args[] ) { String s1, output; char charArray[]; s1 = new String( "hello there" ); charArray = new char[ 5 ]; // output the string output = "s1: " + s1; // test length method output += "\nLength of s1: " + s1.length(); // loop through characters in s1 and display reversed output += "\nThe string reversed is: "; for ( int count = s1.length() - 1; count >= 0; count-- ) output += s1.charAt( count ) + " "; // copy characters from string into char array s1.getChars( 0, 5, charArray, 0 ); output += "\nThe character array is: "; for ( int count = 0; count < charArray.length; count++ ) output += charArray[ count ]; JOptionPane.showMessageDialog( null, output, "Demonstrating String Class Constructors", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 ); }}

14

Strings – 12

The method that returns the length of the string is named length

s1.length returns the length of string s1

output += "\nLength of s1: " + s1.length();

15

Strings – 13

To extract a character at a particular location in a string use the charAt method

charAt takes an integer argument to select the character at the specified position

In the example above, the character at offset count is extracted and returned

output += s1.charAt( count ) + " ";

16

Strings – 14

A series of characters can be extracted from a string and placed in a character array

The method getChars is used to accomplish this getChars takes four arguments

An initial offset into the string A final offset one past the last character to be copied The target character array (where the extracted characters will be

stored) The offset into the character array where the characters will be

inseted

s1.getChars( 0, 5, charArray, 0 );

17

Strings – 15

String Comparison Java offers a variety of ways to compare String

objects Strings may be less than or greater than one

another This is determined by the lexicographic ordering

of the strings The lexicographic ordering is determined by the

order of letters in the alphabet

18

Strings – 16public class StringCompare { // test String class comparison methods public static void main( String args[] ) { String s1, s2, s3, s4, output; s1 = new String( "hello" ); s2 = new String( "good bye" ); s3 = new String( "Happy Birthday" ); s4 = new String( "happy birthday" ); output = "s1 = " + s1 + "\ns2 = " + s2 + "\ns3 = " + s3 + "\ns4 = " + s4 + "\n\n"; if ( s1.equals( "hello" ) ) output += "s1 equals \"hello\"\n"; else output += "s1 does not equal \"hello\"\n"; if ( s1 == "hello" ) output += "s1 equals \"hello\"\n"; else output += "s1 does not equal \"hello\"\n"; if ( s3.equalsIgnoreCase( s4 ) ) output += "s3 equals s4\n"; output += "\ns1.compareTo( s2 ) is " + s1.compareTo( s2 ) + "\ns2.compareTo( s1 ) is " + s2.compareTo( s1 ) + "\ns1.compareTo( s1 ) is " + s1.compareTo( s1 ) + "\ns3.compareTo( s4 ) is " + s3.compareTo( s4 ) + "\ns4.compareTo( s3 ) is " + s4.compareTo( s3 ) + "\n\n";

19

Strings – 17if ( s3.regionMatches( 0, s4, 0, 5 ) ) output += "First 5 characters of s3 and s4 match\n"; else output += "First 5 characters of s3 and s4 do not match\n"; if ( s3.regionMatches( true, 0, s4, 0, 5 ) ) output += "First 5 characters of s3 and s4 match"; else output += "First 5 characters of s3 and s4 do not match"; JOptionPane.showMessageDialog( null, output, "Demonstrating String Class Constructors", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 ); }}

20

Strings – 18

The equals method tests a string to determine if the string object’s value is equal to the argument of the method

The method returns true if the objects are equal and false otherwise

if ( s1.equals( "hello" ) ) output += "s1 equals \"hello\"\n";

21

Strings – 19

The == operator can also be used to test for string equality

== For primitive data types is true when the values

are the same For references, the result is true if the references

refer to the same object in memory

if ( s1 == "hello" ) output += "s1 equals \"hello\"\n";

22

Strings – 20

If two strings are to be compared without concern for case, the method equalsIgnoreCase can be used

For example, the strings “hello” and “HELLO” would be equal using equalsIgnoreCase

if ( s3.equalsIgnoreCase( s4 ) ) output += "s3 equals s4\n";

23

Strings – 21

compareTo The compareTo method is used to determine if one

string is less than, equal to, and greater than If the strings are equal, compareTo returns 0 If one string is less than the other, then compareTo

returns a negative number If one string is greater than the other then compareTo

returns a positive number

"\ns1.compareTo( s2 ) is " + s1.compareTo( s2 ) +

24

Strings – 22

regionMatches Compares portions of two strings for equality First argument: starting index in the String that invokes the

method Second argument: a comparison string Third argument: starting index in the comparison string Fourth argument: number of characters to compare

if ( s3.regionMatches( 0, s4, 0, 5 ) ) output += "First 5 characters of s3 and s4 match\n";

25

Strings – 23

regionMatches – Version 2 If the first argument is true, then the method

ignores the case of the characters being compared

The remaining arguments are identical to those described in the first version of the method

if ( s3.regionMatches( true, 0, s4, 0, 5 ) ) output += "First 5 characters of s3 and s4 match";

26

Strings – 24

public class StringStartEnd { public static void main( String args[] ) { String strings[] = { "started", "starting", "ended", "ending" }; String output = ""; for ( int count = 0; count < strings.length; count++ ) if ( strings[ count ].startsWith( "st" ) ) output += "\"" + strings[ count ] + "\" starts with \"st\"\n"; output += "\n"; for ( int count = 0; count < strings.length; count++ ) if ( strings[ count ].startsWith( "art", 2 ) ) output += "\"" + strings[ count ] + "\" starts with \"art\" at position 2\n"; output += "\n"; for ( int count = 0; count < strings.length; count++ ) if ( strings[ count ].endsWith( "ed" ) ) output += "\"" + strings[ count ] + "\" ends with \"ed\"\n"; JOptionPane.showMessageDialog( null, output, "Demonstrating String Class Comparisons", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 ); }}

27

Strings – 25

startsWith Will return true when if the string that invokes the

method begins the specified character

if ( strings[ count ].startsWith( "st" ) ) output += "\"" + strings[ count ] + "\" starts with \"st\"\n";

28

Strings – 26

endsWith Returns true if the string that invokes the method

ends with the specified string argument

if ( strings[ count ].endsWith( "ed" ) ) output += "\"" +

strings[ count ] + "\" ends with \"ed\"\n";

29

Strings – 27

hashCode Method It is useful to be able to store Strings and other data types

in a manner that allows information to be found quickly One of the best ways to store information for fast lookup is

in a hash table A hash table stores information using a special calculation

called a hash code The hash code is used to choose the location in the table in

which the object is stored

30

Strings – 28

Every object has the ability to be stored in a hash table

Class Object defines method hashCode to perform the hashCode calculation

Method hashCode is overridden by String to provide a good hash code distribution based on the contents of the String

31

Strings – 29public class StringHashCode {public static void main( String args[] ) { String s1 = "hello", s2 = "Hello";

String output = "The hash code for \"" + s1 + "\" is " + s1.hashCode() + "\nThe hash code for \"" + s2 + "\" is " + s2.hashCode();

JOptionPane.showMessageDialog( null, output, "Demonstrating String Method hashCode", JOptionPane.INFORMATION_MESSAGE );

System.exit( 0 ); }}

32

Strings – 30

The output of the hash code function

33

Strings – 31

Things to do with strings Locating things within strings

One of the most useful operations One of the operations that you will do most frequently Types of things to locate

Characters within strings Strings within strings

34

Strings – 32public class StringIndexMethods {

// String searching methods public static void main( String args[] ) { String letters = "abcdefghijklmabcdefghijklm";

// test indexOf to locate a character in a string String output = "'c' is located at index " + letters.indexOf( 'c' );

output += "\n'a' is located at index " + letters.indexOf( 'a', 1 );

output += "\n'$' is located at index " + letters.indexOf( '$' );

// test lastIndexOf to find a character in a string output += "\n\nLast 'c' is located at index " + letters.lastIndexOf( 'c' );

35

Strings – 33 output += "\nLast 'a' is located at index " + letters.lastIndexOf( 'a', 25 );

output += "\nLast '$' is located at index " + letters.lastIndexOf( '$' );

// test indexOf to locate a substring in a string output += "\n\n\"def\" is located at index " + letters.indexOf( "def" );

output += "\n\"def\" is located at index " + letters.indexOf( "def", 7 );

output += "\n\"hello\" is located at index " + letters.indexOf( "hello" );

36

Strings – 34 // test lastIndexOf to find a substring in a string output += "\n\nLast \"def\" is located at index " + letters.lastIndexOf( "def" );

output += "\nLast \"def\" is located at index " + letters.lastIndexOf( "def", 25 );

output += "\nLast \"hello\" is located at index " + letters.lastIndexOf( "hello" );

JOptionPane.showMessageDialog( null, output, "Demonstrating String Class \"index\" Methods", JOptionPane.INFORMATION_MESSAGE );

System.exit( 0 ); }

}

37

Strings – 35

The fundamental string searching method is indexOf

indexOf can take various arguments including Characters Strings Starting location for the search

38

Strings – 36

indexOf Examples Assume the followingString letters = "abcdefghijklmabcdefghijklm";

39

Strings – 37

Search for a character String output = "'c' is located at index " +

letters.indexOf( 'c' ); When a character argument is passed, the

position of the first occurrence of the character is returned

In this example, the output will be 2

40

Strings – 38

You can specify the starting location of a search for a particular character as in the following

output += "\n'a' is located at index " + letters.indexOf( 'a', 1 ); This begins its search at position 1 in the string

41

Strings – 39

When the character is not found, indexOf will return a -1

output += "\nLast '$' is located at index " + letters.lastIndexOf( '$' );

42

Strings – 40

It is also possible to locate a substring within a string output += "\n\nLast \"def\" is located at index " +

letters.indexOf( "def" ); And likewise, it is possible to specify the starting

position for a search when searching for a string output += "\n\"def\" is located at index " +

letters.indexOf( "def", 7 );

43

Strings – 41

A variation of indexOf is the method lastIndexOf

Siminar to indexOf, last index of will return the index of a character or a string occurrence within a string

Instead of returning the index of the first occurrence, lastIndexOf returns the index of the last occurrence

44

Strings – 42

Search for the last occurrence of the character ‘c’ and return its index

output += "\n\nLast 'c' is located at index " + letters.lastIndexOf( 'c' );

Search for the last occurrence of the character ‘a’ beginning at position 25 in the string

output += "\nLast 'a' is located at index " + letters.lastIndexOf( 'a', 25 );

45

Strings – 43

Search for the last occurrence of the string “def” in the string

output += "\n\nLast \"def\" is located at index " + letters.lastIndexOf( "def" );

Search for the last occurrence of the string “def” beginning at position 25 in the string

output += "\nLast \"def\" is located at index " + letters.lastIndexOf( "def", 25 );

46

Strings – 44

Extracting Substrings from Strings Another extremely useful operation The method provided for this is named “subString” Two variations of subString

One argument (where to start) Two arguments

Where to start Where to end

47

Strings – 45public class SubString {

// test String substring methods public static void main( String args[] ) { String letters = "abcdefghijklmabcdefghijklm";

// test substring methods String output = "Substring from index 20 to end is " + "\"" + letters.substring( 20 ) + "\"\n";

output += "Substring from index 0 up to 6 is " + "\"" + letters.substring( 0, 6 ) + "\"";

JOptionPane.showMessageDialog( null, output, "Demonstrating String Class Substring Methods", JOptionPane.INFORMATION_MESSAGE ); System.exit( 0 ); }}

48

Strings – 46

Extract the string beginning at position 20 through the end of the original string

String output = "Substring from index 20 to end is " +"\"" + letters.substring( 20 ) + "\"\n";

49

Strings – 47

Extract the string beginning at position 0 through position 6

output += "Substring from index 0 up to 6 is " + "\"" + letters.substring( 0, 6 ) + "\"";

50

Strings – 48

Concatenation We have used string concatenation in the form of

an operator in an expression When the + operator is used for strings, the

operation it performs is to concatenate its operands

String output = "s1 = " + s1 + "\ns2 = " + s2;

51

Strings – 49

Alternatively there is also a method that is defined for concatenation

The method concat takes an argument as a string and returns an object that is the concatenation of the string invoking the method and the string argument

s1.concat(s2) is equivalent to s1 + s2

52

Strings – 50

Other Methods replace toUpperCase toLowerCase trim toCharArray

53

Strings – 51

s1.replace( 'l', 'L' ); Replace all occurrences of l with L in the

string s1

54

Strings – 52

"\n\ns1.toUpperCase() = " + s1.toUpperCase() + Return a new string object where all lower case

characters have been transformed to uppercase "\ns2.toLowerCase() = " + s2.toLowerCase(); Return a string where all upper case characters

have been transformed to lower case

55

Strings – 53

output += "\n\ns3 after trim = \"" + s3.trim() + "\"";

Trim all white space characters in s3 that occur at the beginning or at the end of s3

A new string object is returned

56

Strings – 54

An object can be transformed into a String object with the toString method (if one has been defined for it)

An object can be transformed into a character array with the toCharArray method

57

Strings – 55

Another typical “programming” operation is the conversion from one type to a string type

In C this was accomplished with a special function: sprint

A special class method exists for this purpose called valueOf

58

Strings – 56

valueOf can take many different types of arguments charArray boolean char int long float double

59

Strings – 57

The purpose of the valueOf methods is to return a string representation of its argument

So, for example, if an integer is passed to the method, the string representation of that integer is returned

60

Strings – 58 public static void main( String args[] ) { char charArray[] = { 'a', 'b', 'c', 'd', 'e', 'f' }; boolean b = true; char c = 'Z'; int i = 7; long l = 10000000; float f = 2.5f; double d = 33.333; Object o = "hello"; // assign to an Object reference String output; output = "char array = " + String.valueOf( charArray ) + "\npart of char array = " + String.valueOf( charArray, 3, 3 ) + "\nboolean = " + String.valueOf( b ) + "\nchar = " + String.valueOf( c ) + "\nint = " + String.valueOf( i ) + "\nlong = " + String.valueOf( l ) + "\nfloat = " + String.valueOf( f ) + "\ndouble = " + String.valueOf( d ) + "\nObject = " + String.valueOf( o );

61

Strings – 59

intern Comparing a large String object is a relatively

slow operation When the String method intern is invoked on a

String object A reference is returned The object is guaranteed to have the same contents as

the original string

62

Strings – 60

intern again More importantly –

If intern is invoked again on a String object that it previously had been invoked on

It will return a reference to the same object it created previously

This object is maintained in memory by the Class String Large strings can be compared quickly using intern

through the use of the == operator

63

Strings – 61

The StringBuffer Class Very similar to String Except

Once a String is created, its contents cannot be changed StringBuffer is used to create and manage

dynamic strings strings that will change over time

64

Strings – 62

StringBuffer Constructors Create a StringBuffer with no characters but an

initial capacity of 16 characters Create a StringBuffer with no characters of a

specified capacity Create a StringBuffer using a source String object

as its argument

65

Strings – 63

public static void main( String args[] ) { StringBuffer buffer1, buffer2, buffer3; buffer1 = new StringBuffer(); buffer2 = new StringBuffer( 10 ); buffer3 = new StringBuffer( "hello" );

String output = "buffer1 = \"" + buffer1.toString() + "\"" + "\nbuffer2 = \"" + buffer2.toString() + "\"" + "\nbuffer3 = \"" + buffer3.toString() + "\"";

66

Strings – 64

It is important to note that StringBuffers are NOT STRING objects

They cannot be used interchangeably with String objects

They need to be converted to strings before they can be used as strings The method toString applies