// This is a class with value field and name field.
// When you create this class, you cannot reset the value and all other fields from outside.
// This class does not have methods for the purpose of resetting fields from outside.
// It means this class is immutable
public class ImmutableClassExample  {
   private int value;
   private String name;

   public ImmutableClassExample(String name, int value)  {
          this.value = value;
          this.name= name;
   }

   public String getName()  {
          return name;
   }

   public int getValue()  {
         return value;
   }
}


// This is a class owning a value field.
// After creating the object, you can reset values of the value field by calling setNewValue(int) method.
// This is a mutable class.
public class MutableClassExample  {

     private int value;

     public MutableClassExample(int value)  {
           this.value= value;
     }

     public void setNewValue(int newValue)  {
          this.value = newValue;
     }

}

// Implicit construction via string literal
String str1 = "Java is Hot";

// Explicit construction via new
String str2 = new String("I'm cool");
 

String s1 = "Hello";              // String literal
String s2 = "Hello";              // String literal
String s3 = s1;                   // same reference
String s4 = new String("Hello");  // String object
String s5 = new String("Hello");  // String object

String s1 = "Hello";              // String literal
String s2 = "Hello";              // String literal
String s3 = s1;                   // same reference
String s4 = new String("Hello");  // String object
String s5 = new String("Hello");  // String object

s1 == s1;         // true, same pointer
s1 == s2;         // true, s1 and s2 share storage in common pool
s1 == s3;         // true, s3 is assigned same pointer as s1
s1 == s4;         // false, different pointers
s4 == s5;         // false, different pointers in heap

s1.equals(s3);    // true, same contents
s1.equals(s4);    // true, same contents
s4.equals(s5);    // true, same contents

• LengthDemo.java

package com.yiibai.tutorial.str;

public class LengthDemo {

    public static void main(String[] args) {
        String str = "This is text";
        int len = str.length();
        System.out.println("String Length is : " + len);
    }
}

• ConcatDemo.java

package com.yiibai.tutorial.str;

public class ConcatDemo {

    public static void main(String[] args) {
        String s1 = "One";
        String s2 = "Two";
        String s3 = "Three";

        // s1.concat(s2) same as s1 + s2
        String s = s1.concat(s2);
        System.out.println("s1.concat(s2) = " + s);

        // s1.concat(s2).concat(s3) same as s1 + s2 + s3;
        s = s1.concat(s2).concat(s3);

        System.out.println("s1.concat(s2).concat(s3) = " + s);
    }
}

s1.concat(s2) = OneTwo
s1.concat(s2).concat(s3) = OneTwoThree

• IndexOfDemo.java

package com.yiibai.tutorial.str;

public class IndexOfDemo {

    public static void main(String[] args) {
        String str = "This is text";
       
        // Find index within this string of the first occurrence 'i'.
        // ==> 2
        int idx = str.indexOf('i');
        System.out.println("- indexOf('i') = " + idx);

      
        // Find index within this string of the first occurrence 'i'
        // starting the search at index 4.  
        // ==> 5
        idx = str.indexOf('i', 4);
        System.out.println("- indexOf('i',4) = " + idx);
       
        // index within this string of the first occurrence of "te".
        // ==> 8
        idx = str.indexOf("te");
        System.out.println("- indexOf('te') = " + idx);
    }

}

- indexOf('i') = 2
- indexOf('i',4) = 5
- indexOf('te') = 8

• SubstringDemo.java

package com.yiibai.tutorial.str;

public class SubstringDemo {

    public static void main(String[] args) {
        String str = "This is text";

        // Returns the substring from index 3 to the end of string.
        String substr = str.substring(3);

        System.out.println("- substring(3)=" + substr);

        // Returns the substring from index 2 to index 7.
        substr = str.substring(2, 7);

        System.out.println("- substring(2, 7) =" + substr);
    }
}

- substring(3)=s is text
- substring(2, 7) =is is

// Returns a new string resulting from replacing all occurrences of
// oldChar in this string with newChar.
public String replace(char oldChar, char newChar)

// Replaces each substring of this string that matches the given  
// 'regular expression' with the given replacement.
public String replaceAll(String regex, String replacement)

// Replaces the first substring of this string that matches
// the given <'regular expression' with the given replacement.
public String replaceFirst(String regex, String replacement)

• ReplaceDemo.java

package com.yiibai.tutorial.str;

public class ReplaceDemo {

    public static void main(String[] args) {
        String str = "This is text";

        // Replace the character 'i' by 'x'.
        String s2 = str.replace('i', 'x');

        System.out.println("- s2=" + s2);

        // Replace all the strings match "is" by "abc". (Regular Expression)
        String s3 = str.replaceAll("is", "abc");

        System.out.println("- s3=" + s3);

        // Replaces the first substring of this string that matches "is" by "abc".
        String s4 = str.replaceFirst("is", "abc");

        System.out.println("- s4=" + s4);
       
        // (See also document the regular expression)
        // Replace all substring matching expression:
        // "is|te": means "is" or "te" replaced by "+".
        String s5 = str.replaceAll("is|te", "+");
        System.out.println("- s5=" + s5);
    }

}

- s2=Thxs xs text
- s3=Thabc abc text
- s4=Thabc is text
- s5=Th+ + +xt

• StringOtherDemo.java

package com.yiibai.tutorial.str;

public class StringOtherDemo {

    public static void main(String[] args) {
        String str = "This is text";

        System.out.println("- str=" + str);

        // Return lower case string.
        String s2 = str.toLowerCase();

        System.out.println("- s2=" + s2);

        // Return upper case string
        String s3 = str.toUpperCase();

        System.out.println("- s3=" + s3);

        // Check string started by "This" or not.
        boolean swith = str.startsWith("This");

        System.out.println("- 'str' startsWith This ? " + swith);
       
        // A string with whitespace in beginning and end.
        // Note: \t is tab character
        // \n is new line character
        str = " \t Java is hot!  \t \n ";

        System.out.println("- str=" + str);

        // Returns a copy of the string, with leading and trailing whitespace omitted.
        String s4 = str.trim();

        System.out.println("- s4=" + s4);
    }

}

- str=This is text
- s2=this is text
- s3=THIS IS TEXT
- 'str' startsWith This ? true
- str= 	 Java is hot!  	 
 
- s4=Java is hot!

// Constructors
StringBuffer()             // an initially-empty StringBuffer
StringBuffer(int size)     // with the specified initial size
StringBuffer(String s)     // with the specified initial content

// Length
int length()

// Methods for building up the content
// type could be primitives, char[], String, StringBuffer, etc
StringBuffer append(type arg)  // ==> note above!
StringBuffer insert(int offset, type arg) // ==> note above!

// Methods for manipulating the content
StringBuffer delete(int start, int end)
StringBuffer deleteCharAt(int index)
void setLength(int newSize)
void setCharAt(int index, char newChar)
StringBuffer replace(int start, int end, String s)
StringBuffer reverse()

// Methods for extracting whole/part of the content
char charAt(int index)
String substring(int start)
String substring(int start, int end)
String toString()

// Methods for searching
int indexOf(String searchKey)
int indexOf(String searchKey, int fromIndex)
int lastIndexOf(String searchKey)
int lastIndexOf(String searchKey, int fromIndex)

• StringBuilderDemo.java

package com.yiibai.tutorial.strbb;


public class StringBuilderDemo {

    public static void main(String[] args) {
       
        // Create StringBuilder object
        // with no characters in it and
        // an initial capacity specified by the capacity argument
        StringBuilder sb = new StringBuilder(10);
        
        // Append the string Hello ... on sb.
        sb.append("Hello...");
        System.out.println("- sb after appends a string: " + sb);

        // append a character
        char c = '!';
        sb.append(c);
        System.out.println("- sb after appending a char: " + sb);

        // Insert a string at index 5
        sb.insert(8, " Java");
        System.out.println("- sb after insert string: " + sb);
        
    
        // Delete substring at index 5 to 8
        sb.delete(5,8);

        System.out.println("- sb after delete: " + sb);
    }
}

- sb after appends a string: Hello...
- sb after appending a char: Hello...!
- sb after insert string: Hello... Java!
- sb after delete: Hello Java!