String s = new String();
s = "Using the new keyword";

String s = new String("Using a one liner");

String s = "Using the shorthand version";

String s = "This is a new string";

s = s.concat("you are not supposed to be able to change this");

Note: what happens is the following

1. A new string object is created using the original string with the concatenation
2. the string variable s now points to the new string object
3. the old string object is removed by the garbage collector as long as nothing else is attached to it.

String x = "Hello World!";
System.out.println("Character 3 in String x is " + x.charAt(2));

Note: The charAt returns the character at a specific index, remember we start at zero

String t = "Hello";
String t1 = "World";
String t2 = t;

System.out.println( t + " compareTo " + t2 + " results in " + t.compareTo(t2));   // results in 0 (match)
System.out.println( t + " compareTo " + t1 + " results in " + t.compareTo(t1));   // results in -15

Note: a reult of zero means that they are equal, a negative values means it is less than the string passed, and a positive values means it is more than the value passed

String x = "Taxi";

System.out.println( x.concat(" cab");
System.out.println("Original String x has now been changed : " + x);

Note: concat method does not update x as there was no assignment

String x = "hello";

if ( x.equalsIgnoreCase("hello")
   System.out.prinln("String x is equal to Hello, hello, etc");

Note: see equals for more information on this method

String x = "hello";

if ( x.equalsIgnoreCase("Hello")
   System.out.prinln("String x is equal to Hello, hello, etc");

Note: the equalsIgnoreCase returns true if the value is the same as the argument passed, otherwise false

# getChars(int srcBegin, int srcEnd, char[] dest, int destBegin)

String h = "Hello World";
char[] ca = new char[5];

h.getChars(0, 5, ca, 0);
System.out.println(ca);

String t1 = "abcdefghiklmnopqrstuvwxyz";
String t2;

t2 = t1.intern();   // see note below

if ( t1 == t2)
   System.out.println("t1 and t2 are the same object");

if ( t1.equals(t2) )
   System.out.println("t1 and t2 have the same contents");

Note: a lookup is performed

String x = "this is a very long string that hopefully will have a total of 76 characters";

System.out.println("String x has " + x.length() + " Character");

Note: return the length of a String (includes whitespace)

String x = "XXaXX";

System.out.println("String before: " + x);
System.out.println("String replaced: " + x.replace('X','x'));

String x = "1234567890";

System.out.println("Part of String x: " + x.substring(5));    // start from position 5 return rest of string
System.out.println("Part of String x: " + x.substring(5,8));  // start from position 5 return upto character 8

Note: used to return part of a string

String lower = "all lower case";
String upper = "ALL UPPER CASE";

System.out.println("String lower is now upper case: " + lower.toUpperCase());
System.out.println("String upper is now lower case: " + upper.toLowerCase());

String x = "Hello World!";

System.out.println("toString method returns: " + x.toString());

Note: all objects in Java have a toString method, normally returns a meaningful way to describe the object

String x = "     x     ";

System.out.println("Blank spaces removed from x: " + x.trim());

Note: trim removes any leading or trailing blank spaces

StringBuffer sb1 = new StringBuffer();              // this will have an initial capacity of 16 characters
StringBuffer sb2 = new StringBuffer(10);            // this will have a capacity of 10 characters

StringBuffer sb3 = new StringBuffer("Hello World!");  // the capacity will be string size 12 plus 16 = 32

System.out.println("StringBuffer sb3 is: " + sb3);    // Just use it like a String

StringBuffer sb = new StringBuffer("abcd");

System.out.println("Appends efgh to StringBuffer sb :" + sb.append("efgh");
System.out.println("StringBuffer sb is now: " + sb);

Note: There are 10 overloaded append methods which allow you to add various data type values

StringBuffer sb1 = new StringBuffer();
StringBuffer sb1 = new StringBuffer(10);
StringBuffer sb1 = new StringBuffer("Hello World");

System.out.prntln("StringBuffer sb1(character count): " + sb1);     // displays 0
System.out.prntln("StringBuffer sb2(character count): " + sb2);     // displays 0
System.out.prntln("StringBuffer sb3(character count): " + sb3);     // displays 11

System.out.prntln("StringBuffer sb1(capacity): " + sb1);     // displays 16
System.out.prntln("StringBuffer sb2(capacity): " + sb2);     // displays 10
System.out.prntln("StringBuffer sb3(capacity): " + sb3);     // displays 27

Note: increasing the size is a performance hit, so if you do change the StringBuffer make sure it has the capacity already so it does not need to grow

StringBuffer sb1 = new StringBuffer();
sb1.ensureCapacity(75);                 // minimum capacity will be 75 characters

Note: if the character length is greater then the method ensures a capacity that is the greater of the number specified as an argument or twice the original capacity plus 2.

## sb.delete(start position, end position)
StringBuffer sb = new StringBuffer("1234567890");

System.out.println("Inserted text into StringBuffer sb: " + sb.delete(4, 6));  / displays 12347890

## sb.insert(start, data type) there are many diffrent data types i.e boolean, char, String, etc
StringBuffer sb = new StringBuffer("1234567890");

System.out.println("Inserted text into StringBuffer sb: " + sb.insert(4, "----"));

Note: again the offset is zero based

StringBuffer sb1 = new StringBuffer();
StringBuffer sb1 = new StringBuffer(10);
StringBuffer sb1 = new StringBuffer("Hello World");

System.out.prntln("StringBuffer sb1: " + sb1);     // displays 0
System.out.prntln("StringBuffer sb2: " + sb2);     // displays 0
System.out.prntln("StringBuffer sb3: " + sb3);     // displays 11

Note: the length method only returns the character count not the size of the StringBuffer - see capacity

StringBuffer sb = new StringBuffer("1234567890");

System.out.println("Reversed StringBuffer sb:" + sb.reverse());

StringBuffer sb1 = new StringBuffer("Hello World");
sb1.setLength(5);
System.out.prntln("sb1: " + sb1);     // displays Hello, it truncated the original

Note: setLength will truncate any characters if the capacity is less than the String contained inside it

StringBuffer sb = new StringBuffer("1234567890");

System.out.println("StringBuffer sb:" + sb.toString());

import java.util.StringTokenizer;

public class stringTokenizerTest {
   public static void main(String[] args) {

      String s = "This is the string to be tokenized by delimiting whitespaces";
      StringTokenizer tokens = new StringTokenerizer(s);

      System.out.println("There are " + tokens.countTokens() + " tokens" );

      System.out.println("The tokens are: ")
      while( tokens.hasMoreTokens() )
         System.out.println( tokens.nextToken() );
   }
}

String s = "This:is:the:string:to:be:tokenized:by:delimiting:whitespaces";
String delimiter = ":";
      
StringTokenizer tokens = new StringTokenerizer(s, delimiter);   // here we change the delimiter

String x = "hello have a nice day     ";

x = x.trim().concat(" and a jolly good evening").replace('hello'.'Hello');

Note: the statement is processed from left to right, so the trim method is called first, etc

x = Math.abs(99);       // returns 99
x = Math.abs(-99);      // returns the absolute value 99

Note: there are many overloaded methods that can take int, long, float, etc

x = Math.ceil(9.0);     // result is 9.0
x = Math.ceil(8.8);     // result is 9.0
x = Math.ceil(8.01);    // still rises to 9.0

Note: there is only one ceil method, ceil(double a)

x = Math.floor(9.0);     // result is 9.0
x = Math.floor(9.4);     // result is 9.0
x = Math.floor(9.99);    // still drops to 9.0

Note: there is only one ceil method, ceil(double a)

x = Math.max(1024, 1023);    // result is 1024

Note: there are many overloaded methods that can take int, long, float, etc

x = Math.min(1024, 1023);    // result is 1023

Note: there are many overloaded methods that can take int, long, float, etc

for ( int i = 1; i < 5; i++) {
   System.out.println( (int) (Math.random()*10) + " ");

Note: returns a random double number between 0.0 and 1.0

Integer i3 = Integer.valueOf("101011", 2);     // converts 101011 to 43

Float f2 = Float.valueOf("3.14f");             // assign 3.14 to Float object f2

String s1 = "42";

int i1 = Integer.parseInt(s1);                 // converts the String to a int primitive

String num1 = "42";
String num2 = "58";

System.out.println("Total: " + (num1 + num2)); // results in 4258 not what we was hoping for

Integer i1 = new Integer(num1);                // convert the String value into a primitive value
Integer i2 = new Integer(num2);

System.out.println("Total: " + (i1 + i2));     // results in 100 what we wanted

System.out.println("Total: " + (Integer.parseInt(num1) + Integer.parseInt(num2))); // another way

String num1 = "42";

Integer i1 = new Integer(num1);

System.out.println("toString reports: " + i1.toString());     // now print out a String