String s = new String("Hi there!");
    String t = "This works too.";
    String u = String.format("Line %d", 1);

• Objects, not primitives.
• Internally represented with 16-bit Unicode characters.
• Immutable - once set, they can't be changed. They have the "appearance" of being changeable, but internally, all the routines that manipulate a string actually discard the reference to the old string object, and create a new string object. If no other references point to the old string object, it becomes eligible for garbage collection.

  This implies there are no 'in-place' string methods - all string methods that manipulate a string, return a string. Thus, if you perform an s.trim() without assigning the result to a String variable, it appears nothing has happened. What actually happened was a new String object was created that consisted of the original string with the whitespace trimmed, but since it didn't get assigned to a variable, it was immediately eligible for garbage collection.

      String s = " excess white space ";
      s.trim();     // NO! Doesn't modify s!
      s = s.trim(); // YES! This modifies s!
  

        String cat = "The cat";
        cat = cat.replace("The", "The furry");
        System.out.println(cat);

    new String("The furry cat").substring(4, 9);

Decimal   Octal   Hex    Binary    Unicode  Value
-------   -----   ---    ------    -------  -------------------------
  009      011    009   00001001   '\u0009'   HT    Horizontal Tab
  010      012    00A   00001010   '\u000A'   LF    Line Feed
  011      013    00B   00001011   '\u000B'   VT    Vertical Tab
  012      014    00C   00001100   '\u000C'   FF    Form Feed
  013      015    00D   00001101   '\u000D'   CR    Carriage Return
  028      034    01C   00011100   '\u001C'   FS    File Separator
  029      035    01D   00011101   '\u001D'   GS    Group Separator
  030      036    01E   00011110   '\u001E'   RS    Record Separator
  031      037    01F   00011111   '\u001F'   US    Unit Separator
  032      040    020   00100000   '\u0020'   SP    Space
  160      240    0A0   10100000   '\u00A0'   NBSP  Non breaking space

	s = s.intern();

Unproven Theory: I THINK that if both strings being compared exist in the string pool, the JVM knows enough to make it a simple == check (seeing if the objects point to the same string), rather than the longer .equals check, which checks character by character. But this is only my personal theory.

    StringBuilder sb = new StringBuilder("My special string");

    dog.replace(10, 13, "dog").reverse().toString();

  StringBuilder cat = new StringBuilder("The cat");
  cat.replace(4, 4, "furry "); 
  // cat is now "The furry cat"		

NOTE THE SYNTAX IS DIFFERENT THAN STRING! In the String object, you specify the 'find' phrase and the 'replace' phrase. In the StringBuffer object, you specify the beginning and ending characters instead of the 'find' phrase. The end character is exclusive. If the start and end character are the same, this method performs an insert. If the end character is higher than the start character, this method removes the characters specified by the start and end arguments, and inserts the specified string at that point.

new StringBuilder("The furry cat").substring(4, 9);

        // Won't compile - must create the StringBuilder object.
        // StringBuilder cat = "The cat";
		
        StringBuilder cat = new StringBuilder("The cat");
        cat.replace(4, 4, "furry ");
		// cat is now "The furry cat"
        System.out.println(cat);
        // Prints     "The furry cat		
        StringBuilder dog = new StringBuilder("The furry cat"); 
        // dog is now "The furry cat."
		
        // .equals doesn't compare character sequences in StringBuilder
        if (cat.equals(dog))
            System.out.println("cat == dog");
        else
            System.out.println("cat <> dog");                  
        // Prints      "cat <> dog"

        // The return value of many StringBuilder methods is the current object itself,
        // so you can concatenate operations, like:
        // dog.replace(10, 13, "dog").reverse().toString();
        // Therefore, the following lines both modify AND print the StringBuilder object.
        System.out.println(dog.replace(10, 13, "dog"));         
        // Prints     "The furry dog"
        System.out.println(dog.replace(4, 9, "barking"));       
        // Prints     "The barking dog"

    cbuf   = Destination buffer
    offset = Offset at which to start storing characters
    length = Maximum number of characters to read

    cbuf   = Destination buffer
    offset = Offset at which to start storing characters
    length = Maximum number of characters to read

    cbuf = A character array
    off  = Offset from which to start reading characters
    len  = Number of characters to write 

    str  = A string
    off  = Offset from which to start reading characters
    len  = Number of characters to write 

    cbuf = A character array
    off  = Offset from which to start reading characters
    len  = Number of characters to write 

    str  = A string
    off  = Offset from which to start reading characters
    len  = Number of characters to write 

        Console console = System.console();
        if (console == null)
            throw new RuntimeException("Couldn't get console!");

import java.io.*;
import java.util.*;

public class testIO {

    public static void main(String[] args) {
        String filename = "xxx";
        StringBuilder sb = new StringBuilder();
        sb.append("These are some lines\nfor the new\nfile.\n");

        if (FileExists(filename))               // if file exists,
            FileRemove(filename);               //   remove it.
        FileCreate(filename);                   // Create a new file.
        FileWrite(filename, sb.toString());     // Write some text to the file.

        // Make sure the normal file read is OK
        String s = FileRead(filename);          // Read some text from the file.
        if (!s.equals(sb.toString()))
            throw new RuntimeException("The FileRead failed!");

        // Make sure the buffered file read is OK
        // Read some buffered text from the file.
        String[] lines = BufferedFileRead(filename);  
        String[] orig = s.split("\n");
        if (lines.length != orig.length)
            throw new RuntimeException("The BufferedFileRead failed!");
        for (int i = 0; i < lines.length; i++) {
            if (!lines[i].equals(orig[i]))
                throw new RuntimeException("The BufferedFileRead failed!");
            else
                System.out.println(lines[i]);
        }

        // Overwrite an existing file
        FileWrite(filename, "This is some new text!");
        for (String line : BufferedFileRead(filename))
            System.out.println(line);

        // Console test
        ConsoleTest();
    }

    public static boolean FileExists(String filename) {
        // Return whether or not a file exists.
        File file = new File(filename);
        return file.exists();
    }

    public static boolean FileRemove(String filename) {
        // Delete a file, returning false if it doesn't exist.
        File file = new File(filename);
        if (!file.exists())
            return false;
        file.delete();
        return true;
    }

    public static boolean FileCreate(String filename) {
        // Create a text file, returning false if it already exists.
        File file = new File(filename);
        if (file.exists())
            return false;
       try {
           file.createNewFile();                    // Could throw IOException
       } catch (IOException ex) {
           throw new RuntimeException(ex);
       }
       return true;
    }

    public static boolean FileWrite(String filename, String s) {
        // Write a line of text to a file.
        File file = new File(filename);

        if (!file.exists())
            return false;

        try {
            FileWriter fd = new FileWriter(file);   // Could throw IOException
            fd.write(s);
            fd.close();
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }

        return true;
    }

    public static String FileRead(String filename) {
        // Read a file as text, returning the entire contents as a string.
        File file = new File(filename);
        try {
            FileReader fd = new FileReader(file);   // Could throw FileNotFoundException
            int ch;
            StringBuilder sb = new StringBuilder();
            do {
                ch = fd.read();                     // Could throw IOException
                if (ch != -1) {
                    // You must cast the value to a char!
                    // Strangely enough, ch is an int, not a char.
                    // However, there is no FileReader.read method
                    // that returns a char - only an int.
                    sb.append((char)ch); 
                }
            } while (ch != -1);
            fd.close();                             // Could throw IOException
            return sb.toString();
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    }

    public static String[] BufferedFileRead(String filename) {
        // Read a file as text, returning an array of lines.
        File file = new File(filename);
        List<String> lst = new ArrayList<String>();
        String s;
        try {
            FileReader fd = new FileReader(file);   // Could throw FileNotFoundException
            BufferedReader br = new BufferedReader(fd);
            while ((s = br.readLine()) != null)     // Could throw IOException
                lst.add(s);
            fd.close();                             // Could throw IOException
            String[] arr = new String[lst.size()];
            for (int i = 0; i < lst.size(); i++)
                arr[i] = lst.get(i);
            return arr;
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    }

    public static void ConsoleTest() {
        Console console = System.console();
        if (console == null)
            throw new RuntimeException("Couldn't get console!");
        console.format("Line: %d", 2);
        String s = console.readLine("%s", "Enter your logonid:");
        char[] password = console.readPassword("Password:");
    }
}

• If you mark a class serializable, you must import java.io.*
• For a class to be serializable, all its instance variables must be serializable.
• Only instance variables are serialized - static variables are not.
• Versioning problems can happen. If you save a MyCat object using one version of the class, but deserialize it using a different version of the class, deserialization might fail.
• To prevent instance variables from being serialized, mark them as 'transient' so the serialization process won't attempt to store them.
• For variables that can't be serialized, mark them as 'transient', or override the readObject and writeObject routines in the main class to handle them separately.
• The signature for the two methods are:

      
  	private void readObject(ObjectInputStream is)
  	private void writeObject(ObjectOutputStream os)
  

  Note they are PRIVATE, return void, and have a single argument.
• If you override readObject and writeObject, remember that the order you write the custom data in writeObject, is the order you must read them in, in readObject.
• When overriding writeObject and readObject, note that there IS no 'writeString' or 'readString' method - you must use something else instead, such as 'writeUTF' and 'readUTF'.

• All instance variables are assigned default values.
• The constructor is invoked, which immediately invokes the superclass constructor, etc.
• All superclass constructors complete.
• Instance variables that are initialized as part of their declaration are assigned their initial value (as opposed to the default value they have prior to the superclass constructors completing.)
• The constructor completes.

In addition, if a serializable subclass inherits from a non-serializable superclass, the constructors at superclass level and above will run. For all variables the subclass inherits from the superclass, the superclass will 'eat' the deserialized value of the subclass, and revert it to its default value as initialized in the superclass.

import java.io.*;

public class testSerializable {
    public static void main(String... args) {
        Person p = new Person("Kevin", 45, 65, 198);
        p.cat = new MyCat("Fluffy", "orange");
        String filename = String.format("%s.ser", p.name);
        p.SaveToFile(filename);
        Person q = Person.LoadFromFile(filename);
        System.out.printf("p = %s\n", p);
        System.out.printf("q = %s\n", q);
    }
}

class Person extends SerializeMe {
    public String name;
    protected int age;
    int height;
    private int weight;
    public transient MyCat cat;
    public Person() {
        System.out.printf("no-arg Person constructor\n");
    }
    public Person(String name, int age, int height, int weight) {
        System.out.printf("Person constructor: %s %d %d %d\n", 
            name, age, height, weight);
        this.name   = name;
        this.age    = age;
        this.height = height;
        this.weight = weight;
    }
    public int getWeight() {
        System.out.printf("getWeight %d\n", weight);
        return weight;
    }
    public void setWeight(int weight) {
        System.out.printf("setWeight %d\n", weight);
        this.weight = weight;
    }
    @Override
    public String toString() {
        return String.format("Name: %s Age: %d Height: %d Weight: %d Cat name: %s " + 
          "Cat color: %s", name, age, height, weight, cat.getName(), cat.getColor());
    }
    private void writeObject(ObjectOutputStream os) {
        try {
            os.defaultWriteObject();
            os.writeUTF(cat.getName());
            os.writeUTF(cat.getColor());
        } catch (Exception ex) {
            ex.printStackTrace();
            throw new RuntimeException(ex);
        }
    }
    private void readObject(ObjectInputStream is) {
        try {
            is.defaultReadObject();
            this.cat = new MyCat("", "");
            cat.setName(is.readUTF());
            cat.setColor(is.readUTF());
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
}

class SerializeMe implements Serializable {
    public void SaveToFile(String filename) {
        // Write the object to the specified filename.
        try {
            FileOutputStream fs = new FileOutputStream(filename);
            ObjectOutputStream os = new ObjectOutputStream(fs);
            os.writeObject(this);
            os.close();
            System.out.printf("Saved %s to file %s\n", this.toString(), filename);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
    public static <T> T LoadFromFile(String filename) {
        // Read the object from the specified filename.
        try {
            FileInputStream fis = new FileInputStream(filename);
            ObjectInputStream ois = new ObjectInputStream(fis);
            // The following does NOT call the constructor!
            T o = (T)ois.readObject();
            ois.close();
            System.out.printf("Loaded %s from file %s\n", o.toString(), filename);
            return o;
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
}

class MyCat {
    private String name;
    private String color;
    public MyCat(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getColor() { return color; }
    public void setColor(String color) { this.color = color; }
}

Person constructor: Kevin 45 65 198
Saved Name: Kevin Age: 45 Height: 65 Weight: 198 Cat name: Fluffy Cat 
   color: orange to file Kevin.ser
Loaded Name: Kevin Age: 45 Height: 65 Weight: 198 Cat name: Fluffy Cat 
   color: orange from file Kevin.ser
p = Name: Kevin Age: 45 Height: 65 Weight: 198 Cat name: Fluffy Cat 
   color: orange
q = Name: Kevin Age: 45 Height: 65 Weight: 198 Cat name: Fluffy Cat 
   color: orange

• To use the Date class, you'll have to import java.util.Date.
• The Date class is mostly deprecated; it's unaffected by time zones, and in most cases, you'll want to use the Calendar class instead.
• An instance of the Date class represents a single date and time. Internally, the Date class is a primitive long that holds the number of milliseconds (NOT seconds!) between the date it represents and January 1, 1970. If this number goes negative, it represents a date BEFORE January 1, 1970.
  Example:

          Date d1 = new Date();
          System.out.println(d1.getTime());
          d1.setTime(0);
          System.out.println(d1.toString());
          // Prints:
          // 1265601358033
          // Wed Dec 31 16:00:00 PST 1969
  

• To use the Calendar class, you'll have to import java.util.Calendar.
• You can't say "Calendar c = new Calendar" - you have to use a static factory method instead called "getInstance". Example:

  	Calendar c = Calendar.getInstance();
  

• Calendar.getTime() returns a Date object, so
• Calendar.getTime().getTime() returns the milliseconds since 1970.

• To use the DateFormat class, you'll have to import java.text.DateFormat.
• You can't say "DateFormat df = new DateFormat()" - you have to use a static factory method instead called "getInstance". Example:

  	DateFormat df = DateFormat.getInstance();
  

    DateFormat.SHORT     9/8/01
    DateFormat.MEDIUM    Sep 8, 2001
    DateFormat.LONG      September 8, 2001
    DateFormat.FULL      Saturday, September 8, 2001

    DateFormat.SHORT     9/8/01
    DateFormat.MEDIUM    Sep 8, 2001
    DateFormat.LONG      September 8, 2001
    DateFormat.FULL      Saturday, September 8, 2001

• Use this class to format numbers or currency values.
• To use the NumberFormat class, you'll have to import java.text.NumberFormat.
• You can't say "NumberFormat nf = new NumberFormat()" - you have to use a static factory method instead called "getInstance". Example:

  	NumberFormat nf = NumberFormat.getInstance();
  

import java.text.DateFormat;
import java.text.NumberFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;


public class testDateTime {
    public static void main(String[] args) {
        testDate();
        testCalendar();
        testDateFormat();
        testLocale();
        testNumberFormat();
    }
    public static void testDate() {
        Date d1 = new Date();
        System.out.println(d1.getTime());           // 1265601358033
        d1.setTime(0);
        System.out.println(d1.toString());          // Wed Dec 31 16:00:00 PST 1969
    }
    public static void testCalendar() {
        Calendar c = Calendar.getInstance();        // defaults to now
        System.out.println(c.getTime());            // Sun Feb 07 20:14:41 PST 2010
        System.out.println(c.getTime().getTime());  // 1265602481314
        c.setTime(new Date());
        c.setTimeInMillis(0);
        System.out.println(c.getTime());            // Wed Dec 31 16:00:00 PST 1969
        System.out.println(c.toString());           // BIG LONG STRING - don't want.

        // Add a month to the date.
        c.add(Calendar.MONTH, 1);
        System.out.println(c.getTime());            // Sat Jan 31 16:00:00 PST 1970

        // Add 1 hour and 1 minute to the date.
        c.add(Calendar.HOUR, 1);
        c.add(Calendar.MINUTE, 1);
        System.out.println(c.getTime());            // Sat Jan 31 17:01:00 PST 1970

        // Subtract 3 seconds from the date.
        c.add(Calendar.SECOND, -3);
        System.out.println(c.getTime());            // Sat Jan 31 17:00:57 PST 1970

        // Add 1000 days to the date using roll.
        // This will affect the day of month only, and no other field.
        // Think of it as a 'modulo' for dates.
        c.roll(Calendar.DAY_OF_MONTH, 1000);
        System.out.println(c.getTime());            // Thu Jan 08 17:00:57 PST 1970
    }
    public static void testDateFormat() {
        Date d1 = new Date(1000000000000L);
        DateFormat[] formats = new DateFormat[6];
        formats[0] = DateFormat.getInstance();
        formats[1] = DateFormat.getDateInstance();
        formats[2] = DateFormat.getDateInstance(DateFormat.SHORT);
        formats[3] = DateFormat.getDateInstance(DateFormat.MEDIUM);
        formats[4] = DateFormat.getDateInstance(DateFormat.LONG);
        formats[5] = DateFormat.getDateInstance(DateFormat.FULL);

        for (DateFormat df : formats) {
            String s = df.format(d1);
            System.out.println(s);
        }
        
        // Prints
        // 9/8/01 6:46 PM
        // Sep 8, 2001
        // 9/8/01
        // Sep 8, 2001
        // September 8, 2001
        // Saturday, September 8, 2001

        for (DateFormat df : formats) {
            String s = df.format(d1);
            Date parseDate;
            try {
                parseDate = df.parse(s);   // could throw java.text.ParseException
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
            System.out.printf("%s  = %s\n", parseDate, d1);
        }

        // Prints
        // Sat Sep 08 18:46:00 PDT 2001  = Sat Sep 08 18:46:40 PDT 2001
        // Sat Sep 08 00:00:00 PDT 2001  = Sat Sep 08 18:46:40 PDT 2001
        // Sat Sep 08 00:00:00 PDT 2001  = Sat Sep 08 18:46:40 PDT 2001
        // Sat Sep 08 00:00:00 PDT 2001  = Sat Sep 08 18:46:40 PDT 2001
        // Sat Sep 08 00:00:00 PDT 2001  = Sat Sep 08 18:46:40 PDT 2001
        // Sat Sep 08 00:00:00 PDT 2001  = Sat Sep 08 18:46:40 PDT 2001
    }

    public static void testLocale() {
        Locale locUS =Locale.US;
        Locale locPT = new Locale("it");
        Locale locBR = new Locale("it", "CH");
        Calendar c = Calendar.getInstance();
        c.set(2010, 02, 07);
        Date d1 = c.getTime();
        
        DateFormat dfUS  = DateFormat.getInstance();
        DateFormat dfIT1 = DateFormat.getDateInstance(DateFormat.FULL, locPT);
        DateFormat dfIT2 = DateFormat.getDateInstance(DateFormat.FULL, locBR);

        System.out.println("US           " + dfUS.format(d1));
        System.out.println("Italy        " + dfIT1.format(d1));
        System.out.println("Switzerland  " + dfIT2.format(d1));
        // Output:
        // US           3/7/10 9:25 PM
        // Italy        domenica 7 marzo 2010
        // Switzerland  domenica, 7. marzo 2010

        System.out.println(locUS.getDisplayCountry(locUS) + " " + 
            locUS.getDisplayLanguage(locUS));
        System.out.println(locUS.getDisplayCountry(locPT) + " " + 
            locUS.getDisplayLanguage(locPT));
        System.out.println(locUS.getDisplayCountry(locBR) + " " + 
            locUS.getDisplayLanguage(locBR));
        System.out.println("");

        System.out.println(locPT.getDisplayCountry(locUS) + " " + 
            locPT.getDisplayLanguage(locUS));
        System.out.println(locPT.getDisplayCountry(locPT) + " " + 
            locPT.getDisplayLanguage(locPT));
        System.out.println(locPT.getDisplayCountry(locBR) + " " + 
            locPT.getDisplayLanguage(locBR));
        System.out.println("");

        System.out.println(locBR.getDisplayCountry(locUS) + " " + 
            locBR.getDisplayLanguage(locUS));
        System.out.println(locBR.getDisplayCountry(locPT) + " " + 
            locBR.getDisplayLanguage(locPT));
        System.out.println(locBR.getDisplayCountry(locBR) + " " + 
            locBR.getDisplayLanguage(locBR));
        System.out.println("");

        // Output:

        // United States English
        // Stati Uniti inglese
        // Stati Uniti inglese

        //  Italian
        //  italiano
        //  italiano

        // Switzerland Italian
        // Svizzera italiano
        // Svizzera italiano
    }
    public static void testNumberFormat() {
        NumberFormat[] formats = {
                NumberFormat.getInstance(),
                NumberFormat.getInstance(Locale.ENGLISH),
                NumberFormat.getInstance(Locale.GERMANY),
                NumberFormat.getNumberInstance(),
                NumberFormat.getNumberInstance(Locale.ENGLISH),
                NumberFormat.getNumberInstance(Locale.GERMANY),
                NumberFormat.getCurrencyInstance(),
                NumberFormat.getCurrencyInstance(Locale.ENGLISH),
                NumberFormat.getCurrencyInstance(Locale.GERMANY)
        };

        for (NumberFormat nf : formats) {
            System.out.println(nf.format(123.4567f));
        }

        // Prints:
        // 123.457
        // 123.457
        // 123,457
        // 123.457
        // 123.457
        // 123,457
        // $123.46
        // ¤123.46
        // 123,46 €
    }
}

• If you use regex, you'll have to import java.util.regex.*;
• Regex helps you find text in strings. You "compile" a Pattern class for the "regular expression" you wish to find, create a Matcher class off the resulting pattern for the string you wish to search, then call a regex method on the Matcher class.
• String.split actually splits on a regex expresion. Thus, to split on a dot ., you have to truss up your statement to say s.split("\\."), so it won't think it's a metacharacter, or an invalid escaped character.
• You can't create a pattern by saying "Pattern p = new Pattern()" - you have to "compile" the pattern.
• You can't create a Matcher by saying "Matcher m = new Matcher()" - you must call the "matcher" method against a compiled pattern, to create a matcher.
• "compile" is a static method of the Pattern class, that compiles the given regular expression into a pattern p.
• "matcher" is an instance method of the Pattern class, that creates a matcher that will match the given input against this pattern.

  Example:

  import java.util.regex.*;
  
  public class testRegex {
      public static void main(String[] args) {
          String find = "n";
          // Compile the pattern
          Pattern p = Pattern.compile(find);                     
          Matcher m = p.matcher("See if you can find all the n's in this string.");
          // Create the matcher off the pattern
          System.out.printf("Found '%s' at character: ", find);  
          // Find the phrase
          while (m.find())          
              // Start index of the found phrase		
              System.out.printf("%d ", m.start());               
          System.out.println("");
          // Prints:
          // Found 'n' at character: 13 17 28 33 44 
      }
  }
  

    \d	Digit
    \s	Whitespace                             
    \w	A word character (letters, digits, or _) 
    .	Any character

    [afg]       Searches for a, f, and g characters.
    [a-g]       Searches for a, b, c, d, e, f, g characters.
    [b-cX-Y]    Searches for b, c, X, Y, Z characters.
    [acex-z]    Searches for all a, c, e, x, y, z characters.

    ^[abc]      Searches for an a, b, or c at the beginning of the line.
    [^abc]      Searches for any character OTHER than a, b, and c.
    $[xyz]      Searches for an x, y, or z at the ending of the line.
    *           Match the preceding element 0 or more times.
    +           Match the preceding element 1 or more times.
    ?           Match the preceding element 0 or 1 time.

    *?          Reluctant (non-greedy) match the preceding element 0 or more times.
    +?          Reluctant (non-greedy) match the preceding element 1 or more times.
    ??          Reluctant (non-greedy) match the preceding element 0 or 1 time.

    String:  yyxxxyxx
    Pattern: .*xx		
    Found at char 0 only.
	
    String:  yyxxxyxx
    Pattern: .*?xx
    Found at chars 0 and 4.

import java.util.regex.*;

public class testRegex {
  public static void main(String[] args) {
    FindRegex("n", "See if you can find all the n's in this string.");      
    // Found 'n' at character: 13 17 28 33 44 
    
    FindRegex("cdc", "cdcdcdc");  
    // Found 'cdc' at character: 0 4 
    
    // The next line won't compile because it needs a double backslash
    // FindRegex("\d", "0a12b3c456d"); 
    
    FindRegex("\\d", "0a12b3c456d");
    // Found '\d' at character: 0 2 3 5 7 8 9 
    
    FindRegex("\\d\\s", "0 123 a 5d 6\n");
    // Found '\d\s' at character: 0 4 11 
    
    // Search for valid hex strings only - 
    // starting with a 0, followed by x or X, 
    // and containing 1 or more occurrences of [0-9a-fA-F]
    FindRegex("0[xX][0-9a-fA-F]+", "hex string 0xab 0x0102a 0x ox");
    // Found '0[xX][0-9a-fA-F]+' at character: 11 16 
    
    // Find word, even if it's misspelled
    FindRegex("sep[ae]r[ae]te", "separate seperate separete seperete\n");
    // Found 'sep[ae]r[ae]te' at character: 0 9 18 27 
    
    // Find an identifier in a programming language
    ListRegex("[A-Za-z_][A-Za-z_0-9]*.", "public int x = 1;");
    //Pattern '[A-Za-z_][A-Za-z_0-9]*.' found at:
    //    0 public 
    //    7 int 
    //   11 x 
    
    // Find a valid phone number
    String pattern = "[01]?[- .]?(\\([2-9]\\d{2}\\)|[2-9]\\d{2})[- .]?\\d{3}[- .]?\\d{4}";
    ListRegex(pattern, "(360) 807-6299, (360)4262112, 3601234567, 4262040");
    //Pattern '[01]?[- .]?(\([2-9]\d{2}\)|[2-9]\d{2})[- .]?\d{3}[- .]?\d{4}' found at:
    //    0 (360) 807-6299
    //   15  (360)4262112
    //   29  3601234567
    
    // Greedy by default - ate all occurrences
    ListRegex(".*xx", "yyxxxyxx");
    //Pattern '.*xx' found at:
    //    0 yyxxxyxx
    
    // A question mark after the * makes it less greedy.
    ListRegex(".*?xx", "yyxxxyxx");
    //Pattern '.*?xx' found at:
    //    0 yyxx
    //    4 xyxx
    
    // How to find a dot, since dot is a metacharacter.
    FindRegex("\\.", "this.is.a.dotty.line");
    // Found '\.' at character: 4 7 9 15 
  }
  
  public static void FindRegex(String pattern, String searchstring) {
     Pattern p = Pattern.compile(pattern);
    Matcher m = p.matcher(searchstring);
    System.out.printf("Found '%s' at character: ", pattern);  
    while (m.find())                     
      System.out.printf("%d ", m.start());        
    System.out.println("");
    
  }
  
  public static void ListRegex(String pattern, String searchstring) {
     Pattern p = Pattern.compile(pattern);
    Matcher m = p.matcher(searchstring);
    System.out.printf("Pattern '%s' found at:\n", pattern);  
    while (m.find()) {                    
      System.out.printf("  %3d %s\n", m.start(), m.group());   
     }
    System.out.println("");
  }
}

• If you use Scanner, you'll have to import java.util.Scanner;
• Use a scanner when you need to split something very large, and stop partway through based on results.
• It tokenizes in a loop, allowing you to exit at any time
• It can convert tokens to their appropriate primitive automatically.

	Line
	Boolean
	Byte
	Short
	Int
	Long
	BigInteger
	Float
	Double
	BigDecimal

	Line
	Boolean
	Byte
	Short
	Int
	Long
	BigInteger
	Float
	Double
	BigDecimal

import java.util.Scanner;

public class testScanner {
  public static void main(String[] args) {
    testNext("Here is 1 true statement and 2 false ones.");
  }
  
  public static void testNext(String source) {
    // Prints
    //  Here is INT(1) BOOLEAN(true) statement and INT(2) BOOLEAN(false) ones. 
    String s;
    String retval = " ";
    Scanner scanner = new Scanner(source);
    while (scanner.hasNext()) {
      if (scanner.hasNextInt()) {
        int i = scanner.nextInt();
        retval += String.format("INT(%d) ", i);
      } else if (scanner.hasNextBoolean()) {
        boolean b = scanner.nextBoolean();
        retval += String.format("BOOLEAN(%b) ", b);
      } else {
        retval += String.format("%s ", scanner.next());
      }
    }
    System.out.println(retval);
  }
}

• System.out.printf - Writes formatted output to console
• System.out.format - Does the same thing as printf
• String.format - Returns a string

    String s = String.format(fmt, args);

The format string is a string of text that includes additional format specifiers, that tell the system how to print the arguments that follow.

The general format of the format specifier is:

    %[arg_index$][flags][width][.precision]conversionchar
    
	where:

        arg_index - the argument number to print (1-based!)
	   
        flags - is one of:
           -    Left justify the argument
           +    Include a + or - sign with the argument
           0    Pad the argument with zeroes
           ,    Use locale-specific grouping separators (ie, the comma in 5,400)
           (    Enclose negative numbers in parentheses
		   
        width - the minimum number of characters TOTAL to print,
                INCLUDING the decimal point and precision characters!
		
        precision - the number of digits to print after the decimal point
		
        conversionchar - the type of argument you'll be formatting.
           b   boolean
           c   char
           d   integer
           f   floating point
           s   string

public class testPrintF {
	public static void main(String... args) {
		String fmt = "%s\n";
		String data = "This is a line.";
		
		// The following two lines do the same thing.
		System.out.format(fmt, data);
		System.out.printf(fmt, data);
		
		// %[arg_index$][flags][width][.precision]conversion char
		
		// Default numbers won't line up
		for (int i = 9; i < 12; i++)
			System.out.format("Line %d\n", i);	
		
		// To line them up, specify the minimum width
		for (int i = 9; i < 12; i++)
			System.out.format("Line %2d\n", i);	
		
		// Floats and doubles are padded with zeros to the precision specified.
		for (double d : new double[]{1.2, 3.4, 5.667, 12.3})
			System.out.printf("%.2f\n", d);
		
		// However, they also won't line up unless you specify the width.
		for (double d : new double[]{1.2, 3.4, 5.667, 12.3, 133.6})
			System.out.printf("%6.2f\n", d);
		
		// Print arguments out of order - 1 BASED
		System.out.printf("%1$d %1$d %3$d %2$d\n", 1, 2, 3);
		
		// Test justification
		System.out.printf("\n%-10d\n%10d\n\n", 52, 52);
		
		// Print a negative number a few different ways.
		double x = -4332.678;
		System.out.printf("$%(,12.2f\n", x);
		System.out.printf("$%(,012.2f\n", x);
		System.out.printf("$%+12.2f\n", x);
	}
}

This is a line.
This is a line.
Line 9
Line 10
Line 11
Line  9
Line 10
Line 11
1.20
3.40
5.67
12.30
  1.20
  3.40
  5.67
 12.30
133.60
1 1 3 2

52        
        52

$  (4,332.68)
$(004,332.68)
$    -4332.68