/* * Copyright (c) 2000 David Flanagan.  All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.com/javaexamples2. */package com.davidflanagan.examples.serialization;import java.io.*;/** * This subclass of IntList assumes that most of the integers it contains are * less than 32,000.  It implements Externalizable so that it can define a  * compact serialization format that takes advantage of this fact. **/public class CompactIntList extends IntList implements Externalizable {    /**     * This version number is here in case a later revision of this class wants     * to modify the externalization format, but still retain compatibility     * with externalized objects written by this version     **/    static final byte version = 1;    /**     * This method from the Externalizable interface is responsible for saving     * the complete state of the object to the specified stream.  It can write     * anything it wants as long as readExternal() can read it.     **/    public void writeExternal(ObjectOutput out) throws IOException {        if (data.length > size) resize(size);  // Compact the array.	out.writeByte(version);  // Start with our version number.	out.writeInt(size);      // Output the number of array elements	for(int i = 0; i < size; i++) {  // Now loop through the array	    int n = data[i];             // The array element to write	    if ((n < Short.MAX_VALUE) && (n > Short.MIN_VALUE+1)) {		// If n fits in a short and is not Short.MIN_VALUE, then write		// it out as a short, saving ourselves two bytes		out.writeShort(n);	    }	    else {		// Otherwise write out the special value Short.MIN_VALUE to		// signal that the number does not fit in a short, and then		// output the number using a full 4 bytes, for 6 bytes total		out.writeShort(Short.MIN_VALUE);		out.writeInt(n);	    }	}    }    /**     * This Externalizable method is responsible for completely restoring the     * state of the object.  A no-arg constructor will be called to re-create     * the object, and this method must read the state written by      * writeExternal() to restore the object's state.     **/    public void readExternal(ObjectInput in)        throws IOException, ClassNotFoundException    {	// Start by reading and verifying the version number.	byte v = in.readByte();	if (v != version)	    throw new IOException("CompactIntList: unknown version number");	// Read the number of array elements, and make array that big	int newsize = in.readInt();	resize(newsize);	this.size = newsize;	// Now read that many values from the stream	for(int i = 0; i < newsize; i++) {	    short n = in.readShort();	    if (n != Short.MIN_VALUE) data[i] = n;	    else data[i] = in.readInt();	}    }    /** A main() method to prove that it works */    public static void main(String[] args) throws Exception {	CompactIntList list = new CompactIntList();	for(int i = 0; i < 100; i++) list.add((int)(Math.random()*40000));	CompactIntList copy = (CompactIntList)Serializer.deepclone(list);	if (list.equals(copy)) System.out.println("equal copies");	Serializer.store(list, new File("compactintlist.ser"));    }}