JavaProgrammingWorld.com

//----------------------------------------------------------------------------------
// 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);

    }

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