Deseriaziling parameterised/generic collections

[Andrew Ebling]

So I wrote this test code to refresh my memory on serialization, but also because I was curious if you could deserialize parameterised/generic collections (I was expecting not since generics in Java only offers compile time protection against putting the wrong stuff in a collection):

package chapter07.exercises;
 
import static org.junit.Assert.*;
import org.junit.Test;
 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.Map;
 
public class SerializingCollections {
@Test
public void serializeAHashMapOfStrings() {

Map<String, String> hm = new HashMap<String, String>();

hm.put("h", "hello");
hm.put("w", "world");

ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = null;

byte[] serializedData = null;
try {
oos = new ObjectOutputStream(baos);
oos.writeObject(hm);
serializedData = baos.toByteArray();

} catch (IOException e1) {
fail(e1+" while opening output stream");

} finally {
try {
if(oos != null) {
oos.close();
}
baos.close();
} catch (IOException ioe) {
fail(ioe+" during cleanup (writing to output stream)");
}
}


ByteArrayInputStream bais = new 
                       ByteArrayInputStream(serializedData);
 
ObjectInputStream ois = null;
 
try {
ois = new ObjectInputStream(bais);
 
                        // WARNING PRODUCED ON NEXT LINE
Map<String, String> m = (HashMap<String, String> :wink:     
                              ois.readObject();
assertEquals(m.get("h"), "hello");
assertEquals(m.get("w"), "world");
assertNull(m.get("foo"));

} catch (IOException e) {
fail(e+" during reading from input stream");

} catch (ClassNotFoundException e) {
fail(e+" during reading from input stream");

} finally {
try {
if(ois != null) {
ois.close();
}
bais.close();
} catch (IOException e) {
fail(e+" while cleaning up from read");
}
}
 
}
}
 

As you can see, the line which reads the HashMap back generates a warning. The warnings go away if I simply attempt to cast it to a non-generic Map/HashMap. But what if I want to retain the benefits of generics after deserializing this collection, without generating a compiler warning?

What would be the safe/proper way to do this?

thanks,

Andy

[Andrew Ebling]

Oh, and adding an "instanceof" check after reading the object back doesn't work either

[Srinivasan thoyyeti]

Hi Andrew,

There are no Type safe collections at runtime.
At complile time you can restrict the code.

readObject returns the HashMap encapsulated by Object which lost its type long back the program starts running.

Hence
HashMap<String,String> hm = (HashMap<String,String> ois.readObject();
warns you may not get HashMap<String,String>.

Its our risk factor.

[Chandra Bhatt]

Hi Srini,

It means if we cast Object what we get back from the readObject() method,
to the (Map<String,String> , it gives warning and the code can't compile without warning.

I was also stuck to the same warning some time ago.
Isn't there any safe way to do casting? (It is my query from you!)

As Andrew says only casting to (HashMap) does compile the code without warning; seems nice, although I have not checked that... Let me check




Regards,
cmbhatt
[ April 21, 2007: Message edited by: Chandra Bhatt ]