This website does readability filtering of other pages. All styles, scripts, forms and ads are stripped. If you want your website excluded or have other feedback, use this form.

Introduction To Java - MFC 158 G

Introduction To Java - MFC 158 G

Week 10 Lecture notes - Fall 2000

 

Chapter 10 -  Strings and Characters - MFC 158 (1 of 3)

 

Character constant - an integer value represented as a character in single quotes (‘a’, ‘B’, ‘\n’)

(see appendix D for integer equivalents for these characters)

 

Strings

-          a series of characters treated as a single unit (number, letters, special characters

-          in Java, a string is an OBJECT of class String.

-          String literals (or constants) are called ‘anonymous strings’  - surrounded by double quotes

-          Anonymous strings with the same contents are treated as one anonymous string object with several references, conserving memory.

 

String color = “blue”; (initializes string reference ‘color’ to refer to anonymous string object “blue”)

 

String Buffer – while strings are constants, a stringbuffer is a dynamically resizable and modifiable string.

 

Class String has nine constructors for initializing String objects in a variety of ways:

char charArray[] = { 'b', 'i', 'r', 't', 'h', ' ','d', 'a', 'y' };

 

String s, s1, s2, s3, s4, s5, s6, s7, output;

StringBuffer buffer;

 

      s = new String( "hello" );

      buffer =

         new StringBuffer( "Welcome to Java Programming!" );

 

      // use the String constructors

      s1 = new String();

      s2 = new String( s );

      s3 = new String( charArray );

      s4 = new String( charArray, 6, 3 );  start copying at 6th offset for 3 characters

      s7 = new String( buffer ); // constructor that accepts a StringBuffer argument – this will        

                                                 // contain a copy of stringbuffer’s contents (into a string)

 

String Methods length, charAt and getChars - get information about strings

s1 = new String( "hello there" );

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

 

// loop through the characters in s1 and display reversed

      output += "\nThe string reversed is: ";

 

      for ( int i = s1.length() - 1; i >= 0; i-- )

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

 

char charArray[];

charArray = new char[ 5 ];

s1.getChars( 0, 5, charArray, 0 ); //  copy five characters of s1, starting from position 0 into charArray

 

 

Comparing Strings - several methods available

s1 = new String( "hello" );  // create a COPY of the anonymous string "hello"

 

if ( s1.equals( "hello" ) )  // compares the contents of s1 with the anonymous string "hello"

         output += "s1 equals \"hello\"\n";

 

if ( s3.equalsIgnoreCase( s4 ) )

         output += "s3 equals s4\n";

 

// regionMatches(start index of s3, comparison string, start index of compare string,

// number of characters to compare)

if ( s3.regionMatches( 0, s4, 0, 5 ) )

         output += "First 5 characters of s3 and s4 match\n";

 

if ( s3.regionMatches( true, 0, s4, 0, 5 ) )  // same as above, except ignore case

 

Operator == works differently with objects than primitives.  The result is true if both references refer to the same object in memory.  The test below is false because we created a COPY of the anonymous string "hello" and put it into a different object - s1.  It would have been true if we changed   s1 = new String( "hello" );  to s1 = "hello";

 

if ( s1 == "hello" )  // compares

         output += "s1 equals \"hello\"\n";  // this evaluates to false //

 

StartsWith and EndsWith

String strings[] = { "started", "starting", "ended", "ending" };

for ( int i = 0; i < strings.length; i++ )

         if ( strings[ i ].startsWith( "st" ) )

            output += "\"" + strings[ i ] + "\" starts with \"st\"\n";

 

if ( strings[ i ].startsWith( "art", 2 ) )  // test starting from position 2

 

if ( strings[ i ].endsWith( "ed" ) ) // test the end of the string

 

(Note:  String method hashCode not covered in class)

 

Locating Characters and Substrings in Strings

String letters = "abcdefghijklmabcdefghijklm";

Output = "'c' is located at index " +

               letters.indexOf( 'c' ); // returns 2

output += "\n'$' is located at index " +

                letters.indexOf( '$' );   // NOT FOUND - returns a (-1)

output += "\n\nLast 'c' is located at index " +

                letters.lastIndexOf( 'c' );  // returns15

output += "\n\n\"def\" is located at index " +

                letters.indexOf( "def" );  // locates substring "def"

output += "\n\nLast \"def\" is located at index " +

                letters.lastIndexOf( "def" );  // looks for the last occurance of "def"

output += "\nLast 'a' is located at index " +

           letters.lastIndexOf( 'a', 25 );  // the highest index to begin searching backwards from

output += "\n\"def\" is located at index " +

                letters.indexOf( "def", 7 );  // the starting index to begin searching from

 

 

 

 

Extracting Substrings from strings

String letters = "abcdefghijklmabcdefghijklm";

output = "Substring from index 20 to end is " +

               "\"" + letters.substring( 20 ) + "\"\n";  //returns from index=20  'hijklm'

output += "Substring from index 0 up to 6 is " +

                "\"" + letters.substring( 0, 6 ) + "\"";   // returns 6 characters from index=0 'abcdef'

 

Concatenation of strings

String s1 = new String( "Happy " ),  s2 = new String( "Birthday" );

output += "\n\nResult of s1.concat( s2 ) = " + s1.concat( s2 );  // prints Happy Birthday-s1=Happy

 

Miscellaneous String Methods

String s1 = new String( "hello" ), s2 = new String( "GOOD BYE" ), s3 = new String( "   spaces   " );

S5 = s1.replace( 'l', 'L' );  // replace l with L in s1 - (if l exists) and returns a NEW string

S5 = s1.toUpperCase(); // converts to uppercase and returns a NEW string

S5 = s2.toLowerCase(); // converts to lowercase and returns a NEW string

S5 = s3.trim();  // removes white space at the beginning and end of the string

 

long l = 10000000;

double d = 33.333;

s1 = String.valueOf( l );  // converts long value to string

s2 = String.valueOf( d ); // converts double value to string

 

StringBuffer class - once created, a string can never change it's value.  StringBuffers allow creation and manipulation of dynamic string information - modifiable Strings.

-          if the capacity of a StringBuffer is exceeded, it is automatically expanded to include the new size.

-          Java can optimize strings better than StringBuffers, as the size of a string is always known. Use strings as much as possible for more efficient code.

StringBuffer buf1, buf2, buf3;      // 3 different constructors below //

      buf1 = new StringBuffer();   // initial capacity of 16 characters - the default //

      buf2 = new StringBuffer( 10 );  // empty, but has the capacity of 10 characters //

      buf3 = new StringBuffer( "hello" );  // contains "hello" and has capacity of 5 + 16

 

StringBuffer buf = new StringBuffer( "Hello, how are you?" );  //initial capacity is 19+16=35

buf.ensureCapacity( 75 );

output += "\n\nNew capacity = " + buf.capacity();  // buffer capacity is now 75

output += "\n Initial Length = " + buf.length();  // length is 19

buf.setLength( 10 );

output += "\n Initial Length = " + buf.length();  // length is now 10 - truncates

 

-          Other methods available with StringBuffers - charAt, setCharAt, getChars and reverse

-          StringBuffers also have append (pg 484), Insertion and Deletion operations (pg 486)

 

Class StringTokenizer - break up statements into pieces, separated by delimiters (tabs, space)

import java.util.*;

 

class stringtok {

 

public static void main(String Args []) {

 

  String stringToTokenize = "this is a sentence to break up";

  StringTokenizer tokens = new StringTokenizer( stringToTokenize );

  System.out.println( "Number of elements: " + tokens.countTokens() );

  System.out.println("The tokens are:\n");

  while ( tokens.hasMoreTokens() )         

      System.out.println( tokens.nextToken() );

 

}

 

}