Core Java for the Impatient (2013)

---

9.4.4 Removing or Replacing Matches

Sometimes, you want to break by matched delimiters and keep everything else. The Pattern.split method automates this task. You obtain an array of strings, with the delimiters removed:

Click here to view code image

Pattern commas = Pattern.compile("\\s*,\\s*");
String[] tokens = commas.split(input);
// "1, 2, 3" turns into ["1", "2", "3"]

If there are many tokens, you can fetch them lazily:

Click here to view code image

Stream<String> tokens = commas.splitAsStream(input);

If you don’t care about precompiling the pattern or lazy fetching, you can just use the String.split method:

Click here to view code image

String[] tokens = input.split("\\s*,\\s*");

If you want to replace all matches with a string, call replaceAll on the matcher:

Click here to view code image

Matcher matcher = commas.matcher(input);
String result = matcher.replaceAll(",");
// Normalizes the commas

Or, if you don’t care about precompiling, use the replaceAll method of the String class.

Click here to view code image

String result = input.replaceAll("\\s*,\\s*", ",");

The replacement string can contain group numbers $n or names ${name}. They are replaced with the contents of the corresponding captured group.

Click here to view code image

String result = "3:45".replaceAll(
"(\\d{1,2}):(?<minutes>\\d{2})",
"$1 hours and ${minutes} minutes");
// Sets result to "3 hours and 45 minutes"

Use \ to escape $ and \ in the replacement string.

9.4.5 Flags

Several flags change the behavior of regular expressions. You can specify them when you compile the pattern:

Click here to view code image

Pattern pattern = Pattern.compile(regex,
Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CHARACTER_CLASS);

Or you can specify them inside the pattern:

Click here to view code image

String regex = "(?iU:expression)";

Here are the flags:

• Pattern.CASE_INSENSITIVE or i: Match characters independently of the letter case. By default, this flag takes only US ASCII characters into account.

• Pattern.UNICODE_CASE or u: When used in combination with CASE_INSENSITIVE, use Unicode letter case for matching.

• Pattern.UNICODE_CHARACTER_CLASS or U: Select Unicode character classes instead of POSIX. Implies UNICODE_CASE.

• Pattern.MULTILINE or m: Make ^ and $ match the beginning and end of a line, not the entire input.

• Pattern.UNIX_LINES or d: Only '\n' is a line terminator when matching ^ and $ in multiline mode.

• Pattern.DOTALL or s: Make the . symbol match all characters, including line terminators.

• Pattern.COMMENTS or x: Whitespace and comments (from # to the end of a line) are ignored.

• Pattern.LITERAL: The pattern is taking literally and must be matched exactly, except possibly for letter case.

• Pattern.CANON_EQ: Take canonical equivalence of Unicode characters into account. For example, u followed by ¨ (diaeresis) matches ü.

The last two flags cannot be specified inside a regular expression.

9.5 Serialization

In the following sections, you will learn about object serialization—a mechanism for turning an object into a bunch of bytes that can be shipped somewhere else or stored on disk, and for reconstituting the object from those bytes.

Serialization is an essential tool for distributed processing, where objects are shipped from one virtual machine to another. It is also used for fail-over and load balancing, when serialized objects can be moved to another server. If you work with server-side software, you will often need to enable serialization for classes. The following sections tell you how to do that.

9.5.1 The Serializable Interface

In order for an object to be serialized—that is, turned into a bunch of bytes—it must be an instance of a class that implements the Serializable interface. This is a marker interface with no methods, similar to the Cloneable interface that you saw in Chapter 4.

For example, to make Employee objects serializable, the class needs to be declared as

Click here to view code image

public class Employee implements Serializable {
private String name;
private double salary;
...
}

It is safe and appropriate to implement the Serializable interface if all instance variables have primitive or enum type, or refer to serializable objects. Many classes in the standard library are serializable. Arrays and the collection classes that you saw in Chapter 7 are serializable provided their elements are. More generally, all objects that you can reach from a serializable object need to be serializable.

In the case of the Employee class, and indeed with most classes, there is no problem. In the following sections, you will see what to do when a little extra help is needed.

To serialize objects, you need an ObjectOutputStream, which is constructed with another OutputStream that receives the actual bytes.

Click here to view code image

ObjectOutputStream out = new ObjectOutputStream(
Files.newOutputStream(path));

Now call the writeObject method:

Click here to view code image

Employee peter = new Employee("Peter", 90000);
Employee paul = new Manager("Paul", 180000);
out.writeObject(peter);
out.writeObject(paul);

To read the objects back in, construct an ObjectInputStream:

Click here to view code image

ObjectInputStream in = new ObjectInputStream(
Files.newInputStream(path));

Retrieve the objects in the same order in which they were written, using the readObject method.

Click here to view code image

Employee e1 = (Employee) in.readObject();
Employee e2 = (Employee) in.readObject();

When an object is written, the name of the class and the names and values of all instance variables are saved. If the value of an instance variable belongs to a primitive type, it is saved as binary data. If it is an object, it is again written with the writeObject method.

When an object is read in, the process is reversed. The class name and the names and values of the instance variables are read, and the object is reconstituted.

There is just one catch. Suppose there were two references to the same object. Let’s say each employee has a reference to their boss:

Click here to view code image

Employee peter = new Employee("Fred", 90000);
Employee paul = new Manager("Barney", 105000);
Manager mary = new Manager("Mary", 180000);
peter.setBoss(mary);
paul.setBoss(mary);
out.writeObject(peter);
out.writeObject(paul);

When reading these two objects back in, both of them need to have the same boss, not two references to identical but distinct objects.

In order to achieve this, each object gets a serial number when it is saved. When you pass an object reference to writeObject, the ObjectOutputStream checks if the object reference was previously written. In that case, it just writes out the serial number and does not duplicate the contents of the object.

In the same way, an ObjectInputStream remembers all objects it has encountered. When reading in a reference to a repeated object, it simply yields a reference to the previously read object.

9.5.2 Transient Instance Variables

Certain instance variables should not be serialized—for example, database connections that are meaningless when an object is reconstituted. Also, when an object keeps a cache of values, it might be better to drop the cache and recompute it instead of storing it.

To prevent an instance variable from being serialized, simply tag it with the transient modifier. Also, mark instance variables as transient if they belong to nonserializable classes. Transient fields are always skipped when objects are serialized.

9.5.3 The readObject and writeObject Methods

In rare cases, you need to tweak the serialization mechanism. A serializable class can add any desired action to the default read and write behavior, by defining methods with the signature

Click here to view code image

private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException
private void writeObject(ObjectOutputStream out)
throws IOException

Then, the object headers continue to be written as usual, but the instance variables fields are no longer automatically serialized. Instead, these methods are called.

Here is a typical example. The Point2D class in the JavaFX library is not serializable. Now, suppose you want to serialize a class LabeledPoint that stores a String and a Point2D. First, you need to mark the Point2D field as transient to avoid a NotSerializableException.

Click here to view code image

public class LabeledPoint implements Serializable {
private String label;
private transient Point2D point;
...
}

In the writeObject method, first write the nontransient label variable by calling the defaultWriteObject method. This is a special method of the ObjectOutputStream class that should only be called from within a writeObject method of a serializable class. Then, write the point coordinates using the writeDouble method from the DataOutput interface.

Click here to view code image

private void writeObject(ObjectOutputStream out)
throws IOException {
out.defaultWriteObject();
out.writeDouble(point.getX());
out.writeDouble(point.getY());
}

In the readObject method, reverse the process:

Click here to view code image

private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
in.defaultReadObject();
double x = in.readDouble();
double y = in.readDouble();
point = new Point2D(x, y);
}

The readObject and writeObject methods only need to read and write their own instance variables. They should not concern themselves with superclass data.