Core Java Advanced LiveLessons

Processing Input and Output

Slide navigation: Forward with space bar, → arrow key, or PgDn. Backwards with ← or PgUp.

Understand the concept of input/output streams

Input/Output Streams

• An input stream is a source of bytes.
• From file, network connection, array of bytes, and so on.
• An output stream is a destination for bytes.
• Don't confuse with readers/writers.
  • Readers/writers process characters, not bytes.
• No relationship with java.util.stream

Obtaining Streams

• Easiest to use static methods from the java.nio.file.Files class:

  Path path = Paths.get(filenameString); // We'll cover paths later this lesson
  InputStream in = Files.newInputStream(path);
  OutputStream out = Files.newOutputStream(path);

• Get an input stream from any URL:

  URL url = new URL("http://horstmann.com/index.html");
  InputStream in = url.openStream();

• Get an input stream from a byte[] array:

  byte[] bytes = ...;
  InputStream in = new ByteArrayInputStream(bytes);

• Conversely, you can write to a ByteArrayOutputStream and then collect the bytes:

  ByteArrayOutputStream out = new ByteArrayOutputStream();
  Write to out
  byte[] bytes = out.toByteArray();

Reading Bytes

• The read method returns a single byte (as an int) or -1 at the end of input:

  InputStream in = ...;
  int b = in.read();
  if (b != -1) { byte value = (byte) b; ...  }
  

• It is more common to read bytes in bulk:

  byte[] bytes = ...;
  int len = in.read(bytes);

• No method for reading all bytes from a stream. Here is one solution:

  ByteArrayOutputStream out = new ByteArrayOutputStream();
  byte[] bytes = new byte[1024];
  while ((len = in.read(bytes)) != -1) out.write(bytes, 0, len);
  bytes = out.toByteArray();

• For files, just call:

  byte[] bytes = Files.readAllBytes(path);

Writing Bytes

• You can write one byte or bytes from an array:

  OutputStream out = ...;
  int b = ...;
  out.write(b);
  byte[] bytes = ...;
  out.write(bytes);
  out.write(bytes, start, length);

• When writing to a stream, close it when you are done:

  out.close();

• Or better, use a try-with-resources block:

  try (OutputStream out = ...) {
     out.write(bytes);
  }

• To save an input stream to a file, call:

  Files.copy(in, path, StandardCopyOption.REPLACE_EXISTING);

Java 9/10 News Flash - I/O Utility Methods

• After all these years, there is finally a method to read all bytes from an input stream:

  byte[] bytes = url.openStream().readAllBytes();
  

  There is also readNBytes.
• InputStream.transferTo(OutputStream) transfers all bytes from an input stream to an output stream.
• Java 10: Reader.transferTo(Writer)
• Java 10: Character sets in PrintWriter, Scanner, etc. can be specified as Charset instead of String

  new Scanner(path, StandardCharsets.UTF_8)
  

• Scanner.tokens gets a stream of tokens, similar to Pattern.splitAsStream from Java 8:

  Stream<String> tokens = new Scanner(path).useDelimiter("\\s*,\\s*").tokens();

Read and write text files

Character Encodings

• Input/output streams process bytes.
• Text files contain characters.
• Java uses Unicode for characters.
  • Each character has a 21-bit “code point”.
  • Internally, Java uses the UTF-16 encoding.
  • Web pages commonly use UTF-8.
  • Files on desktop computers sometimes use legacy encodings (Windows 1252, MacRoman).
• Readers/writers convert between bytes and characters.
• Always specify the character encoding!
• Use StandardCharsets.UTF_8 for Charset parameters, "UTF-8" for string parameters.

Text Input

• You can obtain a Reader for any input stream:

  InputStream inStream = ...;
  Reader in = new InputStreamReader(inStream, charset);

• The read method reads one char value.
  • That's too low-level for most purposes.
• You can read a short file into a string:

  String content = new String(Files.readAllBytes(path), charset);

• You can get all lines as a list or stream:

  List<String> lines = Files.readAllLines(path, charset);
  try (Stream<String> lines = Files.lines(path, charset)) {
      ...
  }
  

jshell

import java.nio.file.*;
import java.nio.charset.*;

Files.readAllLines(Paths.get("poem.txt"), StandardCharsets.UTF_8)
Files.readAllLines(Paths.get("poem-win1252.txt"), StandardCharsets.UTF_8)
    // Throws MalformedInputException
Files.readAllLines(Paths.get("poem-win1252.txt"), Charset.forName("windows-1252"))
    // Ok
Files.readAllLines(Paths.get("poem.txt"), Charset.forName("windows-1252"))
    // Looks weird

Reading Tokens

• Use a Scanner to split input into numbers, words, and so on:

  Scanner in = new Scanner(path, "UTF-8");
  while (in.hasNextDouble()) {
     double value = in.nextDouble();
     ...
  }

• To read words, set the delimiter to any sequence of non-letters:

  in.useDelimiter("\\PL+");
  while (in.hasNext()) {
      String word = in.next();
      ...
  }

jshell

import java.nio.file.*;
import java.nio.charset.*;

Scanner in = new Scanner(Paths.get("poem.txt"), "UTF-8");
while (in.hasNext()) System.out.println(in.next());

// Now try again with
in.useDelimiter("\\PL+");

Text Output

• To write to a file, make one of these calls:

  PrintWriter out = new PrintWriter(Files.newBufferedWriter(path, charset));
  PrintWriter out = new PrintWriter(filenameString, charsetString);

• Then call out.print, out.println, or out.printf to produce output.
• Remember to close the file: try (PrintWriter out = ...) { ... }
• If you already have the entire output in a string, or a collection of lines, call:

  Files.write(path, contentString.getBytes(charset));
  Files.write(path, lines, charset);
  

• You can also append output to a file:

  Files.write(path, lines, charset, StandardOpenOption.APPEND);
  

jshell

import java.nio.file.*;
import java.nio.charset.*;

PrintWriter out = new PrintWriter("test.txt", "UTF-8")
for (int i = 1; i <= 100; i++) out.printf("%6d%n", i * i);
    // Now open another console and type cat squares.txt
out.close();
    // In the other console, type cat squares.txt

String Writers

• Sometimes, a library method wants a Writer object. Example:

  Throwable.printStackTrace(PrintWriter out)

• If you want to capture the output in a string, not a file, use a StringWriter:

  StringWriter writer = new StringWriter();
  throwable.printStackTrace(new PrintWriter(writer));

• Now you can process the stack trace as string:

  String stackTrace = writer.toString();

jshell

StringWriter writer = new StringWriter();
new Throwable().printStackTrace(new PrintWriter(writer));
writer.toString()

Work with binary data

Reading and Writing Binary Data

• Storing numbers as text is less efficient than storing them in binary.
• DataInput/DataOutput interfaces have methods readInt/writeInt, readDouble/writeDouble, and so on.
• Can wrap any stream into a DataInputStream/DataOutputStream:

  DataInput in = new DataInputStream(Files.newInputStream(path));
  DataOutput out = new DataOutputStream(Files.newOutputStream(path));

Random Access Files

• Reading/writing stream data is sequential.
• “Random access file”: You can jump to any file position and start reading/writing.
• Open with "r" for reading or "rw" for writing:

  RandomAccessFile file = new RandomAccessFile(filenameString, "rw");

• The getFilePointer method yields the current position (as a long).
• The seek method moves to a new position.
• Example: Increment an integer that you just read:

  int value = file.readInt();
  file.seek(file.getFilePointer() - 4);
  file.writeInt(value + 1);
  

lesson03/randomAccess

Memory-Mapped Files

• A memory-mapped file provides very efficient random access for large files.
  • Uses operating system mechanism for virtual memory.
• Get a channel for the file:

  FileChannel channel = FileChannel.open(path,
      StandardOpenOption.READ, StandardOpenOption.WRITE)

• Map an area of the file (or all of it) into memory:

  ByteBuffer buffer = channel.map(FileChannel.MapMode.READ_WRITE,
      0, channel.size());

• You use methods get, getInt, getDouble, and so on to read, and the equivalent put methods to write:

  int position = ...;
  int value = buffer.getInt(position);
  buffer.put(position, value + 1);

• The file is updated at some point, and certainly when the channel is closed.

lesson03/memoryMap

java memoryMap.MemoryMapTest /opt/jdk1.8.0/src.zip 
java memoryMap.MemoryMapTest2 /opt/jdk1.8.0/src.zip 

Create, access, and delete files and directories

Paths

• Path objects specify abstract path names (which may not currently exist on disk).
• Sequence of directory names, optionally followed by a file name.
• First component may be a root component such as / or C:\
• Path starting with a root is absolute.
• Other paths are relative.
• Use Paths.get to create paths:

  Path absolute = Paths.get("/", "home", "cay");
  Path relative = Paths.get("myapp", "conf", "user.properties");

• Path separator / or \ is supplied for the default file system.
• If you know which platform your program is running, you can provide a string with separators:

  Path homeDirectory = Paths.get("/home/cay");

Working with Paths

• The call p.resolve(q) computes “p then q”.
• If q is absolute, that's just q.
• Otherwise, first follow p, then follow q:

  Path workPath = homeDirectory.resolve("myapp/work");

• The opposite of resolve is relativize, yielding “how to get from p to q”.
  • Paths.get("/home/cay").relativize(Paths.get("/home/fred/myapp")) yields "../fred/myapp".
• normalize removes ./ or directory/../ and other redundancies.
• toAbsolutePath makes a path absolute.

Taking Paths Apart

• Utility methods to get at the most important parts:

  Path p = Paths.get("/home", "cay", "myapp.properties");
  Path parent = p.getParent(); // The path /home/cay
  Path file = p.getFileName(); // The last element, myapp.properties
  Path root = p.getRoot(); // The initial segment / (null for a relative path)
  Path first = p.getName(0); // The first element
  Path dir = p.subpath(1, p.getNameCount()); // All but the first element

• You can iterate over the components:

  for (Path component : path) {
      ...
  }

• To interoperate with legacy File class, use:

  File file = path.toFile();
  Path path = file.toPath();

jshell

import java.nio.file.*;
Path p = Paths.get(".")
p = p.toAbsolutePath()
p.resolve("../lesson2")
p.resolve("../lesson2").normalize()
p.getParent()
p.getFileName()
p.getRoot()
p.getName(0)
p.getNameCount()

Creating Files and Directories

• To create a new directory, call:

  Files.createDirectory(path); // All but the last component must exist
  Files.createDirectories(path); // Missing components are created
  

• You can create an empty file:

  Files.createFile(path);
  

• If the file exists, an exception occurs. Check and creation are atomic.
• Convenience methods for creating temporary files:

  Path tempFile = Files.createTempFile(dir, prefix, suffix);
  Path tempFile = Files.createTempFile(prefix, suffix);
  Path tempDir = Files.createTempDirectory(dir, prefix);
  Path tempDir = Files.createTempDirectory(prefix);

• Files.createTempFile(null, ".txt") might return a path such as /tmp/1234405522364837194.txt

Checking File Properties

• Files.exists(path) checks whether a path currently exists.
• Use Files.isDirectory(path), Files.isRegularFile(path), Files.isSymbolicLink(path) to find out whether the path is a directory, file, or symlink.
• You can get more information with static methods such as isHidden, isExecutable, isReadable, isWritable of the Files class.
• Files.size(path) reports the file size as a long value.

Copying, Moving, and Deleting Files

• Use the copy or move method:

  Files.copy(fromPath, toPath);
  Files.move(fromPath, toPath);

• Can define behavior with copy options:

  Files.copy(fromPath, toPath, StandardCopyOption.REPLACE_EXISTING,
      SteandardCopyOption.COPY_ATTRIBUTES);
  Files.move(fromPath, toPath, StandardCopyOption.ATOMIC_MOVE);

• Delete a file like this:

  Files.delete(path); // Throws exception if path doesn't exist
  boolean deleted = Files.deleteIfExists(path);

Visiting Directory Entries

• Files.list(dirpath) yields a Stream<Path> of the directory entries.
• The directory is read lazily—efficient for huge directories.
• Be sure to close the stream:

  try (Stream<Path> entries = Files.list(pathToDirectory)) { ... }

• Call Files.walk(dirpath) to visit all descendants of subdirectories as well.
• Descendants are visited in depth-first order.
  • When a directory is visited, its children are visited before the next sibling:

    ...
    java/nio/ByteBufferAsDoubleBufferB.java
    java/nio/charset
    java/nio/charset/CoderMalfunctionError.java
    java/nio/charset/CharsetDecoder.java
    java/nio/charset/spi
    java/nio/charset/spi/CharsetProvider.java
    ...
    java/nio/charset/UnsupportedCharsetException.java
    java/nio/HeapFloatBufferR.java
    ...

• If you filter results by file attributes (size, creation time, and so on), use find instead of walk for greater efficiency:

  Files.find(path, maxDepth, (path, attr) -> attr.size() > 100000)

jshell

Files.list(Paths.get("../..")).forEach(System.out::println)
Files.walk(Paths.get("../..")).forEach(System.out::println)
Files.find(Paths.get("../.."), Integer.MAX_VALUE,
    (p, attr) -> attr.size() > 100000).forEach(System.out::println)

Copying and Deleting Directory Trees

• Use Files.walk to copy a directory tree:

  Files.walk(source).forEach(p -> {
      try {
          Path q = target.resolve(source.relativize(p));
          if (Files.isDirectory(p))
              Files.createDirectory(q);
          else
          Files.copy(p, q);
      } catch (IOException ex) {
          throw new UncheckedIOException(ex);
      }
  });

• Unfortunately, this approach doesn't work for deleting a directory tree.
  • Need to visit the children before deleting the parent.
• Use FileVisitor instead:

  Files.walkFileTree(root, new SimpleFileVisitor<Path>() {
     public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
         Files.delete(file);
         return FileVisitResult.CONTINUE;
      }
      public FileVisitResult postVisitDirectory(Path dir, IOException ex) throws IOException {
          if (ex != null) throw ex;
          Files.delete(dir);
          return FileVisitResult.CONTINUE;
      }
  });

Zip Files

• Paths class looks up paths in the default file system.
• Can have file system for the files in a ZIP archive:

  FileSystem zipfs = FileSystems.newFileSystem(Paths.get(zipname), null);

• Copy out a file if you know its name:

  Files.copy(zipfs.getPath(sourceName), targetPath);

• To list all files in an archive, walk the file tree:

  Files.walk(zipfs.getPath("/")).forEach(p -> { Process p });

• Here is the magic incantation for creating a zip file:

  Path zipPath = Paths.get("myfile.zip");
  URI uri = new URI("jar", zipPath.toUri().toString(), null);
      // Constructs the URI jar:file://myfile.zip
  try (FileSystem zipfs = FileSystems.newFileSystem(uri, Collections.singletonMap("create", "true"))) {
      // To add files, copy them into the ZIP file system
      Files.copy(sourcePath, zipfs.getPath("/").resolve(targetPath));
  }

jshell

Path p = Paths.get("/opt/jdk1.8.0/src.zip")
FileSystem zipfs = FileSystems.newFileSystem(p, null)
Files.walk(zipfs.getPath("/")).limit(100).forEach(System.out::println)
Files.copy(zipfs.getPath("/java/lang/String.java"), Paths.get("/tmp/String.java"));

Path zipPath = Paths.get("/tmp/myfile.zip");
URI uri = new URI("jar", zipPath.toUri().toString(), null);
FileSystem zipfs = FileSystems.newFileSystem(uri,
    Collections.singletonMap("create", "true"))
InputStream in = new ByteArrayInputStream("Hello".getBytes("UTF-8"));
Files.copy(in, zipfs.getPath("/hello.txt"))
zipfs.close();

Process data from the internet

URLs and URL Connections

• You can read data from a given URL:

  URL url = new URL("http://horstmann.com/index.html");
  InputStream in = url.openStream();

• That gets you the contents of the URL (from the GET request).
• You need to use the URLConnection class for more complex cases:
  • Making a POST request
  • Setting request headers
  • Reading response headers

The Five Stages of URL Connections

1. Get an URLConnection object:

   URLConnection connection = url.openConnection();

2. Set request properties:

   connection.setRequestProperty("Accept-Charset", "UTF-8, ISO-8859-1");

3. Send data to the server:

   connection.setDoOutput(true);
   try (OutputStream out = connection.getOutputStream()) { Write to out }

4. Read the response headers:

   connection.connect(); // If you skipped step 3
   Map<String, List<String>> headers = connection.getHeaderFields();

5. Read the response:

   try (InputStream in = connection.getInputStream()) { Read from in }

Making a Form Post

• When writing to a HttpURLConnection, the default encoding is application/x-www-form-urlencoded.
• But you still need to encode the name/value pairs.
• Suppose POST data are given in a map:

  URLConnection connection = url.openConnection();
  connection.setDoOutput(true);
  try (Writer out = new OutputStreamWriter(
          connection.getOutputStream(), StandardCharsets.UTF_8)) {
      boolean first = true;
      for (Map.Entry<String, String> entry : postData.entrySet()) {
          if (first) first = false;
          else out.write("&");
          out.write(URLEncoder.encode(entry.getKey(), "UTF-8"));
          out.write("=");
          out.write(URLEncoder.encode(entry.getValue(), "UTF-8"));
      }
  }

lesson03/post

firefox https://www.usps.com/zip4/

java post.PostTest > /tmp/out.html
firefox /tmp/out.html

• Normally, redirects are automatic.
• Normally, the user agent is java.
• In our case, we fake the user agent to be HTTPie.
• That doesn't get carried into a redirect, so we have to do them by hand.

Java 9 News Flash - HttpClient

• Intended to replace fussy URLConnection/HttpURLConnection
• Supports HTTP/2.
• In jdk.incubator package.
  • Run with --add-modules jdk.incubator.httpclient
• Build a client:

  HttpClient client = HttpClient.newBuilder()
      .followRedirects(HttpClient.Redirect.ALWAYS)
      .build();

• Build a request:

  HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("http://horstmann.com"))
      .GET()
      .build();
  

HttpClient

• Get and handle response:

  HttpResponse<String> response = client.send(request, HttpResponse.BodyHandler.asString());

• Asynchronous processing (see Lesson 4):

  client.sendAsync(request, HttpResponse.BodyHandler.asString())
     .completeOnTimeout(errorResponse, 10, TimeUnit.SECONDS)
     .thenAccept(response -> Process response.body());
  

• Big feature: HTTP/2 support.
• Still work in progress—no support for application/x-www-form-urlencoded, multipart/form-data, JSON body handler, ...

jshell

jshell --add-modules jdk.incubator.httpclient
  

import jdk.incubator.http.*;
import java.net.*;

HttpClient client = HttpClient.newBuilder().build();
HttpRequest request = HttpRequest.newBuilder().
   uri(URI.create("http://www.gutenberg.org/files/11/11-0.txt")).
   GET().
   build();
client.sendAsync(request, HttpResponse.BodyHandler.asString()).
   thenAccept(response -> System.out.println(response.body()));

Work with regular expressions

Regular Expressions

• Regular expressions (regex) specify string patterns.
• The regex [Jj]e?a.+ matches Java and jealous but not Jim or ja.
• Special characters . * + ? { | ( ) [ \ ^ $
• . matches any character.
• * is 0 or more, + 1 or more, ? 0 or 1 repetition.
• Use braces for other multiplicities such as {2,4}
• | denotes alternatives: (Java|Scala)
• () are used for grouping.
• [...] delimit character classes, such as [A-Za-z]
• Useful predefined character classes such as \s (space), \pL (Unicode letters), complements \S, \PL
• ^ and $ match the beginning and end of input.
• Escape special characters with \ to match them literally.
• Caution: Must double-escape \ in Java strings.

Finding All Matches in a String

• Two principal ways to use a regex:
  • Find all matches within a string.
  • Find whether the entire string matches.
• This loop iterates over all matches of a regex in a string:

  Pattern pattern = Pattern.compile(regexString);
  Matcher matcher = pattern.matcher(input);
  while (matcher.find()) {
      String match = matcher.group();
      ...
  }

• Use matcher.start(), matcher.end() to get the position of the current match in the string.

jshell

import java.util.regex.*
Matcher matcher = Pattern.compile("[0-9]+").matcher(input)
String input = "9:45am";
while (matcher.find()) System.out.println(matcher.group());

Finding Whether a String Matches

• Use the matches method to check whether a string matches a regex:

  String regex = "[12]?[0-9]:[0-5][0-9][ap]m";
  if (Pattern.matches(regex, input)) { ... }

• Compile the regex if you need it repeatedly:

  Pattern pattern = Pattern.compile(regex);
  Matcher matcher = pattern.matcher(input);
  if (matcher.matches()) ...

• Can turn the pattern into a predicate:

  Stream<String> result = streamOfStrings.filter(pattern.asPredicate());

jshell

String regex = "[12]?[0-9]:[0-5][0-9][ap]m";
Pattern.matches(regex, "9:45am")
Pattern.matches(regex, "9:65")

import java.util.stream.*
import java.util.regex.*
import java.nio.file.*

Files.lines(Paths.get("/usr/share/dict/words")).
   filter(Pattern.compile(".+q.+q.+").asPredicate()).
   forEach(System.out::println)

Groups

• Use groups to match subexpressions.
• Example: Match records such as

  Blackwell Toaster USD29.95

• Regex with groups:

  (\p{Alnum}+(\s+\p{Alnum}+)*)\s+([A-Z]{3})([0-9.]*)

• Use the group method to get at each group:

  Matcher matcher = pattern.matcher(input);
  if (matcher.matches()) {
      item = matcher.group(1);
      currency = matcher.group(3);
      price = matcher.group(4);
  }

• Group index values start with 1.
• Here, group 2 was needed for the repetition.
• Clearer with named groups:

  (?<item>\p{Alnum}+(\s+\p{Alnum}+)*)\s+(?<currency>[A-Z]{3})(?<price>[0-9.]*)

• Then you retrieve items by name:

  item = matcher.group("item");

Splitting Strings

• Specify the delimiter as a regex:

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

• Fetch result lazily for large inputs:

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

• If you don't care about efficiency, just use the String.split method:

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

Replacing Matches

• To replace all matches, call replaceAll on the matcher:

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

• If you don't care about efficiency, just use the String.replaceAll method:

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

• Group numbers $n or names $name are replaced with the captured group:

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

• Jamie Zawinsky: Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.

Java 9 News Flash - Regex Improvements

• Matcher.stream and Scanner.findAll gets a stream of match results:

  Pattern pattern = Pattern.compile("[^,]");
  Stream<String> matches = pattern.matcher(str).results().map(MatchResult::group);
  matches = new Scanner(path).findAll(pattern).map(MatchResult::group);

• Matcher.replaceFirst/replaceAll now have a version with a replacement function:

  String result = Pattern.compile("\\pL{4,}")
      .matcher("Mary had a little lamb")
      .replaceAll(m -> m.group().toUpperCase());
      // Yields "MARY had a LITTLE LAMB"

Understand the concept of serialization

Serialization

• Serialization turns an object into a sequence of bytes.
• Deserialization is the opposite: turning a sequence of bytes back into an object.
• Useful for sending objects to a different computer.
• Useful for short-term storage (e.g. cache).
• Not intended for long-term storage.
• Participating classes implement the Serializable marker interface:

  public class Employee implements Serializable { ... }

Saving a Serializable Object

• Construct an ObjectOutputStream object:

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

• Call the writeObject method:

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

Loading a Serializable Object

• Construct an ObjectInputStream object:

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

• Retrieve the objects in the same order as they were saved:

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

Serialization Preserves Object References

• Consider this network of objects:

  Employee peter = new Employee("Peter", 40000);
  Manager paul = new Manager("Paul", 105000);
  Manager mary = new Manager("Mary", 180000);
  paul.setAdmin(peter);
  mary.setAdmin(peter);
  ObjectOutputStream out = new ObjectOutputStream(
      Files.newOutputStream(path));
  out.writeObject(peter);
  out.writeObject(paul);
  out.writeObject(mary);

• When reading the managers back in, both of them need to have the same admin.
• Each object gets a serial number.
• Each object reference is saved with that serial number.
• When reloading object references, they are matched up with the deserialized object with that serial number.

Tweaking the Serialization Mechanism

• Declare fields that shouldn't be serialized with the transient modifer.
• You can take over serialization of fields by implementing the readObject/writeObject methods.
  • Useful for saving instances of non-serializable classes.
• You can delegate serialization and deserialization to a proxy by implementing the readResolve/writeReplace methods.
  • Useful in rare cases when object identity needs to be preserved.
• You can declare multiple versions of serializations.
  • Default serialVersionUID is obtained by hashing field names and types.
  • If the serialVersionUID changes, readObject throws an exception.
  • You can declare your own version ID and implement deserialization to consider multiple versions.

    private static final long serialVersionUID = 2L; // Version 2

  • Complex and rarely useful.

objectStream