1. Strings

//----------------------------------------------------------------------------------
// character are simple values, and use single quotes are delimiters
char c = '\n';                           // a newline character
//----------------------------------------------------------------------------------
// strings are immutable objects, and use double quotes as delimiters
String s1 = "\n";                    // a string containing only a newline
String s2 = "Jon \"Maddog\" Orwant"; // a string containing double quotes
//----------------------------------------------------------------------------------
// use concatenation for multiline string declation
String s = "This is a multiline string declaration "
         + "using the concatenation operator "
         + "to append separate parts.";
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// accessing substrings
String s1 = data.substring(start, end);
String s2 = data.substring(start);
            
// String instances are immutable character sequences
// recreating them on the fly is unefficient
String variableString = data;
variableString = variableString.substring(0, start) + newMiddle
    + variableString.substring(start);
variableString = variableString.substring(0, start) + newTail;

// StringBuffer instances are mutable character sequences
// they provides efficient modification methods
StringBuffer variableStringBuffer = new StringBuffer(data);
variableStringBuffer.replace(start, end, newMiddle);
variableStringBuffer.replace(start, variableStringBuffer.length(), newTail);
//----------------------------------------------------------------------------------
// No real pack/unpack equivalent exist in Java. Exemples here use a custom
// implementation to split an original string into chunks of specified length

// get a 5-characters string, skip 3, then grab 2 8-characters strings,
// then the rest
try { 
    String[] a = unpack("A5 x3 A8 A8 A*", data);
} catch (ParseException ex) {}

// split at five characters boundaries
try { 
    String[] fivers = unpack(aggregate("A5 ", data.length() / 5), data);
} catch (ParseException ex) {}

// chop string into unique character strings
try { 
    String[] chars = unpack(aggregate("A1 ", data.length()), data);
} catch (ParseException ex) {}

/**
 * Unpacks a string into a string array following a given format.
 */
String[] unpack(String format, String data) throws ParseException {
    ArrayList result = new ArrayList();
    int formatOffset = 0;
    int dataOffset = 0;
    int minDataOffset = 0;
    int maxDataOffset = data.length();
    
    StringTokenizer tokenizer = new StringTokenizer(format);
    while (tokenizer.hasMoreTokens()) {
        String token = tokenizer.nextToken();
        int tokenLen = token.length();
        
        // count determination
        int count = 0;
        if (tokenLen == 1)
            count = 1;
        else if (token.charAt(1) == '*')
            count = -1;
        else {
            try {
                count = new Integer(token.substring(1)).intValue();
            } catch (NumberFormatException ex) {
                throw new ParseException("Unknown count token", formatOffset);
            }
        }
        
        // action determination
        char action = token.charAt(0);
        switch (action) {
            case 'A':
                if (count == -1) {
                    int start = (dataOffset < maxDataOffset) ?
                        dataOffset : maxDataOffset;
                    result.add(data.substring(start));
                    dataOffset = maxDataOffset;
                } else {
                    int start = (dataOffset < maxDataOffset) ?
                        dataOffset : maxDataOffset;
                    int end = (dataOffset + count < maxDataOffset) ?
                        dataOffset + count : maxDataOffset;
                    result.add(data.substring(start, end));
                    dataOffset += count;
                }
                break;
            case 'x':
                if (count == -1)
                    dataOffset = maxDataOffset;
                else
                    dataOffset += count;
                break;
            case 'X':
                if (count == -1)
                    dataOffset = minDataOffset;
                else
                    dataOffset -= count;
                break;
            default:
                throw new ParseException("Unknown action token", formatOffset);
        }
        formatOffset += tokenLen + 1;
    }
    return (String[]) result.toArray(new String[result.size()]);
}

/**
 * Aggregates repetitly a basic pattern.
 */
String aggregate(String pattern, int count) {
    StringBuffer buffer = new StringBuffer();
    for (int i=0; i < count; i++)
        buffer.append(pattern);
    return buffer.toString();
}
//----------------------------------------------------------------------------------
String data = "This is what you have";
// forward    +012345678901234567890 
// backward    109876543210987654321-

// backward indexing doesn't exist, but can easily be translated into forward
// indexing: forward = data.length() - backward;

String first = data.substring(0, 1);
// "T"
String start = data.substring(5, 7);
// "is"
String rest  = data.substring(13);
// "you have"
String last  = data.substring(data.length() - 1);
// "e"
String end   = data.substring(data.length() - 4);
// "have"
String piece = data.substring(data.length() - 8, data.length() - 5);
// "you"
//----------------------------------------------------------------------------------
String data = "This is what you have";
data = data.substring(0, 5) + "wasn't" + data.substring(7);
// "This wasn't what you have"
data = data.substring(0, data.length() - 12) + "ondrous";
// "This wasn't wondrous"
data = data.substring(1);
// "his wasn't wondrous"
data = data.substring(0, data.length() - 10);
// "his wasn'"
//----------------------------------------------------------------------------------
import org.apache.oro.text.perl.Perl5Util;

Perl5Util util = new Perl5Util();
// you can test substrings with match() method
if (util.match("/pattern/", data.substring(data.length() - 10)))
    System.out.println("Pattern matches in last 10 characters");

// substitute "at" for "is", restricted to first five characters
data = util.substitute("s/is/at/g", data.substring(0, 5)) + data.substring(5);
//----------------------------------------------------------------------------------
// exchange the first and last letters in a string
String data = "make a hat";
data = data.charAt(data.length() -1) + data.substring(1, data.length() - 1)
    + data.charAt(0); // "take a ham"
//----------------------------------------------------------------------------------
// extract column with unpack
String data = "To be or not to be";

// skip 6, grab 6
try {
    String[] a1 = unpack("x6 A6", data);       // {"or not"}
} catch (ParseException ex) {}

// forward 6, grab 2, backward 5, grab 2
try {
    String[] a2 = unpack("x6 A2 X5 A2", data); // {"or", "be"}
} catch (ParseException ex) {}
//----------------------------------------------------------------------------------
/**
 * Creates a format suitable for unpack method.
 */
String cut2fmt(int[] positions) {
    StringBuffer sb = new StringBuffer();
    int end = 1;
    for (int i=0; i < positions.length; i++) {
        sb.append("A");
        sb.append(positions[i] - end);
        sb.append(" ");
        end = positions[i];
    }
    sb.append("A*");
    return sb.toString();
}

String fmt = cut2fmt(new int[] {8, 14, 20, 26, 30}); // "A7 A6 A6 A6 A4 A*"
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// truth only concern boolean values

// use b if b is true, else c
boolean  b, c;
// [..]
boolean a = (b || c);              

// set x to y unless x is already true
boolean x, y;
// [..]
x = (x || y);
//----------------------------------------------------------------------------------
// other types must test default value
// only instance variables have default values, depending of their type:
// object -> null
// int -> 0
// char -> ?
// boolean -> ?
// local variables must always be explicitly initialised

// creating a new variable: ternary operator
//use b if b is not null, else c
Object b, c;
// [..]
Object a = (b != null) ? b : c;

// reallocating a variable: direct test
// set x to y unless x is already true
Object x, y;
// [..]
if (x == null)
    x = y;
//----------------------------------------------------------------------------------
// strings are objects, so you must use the ternary operator
String foo = (bar != null) ? bar : "DEFAULT VALUE";
// you may also consider the empty string case
// you must first test for nullity, to prevent a potential NullPointerException
String foo = ((bar != null) && (bar.length != 0)) ? bar : "DEFAULT VALUE";
//----------------------------------------------------------------------------------
int index = 0;
// lazy evaluation prevents various exceptions to occurs
String dir = ((args.length > index) && (args[index] != null)
    && (args[index].length != 0)) ? args[index] : "/tmp";
index++;
//----------------------------------------------------------------------------------
int index = 0;
// lazy evaluation prevents various exceptions to occurs
String dir = ((args.length > index) && (args[index] != null)
    && (args[index].length != 0)) ? args[index++] : "/tmp";
//----------------------------------------------------------------------------------
String dir = ((args.length != 0)) ? args[0] : "/tmp";
//----------------------------------------------------------------------------------
// Collection contains only objects, so values must be wrapped
String key = (shell != null) ? shell : "/bin/sh";
int value = 0;
if (count.containsKey(key))
    value = ((Integer) count.get(key)).intValue();
count.put(key, new Integer(++value));
//----------------------------------------------------------------------------------
// chained conditional allocations can test preceding allocation value

// find the user name on Unix systems
String user;
Properties environment = getEnvironment();
int UID = getUID();
if ((user = environment.getProperty("USER")) == null)
    if ((user = environment.getProperty("LOGNAME")) == null)
        if ((user = getLogin()) == null)
            if ((user = getPWUID(UID)[0]) == null)
                user = "Unknown uid number " + UID;

/**
 * Returns current environment.
 */
Properties getEnvironment() {
    Properties environment = new Properties();
    try {
        Process process = Runtime.getRuntime().exec("env");
        BufferedReader input =
            new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line;
        while ((line = input.readLine()) != null) {
            int limit = line.indexOf('=');
            String key = line.substring(0, limit);
            String value = line.substring(limit + 1);
            environment.setProperty(key, value);
        }
    } catch (IOException ex) {
        System.err.println("Error occured while processing environment");
    }
    return environment;
}

/**
 * Returns current login.
 */
String getLogin() {
    String login = "";
    try {
        Process process = Runtime.getRuntime().exec("cat /etc/utmp");
        BufferedReader input = 
            new BufferedReader(new InputStreamReader(process.getInputStream()));
        login = input.readLine();
    } catch (IOException ex) {
        System.err.println("Error occured while processing login");
    }
    return login;
}

/**
 * Returns current UID.
 */
int getUID() {
    int uid = 0;
    try {
        Process process = Runtime.getRuntime().exec("id -u");
        BufferedReader input =
            new BufferedReader(new InputStreamReader(process.getInputStream()));
        uid = new Integer(input.readLine()).intValue();
    } catch (IOException ex) {
        System.err.println("Error occured while processing login");
    }
    return uid;
}

/**
 * Returns /etc/passwd line relative to given UID.
 */
String[] getPWUID(int uid) {
    ArrayList pwuid = new ArrayList();
    try {
        Process process =
            Runtime.getRuntime().exec("grep ^[^:]*:[^:]*:" + uid + " /etc/passwd");
        BufferedReader input =
            new BufferedReader(new InputStreamReader(process.getInputStream()));
        StringTokenizer tokenizer = new StringTokenizer(input.readLine(), ":");
        while (tokenizer.hasMoreTokens())
            pwuid.add(tokenizer.nextToken());
    } catch (IOException ex) {
        System.err.println("Error occured while processing login");
    }
    return (String[]) pwuid.toArray(new String[pwuid.size()]);
}
//----------------------------------------------------------------------------------
// test for nullity then for emptyness
if ((startingPoint == null) || (startingPoint.length() == 0))
    startingPoint = "Greenwich";
//----------------------------------------------------------------------------------
Object[] a, b, c;

// copy only if empty
// test for nullity then for emptyness
if ((a == null) || (a.length == 0))
    a = b;

// assign b if nonempty, else c
// test for nullity then for emptyness
a = ((b != null) && (b.length != 0)) ? b : c;
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// Not possible in Java
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// char and int are interchangables, apart precision difference
// char use 16 bits while int use 32, requiring a cast from int to char
int num;
char ch;
num = ch;        // no problem 
ch = (char) num; // needs an explicit cast
//----------------------------------------------------------------------------------
System.out.println("Number " + num + " is character " + (char) num);
// Number 101 is character e
System.out.println("Character " + ch + " is number " + (int) ch);
// Character e is number 101
//----------------------------------------------------------------------------------
char[] ascii = string.toCharArray();
String string = new String(ascii);
//----------------------------------------------------------------------------------
int value      = 'e'; // now 101
char character = 101; // now "e"
//----------------------------------------------------------------------------------
System.out.println("Number " + 101 + " is character " + (char) 101);
//----------------------------------------------------------------------------------
char[] ascii = "sample".toCharArray();
// {115, 97, 109, 112, 108, 101}
String s1 = new String(ascii);
// "sample"
String s2 = new String(new char[] {115, 97, 109, 112, 108, 101});
// "sample"
//----------------------------------------------------------------------------------
String hal = "HAL";
char[] ascii = hal.toCharArray();
for (int i=0; i<ascii.length; i++)
    ascii[i]++;                 // add one to each ASCII value
String ibm = new String(ascii); // IBM
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// You can process a string either by character or by string element:
// using character is more efficient, as they are values
// using string allow to use object-based methods, as collections 

// splitting a string into elementary characters
char[] charArray = string.toCharArray();
//----------------------------------------------------------------------------------
int size = string.length();
// processing a string by elementary strings
for (int i=0; i<size; i++) {
    String s = string.substring(i, i + 1);
    // do something with s
}
// processing a string by elementary characters
for (int i=0; i<size; i++) {
    char ch = string.charAt(i);
    // do something with s
}
//----------------------------------------------------------------------------------
// with an array, using chars
String string = "an apple a day";
boolean[] seen = new boolean[256];
Arrays.fill(seen, false);

char[] array = string.toCharArray();
for (int i=0; i<array.length; i++)
    seen[array[i]] = true;

System.out.print("unique chars are: ");
for (int i=0; i<seen.length; i++)
    if (seen[i])
        System.out.print((char) i);
System.out.println(); 

//=> unique chars are:  adelnpy
//----------------------------------------------------------------------------------
// with a loop, using strings
String string = "an apple a day";
TreeSet seen = new TreeSet();

int size = string.length();
for (int i=0; i<size; i++)
    seen.add(string.substring(i, i + 1));

System.out.print("unique chars are: ");
Iterator it = seen.iterator();
while (it.hasNext())
    System.out.print(it.next());
System.out.println();

//=> unique chars are:  adelnpy
//----------------------------------------------------------------------------------
int sum = 0;
char[] chars = string.toCharArray();
for (int i=0; i<chars.length; i++)
    sum += chars[i];
System.out.println("sum is " + sum);

// prints "1248" if string was "an apple a day"
//----------------------------------------------------------------------------------
/*
 * Sum.java
 */
package pleac.ch01.part05;

import java.io.*;
/**
 * Compute 16-bit checksum of input file
 * Usage: java pleac.ch01.part05.Sum <file>
 */
public class Sum {

    public static void main(String args[]) {
        if (args.length < 1) {
            System.err.println("Usage: java pleac.ch01.part05.Sum <file>");
            System.exit(1);
        }
        
        int checksum = 0;
        try {
            Reader input = new FileReader(args[0]);
            int ch;
            while ((ch = input.read()) != -1)
                checksum += ch;
        } catch (IOException ex) {
            System.err.println("Exception occured: " + ex);
        }
        checksum %= (java.lang.Math.pow(2, 16) - 1); 

        System.out.println(checksum);
    }
    
}
//----------------------------------------------------------------------------------
//=> % java Sum /etc/termcap
//=> 53651
//----------------------------------------------------------------------------------
//=> % sum --sysv /etc/termcap
//=> 53651 1373 /etc/termcap
//----------------------------------------------------------------------------------
/*
 * Slowcat.java
 */
package pleac.ch01.part05;

import java.io.*;
/**
 * Emulate a  s l o w line printer
 * Usage: java pleac.ch01.part05.Slowcat <file>
 */
public class Slowcat {

    public static void main(String args[]) {
        if (args.length < 1) {
            System.err.println("Usage: java pleac.ch01.part05.Slowcat <file> [delay]");
            System.exit(1);
        }
        long delay = ((args.length > 1) && (args[1] != null)) ?
            1000 * new Long(args[1]).longValue() : 1000;
        
        try {
            Reader input = new FileReader(args[0]);
            int ch;
            while ((ch = input.read()) != -1) {
                System.out.print((char) ch);
                try {
                Thread.sleep(delay);
                } catch (InterruptedException ex) {}
            }
        } catch (IOException ex) {
            System.err.println("Exception occured: " + ex);
        }
    }
    
}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
String reverseCharacters(String string) {
    int length = string.length();
    char[] chars = string.toCharArray();
    char[] revChars = new char[length];
    for (int i=0; i < length; i++)
        revChars[i] = chars[length - i];
    return new String(revChars);
}
//----------------------------------------------------------------------------------
String reverseWords(String string) {
    StringTokenizer tokenizer = new StringTokenizer(string, " ");
    StringBuffer buffer = new StringBuffer();
    while (tokenizer.hasMoreTokens())
        buffer.insert(0, tokenizer.nextToken() + " ");
    return buffer.toString();
}
//----------------------------------------------------------------------------------
String string = 'Yoda said, "can you see this?"';
System.out.println(reverseWords(string));

this?" see you "can said, Yoda
//----------------------------------------------------------------------------------
// normalize whitespace
StringTokenizer tokenizer = new StringTokenizer(string, " ");
StringBuffer buffer = new StringBuffer();
while (tokenizer.hasMoreTokens())
    buffer.insert(0, tokenizer.nextToken() + " ");
//----------------------------------------------------------------------------------
// preserve whitespace
StringTokenizer tokenizer = new StringTokenizer(string, " ", true);
StringBuffer buffer = new StringBuffer();
while (tokenizer.hasMoreTokens())
    buffer.insert(0, tokenizer.nextToken());
//----------------------------------------------------------------------------------
String word = "reviver";
boolean isPalindrome = word.equals(reverseCharacters(word));
//----------------------------------------------------------------------------------
String file = "/usr/share/dict/words";
int length = 5;
try {
    BufferedReader input = new BufferedReader(new FileReader(file));
    String word;
    while ((word = input.readLine()) != null)
        if ((word.length() > length) && (word.equals(reverseCharacters(word))))
            System.out.println(word);
} catch (IOException ex) {
    System.err.println("Exception occured: " + ex);
}
//=> redder
//=> reviver
//=> rotator

//----------------------------------------------------------------------------------
String expand(String string, int tabStop) {
    int index = string.indexOf('\t');
    if (index == -1)
        return string;
    else {
        StringBuffer buffer = new StringBuffer(string);
        int count = tabStop - index % tabStop;
        buffer.deleteCharAt(index);
        for (int i=0; i<count; i++)
            buffer.insert(index, " ");
        return expand(buffer.toString(), tabStop);      
    }
}

String unexpand(String string, int tabStop) {
    StringBuffer buffer = new StringBuffer(string);
    int index = 0;
    while (index + tabStop < buffer.length()) {
        // cut original string in tabstop-length pieces
        String piece = buffer.substring(index, index + tabStop);
        // count trailing whitespace characters
        int count = 0;
        while ((count < tabStop)
            && (Character.isWhitespace(piece.charAt(tabStop - (count + 1)))))
            count++;
        // replace in original string if any whitespace was found
        if (count > 0) {
            piece = piece.substring(0, tabStop - count) + '\t';
            buffer.replace(index, index + tabStop, piece);
            index = index + tabStop - (count - 1);
        } else 
            index = index + tabStop;
    }
    return buffer.toString();
}
//----------------------------------------------------------------------------------
BufferedReader input;
String line;
// [..]
while ((line = input.readLine()) != null)
    System.out.println(expand(line), 4);
//----------------------------------------------------------------------------------
BufferedReader input;
String line;
// [..]
while ((line = input.readLine()) != null)
    System.out.println(unexpand(line), 8);
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// No interpolation in Java
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
String big = little.toUpperCase(); // "bo peep" -> "BO PEEP"
String little = big.toLowerCase(); // "JOHN"    -> "john"
//----------------------------------------------------------------------------------
String big = little.substring(0, 1).toUpperCase() + little.substring(1);
// "bo"      -> "Bo"
String little = big.substring(0, 1).toLowerCase() + big.substring(1);
// "BoPeep" -> "boPeep"
//----------------------------------------------------------------------------------
String beast   = "dromedary";
// capitalize various parts of beast
String capit1   = beast.substring(0, 1).toUpperCase()
    + beast.substring(1).toLowerCase();
// Dromedary
String capit2   = Character.toUpperCase(beast.charAt(0))
    + beast.substring(1).toLowerCase();
// Dromedary
String capall   = beast.toUpperCase();
// DROMEDARY
String caprest1 = beast.substring(0, 1).toLowerCase()
    + beast.substring(1).toUpperCase();
// dROMEDARY
String caprest2 = Character.toLowerCase(beast.charAt(0))
    + beast.substring(1).toUpperCase();
// dROMEDARY
//----------------------------------------------------------------------------------
// capitalize each word's first character, downcase the rest
String text = "thIS is a loNG liNE";
StringTokenizer tokenizer = new StringTokenizer(text);
while (tokenizer.hasMoreTokens()) {
    String word = tokenizer.nextToken();
    System.out.print(word.substring(0, 1).toUpperCase() 
                   + word.substring(1).toLowerCase()
                   + " ");
    }
//=> This Is A Long Line
//----------------------------------------------------------------------------------
String a, b;
if (a.equalsIgnoreCase(b))
    System.out.println("a and b are the same");
//----------------------------------------------------------------------------------
private Random rand;
char randomCase(char ch) {
    return (rand.nextInt(100) < 20) ? Character.toLowerCase(ch): ch;
}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// No interpolation in Java
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// No here-document in Java
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
import java.text.BreakIterator();
BreakIterator boundary = BreakIterator.getLineInstance();
//----------------------------------------------------------------------------------
/**
 * WrapDemo.java
 */
package pleac.ch01.part12;

import java.text.BreakIterator;
/**
 * Show how BreakIterator works
 */
public class WrapDemo {

    private static BreakIterator iterator = BreakIterator.getLineInstance();

    public static void main(String[] args) {
        String input = "Folding and splicing is the work of an editor,"
                 + " not a mere collection of silicon"
                 + " and"
                 + " mobile electrons!";
        int column = 20;
        String leadTab = "    ";
        String nextTab = "  ";

        System.out.println("01234567890123456789");
        input = wrapLine(leadTab + input, column);
        while (input != null)
            input = wrapLine(nextTab + input, column);
    }

    private static String wrapLine(String line, int width) {
        iterator.setText(line);
        int end = iterator.first();
        while ((end != BreakIterator.DONE) && (end <= width))
            end = iterator.next();
        if (end == BreakIterator.DONE) {
            System.out.println(line);
            return null;
        } else {
            end = iterator.previous();
            System.out.println(line.substring(0, end));
            return line.substring(end);
        }
    }

}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
Perl5Util util = new Perl5Util();
// backslash
var = util.substitute("s/([CHARLIST])/\\\\$1/g", var);

// double
var = util.substitute("s/([CHARLIST])/$1$1/g", var);
//----------------------------------------------------------------------------------
string = util.substitute("s/%/%%/g", string);
//----------------------------------------------------------------------------------
string = "Mom said, \"Don't do that.\"";
string = util.substitute("s/(['\"])/\\\\$1/g", string);
//----------------------------------------------------------------------------------
string = util.substitute("s/([^A-Z])/\\\\$1/g", string);
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
string = string.trim();
//----------------------------------------------------------------------------------
// print what's typed, but surrounded by >< symbols
try {
    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
    String line;
    while((line = input.readLine()) != null) {
        line = line.trim();
        System.out.println(">" + line + "<");
    }
} catch (IOException ex) {
    System.err.println("Exception occured: " + ex);
}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
static final String PATTERN =
    "m/\"([^\\\"\\\\]*(?:\\\\.[^\\\"\\\\]*)*)\",? | ([^,]+),? | ,/x";
Perl5Util util = new Perl5Util();

Iterator parseCSV(String text) {
    ArrayList list = new ArrayList();
    while (util.match(PATTERN, text)) {
        // find which group matched
        if (util.group(1) != null)
            list.add(util.group(1));
        else if (util.group(2) != null)
            list.add(util.group(2));
        else
            list.add(null);
        // loop on post-match string
        text = util.postMatch();
       };
       return list.iterator();
}  
//----------------------------------------------------------------------------------
String line = 
    "XYZZY,\"\",\"O'Reilly, Inc\",\"Wall, Larry\",\"a \\\"glug\\\" bit,\",5,\"Error, Core Dumped\"";
Iterator it = parseCSV(line);
while (it.hasNext())
    System.out.println(count++ + " : " + it.next());

//=> 0 : XYZZY
//=> 1 :
//=> 2 : O'Reilly, Inc
//=> 3 : Wall, Larry
//=> 4 : a \"glug\" bit,
//=> 5 : 5
//=> 6 : Error, Core Dumped
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// Sorry, no java soundex implementation found 
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
/*
 * FixStyle.java
 */
package pleac.ch01.part17;

import java.io.*;
import java.util.*;
/**
 * Switch first set of strings from to second set according to STYLE_FILE
 * Usage: see derived classes
 */
public abstract class FixStyle {

    private static final String STYLE_FILE = "pleac/ch01/part17/style";
    private static final String BACKUP_SUFFIX = ".orig";
    private static final String VERBOSE_FLAG = "-v";

    Properties changes;

    FixStyle() {
        changes = new Properties();
        try {
            InputStream input =
                getClass().getClassLoader().getResourceAsStream(STYLE_FILE);
            changes.load(input);
        } catch (IOException ex) {
            System.err.println("Style loading failed: " + ex);
        }
    }

    void fix(String[] args) {
        if (args.length < 1) {
            System.out.println("usage: java " + getClass().getName()
                + " <file> [-v]");
            System.exit(1);
        }
        String file = args[0];
        boolean verbose = ((args.length > 1) && (args[1] != null)
            && (args[1].equals(VERBOSE_FLAG))) ? true: false;
        fixFile(file, verbose);
    }

    void fixFile(String file, boolean verbose) {
         try {
            BufferedReader input = new BufferedReader(new FileReader(file));
            BufferedWriter output =
                new BufferedWriter(new FileWriter(file + BACKUP_SUFFIX));
            String line;
            int count = 0;
            while ((line = input.readLine()) != null) {
                output.write(fixLine(line, ++count, verbose));
                output.newLine();
            }
            output.close();
        } catch (IOException ex) {
             System.err.println("Exception occured: " + ex);
        }
    }

    abstract String fixLine(String line, int count, boolean verbose);

}

/*
 * FixStyle1.java
 */
package pleac.ch01.part17;

import java.util.*;
import org.apache.oro.text.perl.Perl5Util;
/**
 * Fix style using substitutions
 * Usage: java pleac.ch01.part17.FixStyle1 <file> [-v]
 */
public class FixStyle1 extends FixStyle {

    private static Perl5Util util;

    FixStyle1() {
        util = new Perl5Util();
    }

    String fixLine(String line, int count, boolean verbose) {
        Enumeration enum = changes.propertyNames();
        while (enum.hasMoreElements()) {
            String oldWord = (String) enum.nextElement();
            if (util.match("/" + oldWord + "/", line)) {
                String newWord = changes.getProperty(oldWord);
                if (verbose)
                    System.out.println("substituting " + newWord + " to "
                        + oldWord + " in line " + count);
                line = util.substitute("s/" + oldWord + "/" + newWord + "/g", line);
            }
        }
        return line;
    }

    public static void main(String[] args) {
        FixStyle fixer = new FixStyle1();
        fixer.fix(args);
    }

}

/*
 * FixStyle2.java
 */
package pleac.ch01.part17;

import java.util.*;
import java.text.BreakIterator;
/**
 * Fix style using a break iterator
 * Usage: java pleac.ch01.part17.FixStyle2 <file> [-v]
 */  
public class FixStyle2 extends FixStyle {

    private BreakIterator iterator;

    FixStyle2() {
        iterator = BreakIterator.getWordInstance();
    }

    String fixLine(String line, int count, boolean verbose) {
        // use a mutable string buffer to performs string modifications
        StringBuffer buffer = new StringBuffer(line);
        // use a break iterator to performs initial string analysis
        iterator.setText(line);
        // and keep track of offset between them
        int offset = 0;

        int start = iterator.first();
        int end = iterator.first();
        while ((end = iterator.next()) != BreakIterator.DONE) {
            String oldWord = line.substring(start, end);
            if (changes.containsKey(oldWord)) {
                String newWord = changes.getProperty(oldWord);
                if (verbose)
                    System.out.println("substituting " + newWord + " to "
                        + oldWord + " in line " + count);
                buffer.replace(start + offset, end + offset, newWord);
                offset += newWord.length() - oldWord.length();
            }
            start = end;
        }
        return buffer.toString();
    }

    public static void main(String[] args) {
        FixStyle fixer = new FixStyle2();
        fixer.fix(args);
    }

}
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// To do...
// @@INCOMPLETE@@
// @@INCOMPLETE@@
//----------------------------------------------------------------------------------