Why is the HashMap transient inside HashSet implementation? - collections

Question

HashSet class itself implements Serializable, but the Hashmap it uses to store all of it's data is kept transient. Wouldn't all the data be lost on deserializing it? What's the point of serializing it then?

Answer 1

A HashSet serializes as a basic set. Upon deserialization, a new HashMap is constructed to hold the data. There's no need to serialize the map, with key-value pairs, when all you care about is the keys.

Answer 2

First, you are right ,transient hashmap in hashset will not be serialized, but hashset store data in its field hashmap, you think when do serialize, hashset may lost it's data, by read HashSet source code you will find there two methods called writeObject and readObject in HashSet, when do serializes, will invoke writeObject method in hashset to store data,and when do deserialize,will invoke readObject method in hashset to restore data,so serialize it's field hashmap is not necessary
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out HashMap capacity and load factor
s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());
// Write out size
s.writeInt(map.size());
// Write out all elements in the proper order.
for (E e : map.keySet())
s.writeObject(e);
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read capacity and verify non-negative.
int capacity = s.readInt();
if (capacity < 0) {
throw new InvalidObjectException("Illegal capacity: " +
capacity);
}
// Read load factor and verify positive and non NaN.
float loadFactor = s.readFloat();
if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
throw new InvalidObjectException("Illegal load factor: " +
loadFactor);
}
// Read size and verify non-negative.
int size = s.readInt();
if (size < 0) {
throw new InvalidObjectException("Illegal size: " +
size);
}
// Set the capacity according to the size and load factor ensuring that
// the HashMap is at least 25% full but clamping to maximum capacity.
capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f),
HashMap.MAXIMUM_CAPACITY);
// Constructing the backing map will lazily create an array when the first element is
// added, so check it before construction. Call HashMap.tableSizeFor to compute the
// actual allocation size. Check Map.Entry[].class since it's the nearest public type to
// what is actually created.
SharedSecrets.getJavaOISAccess()
.checkArray(s, Map.Entry[].class, HashMap.tableSizeFor(capacity));
// Create backing HashMap
map = (((HashSet<?>)this) instanceof LinkedHashSet ?
new LinkedHashMap<E,Object>(capacity, loadFactor) :
new HashMap<E,Object>(capacity, loadFactor));
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
#SuppressWarnings("unchecked")
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}