Java SE 8: Getting Started with String Processing

1. In the NetBeans IDE, perform the following steps:

   • Expand Source Packages > com.example.strings.
   • Double-click the provided StringsDemo project.
   • On the Projects tab, create a Java file named Stringcomparison.java.

   

   
   

2. Open Stringcomparison.java in the code editor window, and then perform the following steps:

• Assign and declare the Stringcomparison class variables.
  
• Create an instance of the Stringcomparison class and invoke the String, StringBuffer, and StringBuilder class concatenation methods.
• Generate the concat(), concat1(), and concat2()methods to perform string concatenation for the String, StringBuffer, and StringBuilder classes, respectively.
  

  package com.example.strings;
  
  public class Stringcomparison {
  
      public static void main(String[] args) {
      String s1 = "Java";
      String s2 = "Oracle";
      Stringcomparison sc = new Stringcomparison();
      sc.concat(s1, s2);
      sc.concat1(s1, s2);
      sc.concat2(s1, s2);
      }
  
      public String concat(String s1, String s2) {
      System.out.println("String concatenation  " + (s1 + s2));
      return s1 + s2;
      }
  
      public String concat1(String s1, String s2) {
      StringBuffer sb = new StringBuffer();
      sb.append(s1);
      sb.append(s2);
      System.out.println("String Buffer concatenation  " + sb);
      return sb.toString();
      }
  
      public String concat2(String s1, String s2) {
      StringBuilder sb1 = new StringBuilder();
      sb1.append(s1);
      sb1.append(s2);
      System.out.println("String Builder concatenation  " + sb1);
      return sb1.toString();
  
      }
  
  }   

Here are the descriptions of the classes:

String class: When you performed string concatenation in JDK version 1.1, the String class created three string objects in the heap. Of the three string objects, two object references were lost and was garbage collected. If the number of strings for concatenation increased by 10, 20, and so on, intermediate string references were created, and the heap memory was occupied for garbage collection. To solve the problem, JDK version 1.3 introduced the StringBuffer class.

StringBuffer class: You use the StringBuffer class for multithreaded applications. Every string buffer has a capacity. As long as the length of the character sequence in the string buffer doesn't exceed the capacity of 2^31-1, you don't have to allocate a new internal buffer array. If you increase the maximum number of elements in the array, the array goes to negative and throws an error. String buffers are safe to use when multiple threads are involved in the application. In the JDK 5 release, the StringBuffer class was supplemented with an equivalent class, StringBuilder, which was designed for single-thread applications.

StringBuilder class: In general you should use the StringBuilder class instead of the StringBuffer class. The StringBuilder class executes faster, uses memory more efficiently, and provides better performance when you must make many concatenations. The  StringBuilder class has no array size limit and supports all StringBuffer class methods. When you perform string concatenation with the + operator, Java internally converts that call to the corresponding StringBuilder append() method. 

For example, implementation of return s1+s2; in the String class is equivalent to return new StringBuilder().append(s1).append(s2).toString(); in the StringBuilder class.

3. On the Projects tab, right-click Stringcomparison.java and select Run File.






4. Verify the output.

    

   
   The code demonstrates how to use the String, StringBuffer, and StringBuilder class methods to perform string concatenation.

5. Edit the main()method in Stringcomparison.java to understand the usage of the insert()and append()methods in the string concatenation process.
   

   // preexisting code goes here 

       System.out.println("StringBuilder insert and append example!");
       StringBuilder sb = new StringBuilder(0);
       System.out.println(sb.insert(0, "101 street"));
       int len = sb.length();
       System.out.println(sb.insert(len, "Boston"));
       System.out.println(sb.insert(10, "/"));
       System.out.println(sb.append("United states"));

   The code creates an instance of the StringBuilder class, which provides the insert() and append()methods.

   • insert(): Inserts the second argument in the string builder. This method lets you add data in any position.
     Syntax: insert(int pos, String str) where
     pos is the position where the data will be inserted.
     str is the string that will be inserted. The data is converted to a string before the insert operation takes place.

   • length(): Returns the length of the string. 

   • append(): Appends the argument to this string builder. The method appends the data at the last position.  
     Syntax: append(String str) where
     str is the string to be appended.
     

   Note: Use concatenation to attach a string at the end of another string. However, use the append() method with the StringBuffer or StringBuilder class to append character sequence, boolean, float, int, object, or string.

6. On the Projects tab, right-click Stringcomparison.java and select Run File.






7. Verify the output.

    

   You successfully used the insert() and append()methods in the StringBuider class.

In this section, you use the StringBuilder class methods. The StringBuilder class objects let you manipulate strings without creating a new object. They are unsynchronized (that is, the StringBuilder class isn't used for multithreaded applications). The StringBuilder class is designed for use as a drop-in replacement for the StringBuffer class.

1. In the NetBeans IDE, perform the following steps:
   • Expand Source Packages > com.example.strings.
   • Open the provided StringsDemo project.
   • On the Projects tab, create a Java file named StringBuildermethod.java.

 


2. Open StringBuildermethod.java in the code editor window. Add the following code to the main() method:

public static void main(String[] args) {

    StringBuilder sb1 = new StringBuilder("Welcome to the Java World");
    sb1.delete(11, 14);
    System.out.println("Delete method demo: " + sb1);

    StringBuilder sb2 = new StringBuilder(sb1);
    sb2.insert(11, "Sun ");
    System.out.println("Insert Operation: " + sb2);

    StringBuilder sb3 = new StringBuilder(sb2);
    sb3.replace(11, 14, "oracle");
    System.out.println("Replace Operation: " + sb3);

    StringBuilder sb4 = new StringBuilder(sb3);
    sb4.setCharAt(11, 'O');
    System.out.println("Replacing char at index 11 with Caps O: " + sb4);

    StringBuilder sb5 = new StringBuilder(sb4);
    sb5.reverse();
    System.out.println("Reverse of Welcome to oracle  Java World : " + sb5);
    int length= sb5.length();
    System.out.println("Length of the string:" +length);

    }

3. On the Projects tab, right-click StringBuildermethod.java and select Run File.






4. Verify the output. 



You successfully used the StringBuider class methods.

You use the StringTokenizer class to read tokens directly from a file. Reading tokens makes some utilities efficient because they work with individual tokens rather than lines of text. The StringTokenizer class methods don't distinguish among identifiers, numbers, and quoted strings, and they don't recognize and skip comments.

You create the class object by using one of the following constructor methods:

• If a string is passed as a single parameter to the constructor, the source text is broken by a default set of delimiters, such as space, tab, newline, cr, or formfeed (whitespace). Syntax: StringTokenizer(String str)
• If a second string is also passed, it is assumed to be a set of delimiting characters. Syntax: StringTokenizer(String str,String delim)
• If you add a true flag as a third parameter, delimiters are also returned as string tokens. Syntax: StringTokenizer(String str,String delim,boolean returnDelims)
  

In this example, you apply the tokenizer function on a URL. You also learn how to break the URL based on different delimiters or use the StringTokenizer class to break characters.

1. In the NetBeans IDE, perform the following steps: 

   • Expand Source Packages > com.example.strings.
   • Open the provided StringsDemo project.
   • On the Projects tab, create a Java file named Tokenizer.java.

   
   

2. Open Tokenizer.java in the code editor window. Add the following code to the main() method, and then press Ctrl + Shift + I to solve the imports.

       String url = "http://192.173.15.36:8084/";
       StringTokenizer st = new StringTokenizer(url);
       int tokenCount = st.countTokens();
       while (st.hasMoreTokens())
       {
           System.out.println(st.nextToken());
       }
       System.out.println("Number of tokens generated using single parameter constructor = " + tokenCount);   
   

This code sets the URL to the string variable message, gets the instance of the StringTokenizer object, retrieves the number of tokens, and displays the number of generated tokens in the console.

For the single parameter constructor, this example demonstrates where you break the source text at the default set of delimiters (for example, whitespace and newline).

3. On the Projects tab, right-click Tokenizer.java  and select Run File.

   

   
   
4. Verify the output.

   

   
   

5. In the main()method, add the following code to demonstrate the two-argument constructor:

      StringTokenizer str = new StringTokenizer(url, ":/.");
       int tokenCounts = str.countTokens();
       while (str.hasMoreTokens()) {
           System.out.println(str.nextToken());
       }
       System.out.println("Number of tokens generated using two parameter constructor = " + tokenCounts);
   

This code generates the number of tokens based on the delimiting character passed in the second argument. The number of generated tokens is displayed in the console.

6. On the Projects tab, right-click Tokenizer.java  and select Run File.

   

7. Verify the output.

   

   
   

8. In the main()method, add the following code to demonstrate the three-argument constructor:

       StringTokenizer str1 = new StringTokenizer(url, ":/.", true);
       int tc = str1.countTokens();
       while (str1.hasMoreTokens()) {
           System.out.println(str1.nextToken());
       }
       System.out.println("Number of tokens generated using three parameter constructor  = " + tc); 
   



This code generates the number of tokens based on the delimiting character passed in the second argument. When you set the third parameter to true, the parameter returns the string token and any delimiters.

9. On the Projects tab, right-click Tokenizer.java  and select Run File.

   

10. Verify the output.

    
    

    The number of generated tokens and empty token is displayed in the console.

In this section, you use the split() method in Address.java to retrieve the address from the address array list and display the address in the console.

1. In the NetBeans IDE, perform the following steps:

   • Expand Source Packages > com.example.strings.
   • Open the provided StringsDemo project.
   • On the Projects tab, create a Java file named Address.java.

   

   
   

2. Open Address.java in the code editor window and then perform the following steps:

• Declare the Address class variables.
  
• Generate the getter methods for each variable.
• Generate the parametrized constructor.



    package com.example.strings;

    public class Address {

    private String doorNo = "";
    private String street = "";
    private String city = "";
    private String country = "";

    public String getDoorNo() {
    return this.doorNo;
    }

    public String getStreet() {
    return street;
    }

    public String getCity() {
    return city;
    }

    public String getCountry() {
    return country;
    }

    public Address(String doorNo, String street, String city, String country) {
    this.doorNo = doorNo;
    this.street = street;
    this.city = city;
    this.country = country;
    }

}
   


3. Override the toString() method in Address.java to display the Address object in the console.

   // preexisting code goes here

   @Override
       public String toString() {
             StringBuilder sb = new StringBuilder(256);
             sb.append("Door ID: ").append(this.getDoorNo()).append("\n");
             sb.append("Street: ").append(this.getStreet()).append("\n");
             sb.append("City: ").append(this.getCity()).append("\n");
             sb.append("Country: ").append(this.getCountry()).append("\n");
   
             return sb.toString();
       }

   The code creates an instance of the StringBuilder class. A StringBuilder class provides the append() method, which appends the field values to the fields. You use the this()object reference to retrieve the values.

4. Use the split() method to retrieve the addressList address array list.

1. Add the following code to the main() method:
   

       public static void main(String[] args) {
           String[] add = new String[6];
           List<Address> addressList = new ArrayList<>(11);
   
           add[0] = "No20,MG Road,Bangalore,India";
           add[1] = "No657,Maple Street,Redwood City(CA),USA";
           add[2] = "No67,Oak Street,Colombo,Srilanka";
           add[3] = "No54,Lake Street,Bangkok,Thailand";
           add[4] = "No122,Washington Street,Tokyo,Japan";
           add[5] = "No673,Hill Street,Melbourne,Australia";
      
           for (String curLine : add) {
               String[] e = curLine.split(",");
               addressList.add(new Address(e[0], e[1], e[2], e[3]));
           }
      
           System.out.println("=== Address List ===");
           for (Address address : addressList) {
               System.out.println(address.toString());
           }
       }

The for each loop retrieves the individual addressList array objects, and the toString() method displays the objects in the console. 



2. Press Ctrl + Shift + I to solve the imports.



5. On the Projects tab, right-click Address.java and select Run File.



6. Verify the output.

The String.split() syntax is easier than the StringTokenizer syntax. However, if you want to parse the resulting strings, or if you want to change the delimiter based on a particular token, String.split() won't help because it returns an array (String[]), whereas StringTokenizer returns one token at a time.

The StringTokenizer class removes tokens that are delimited by fixed substrings. As a result, StringTokenizer is about twice as fast as String.split(). You can also use different tokens with the same StringTokenizer object. You cannot do this with the split() method because, after the array is returned, it can’t be reused for another delimiter.