How in God's name does it know, that one rea - java help on CodeGym

Lines 23 and 28? How does it make that difference? How do we know that the first time we readInt it brings back the capacity and the next time we readInt it returns the size? What kind of magic is this? Also, what about readFloat? In the description it just says it reads a 32 bit float. How do we know that is the loadFactor? What happens if we accidentally readFloat multiple times or if it has been read before by somebody else and we don't know it? It all seems so... random ?

private void writeObject(ObjectOutputStream s) throws java.io.IOException {
     // Write out any hidden serialization magic
     s.defaultWriteObject();

     // Write out HashMap capacity and load factor
     s.writeInt(HashMapReflectionHelper.<Integer>callHiddenMethod(map, "capacity"));
     s.writeFloat(HashMapReflectionHelper.<Float>callHiddenMethod(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(ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
     // Read in any hidden serialization magic
     s.defaultReadObject();

     // Read in HashMap capacity and load factor and create backing HashMap
     int capacity = s.readInt();
     float loadFactor = s.readFloat();
     map = new HashMap<>(capacity, loadFactor);

     // Read in size
     int size = s.readInt();

     // Read in all elements in the proper order.
     for (int i = 0; i < size; i++) {
         E e = (E) s.readObject();
         map.put(e, PRESENT);
     }
 }

public class HashMapReflectionHelper { public static <T> T callHiddenMethod(HashMap map, String methodName) { try { Method method = map.getClass().getDeclaredMethod(methodName); method.setAccessible(true); return (T) method.invoke(map); } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException ignored) { } return null; } }

Comments (5)

Popular
New
Old

You must be signed in to leave a comment

Thomas

Level 41 , Bayreuth, Germany

10 July 2021, 11:10

solution

there is nothing random. You read in the same order as you have written the data. If you won't do that your code breaks. first the object data, then capacity, load factor and size and finally the elements of the map. You could change that order (except writing the elements as you need the before data to create the map) but you need to do that in both methods, read and write. As far as I know the load factor is just some value defining the behaviour of a map when to resize itself. And that's a float. So you get that info from the map you want to save and you just save that value (cause it's a float you save a float -> line 7). When loading the value you of course load it just one time otherwise you would break your code. Or you save it twice, then you need to load it twice before you advance to the next relevant value. Each read method blocks (again afaik, you'd have to check the API docs to make sure). So while reading a value you can not interrupt it. But in between the reads you could mess things up if you pass the streams reference to another method (in another thread) and try to read values there as well from the stream. But why do you want to do that? And if you need to do that, you need to use synchronization or other possibilities you have to avoid problems. That's the same as in the core quest, you read value by value but of course you can mess up things with force if you really want that.

10 July 2021, 11:48

useful

capacity() is package private in HashMap... the HashMapReflectionHelper is a CG predefined class that lets you invoke not visible methods using reflection? WIth getDeclaredMethod, setAccessible, invoke? Or did you have to write the helper class yourself? Did CG ginve some hints that you need to have a look at the HashMap implementation to solve this task?

Andrei

Level 41

12 July 2021, 08:34

Thanks, Thomas, it makes more sense now. So they have an order in which the capacity and float are written you just need to remember what the order is. Is this order strict and you must respect it? Or can we create the order we want? This is the HashMapReflectionHelper, it is a class provided by CodeGym, which indeed does the things you mentioned:

What CG says at the end is to take a look at the HashSet source, download it, connect it and compare it to my code. I am trying to download it but I have no idea, I will research some more.

12 July 2021, 09:38

Ahh, OK, then they are not totally unfair in this task ;) (thanks for posting the helper class) And yes, you can chose the order yourself but have to take care that it makes sense. Like the map, to create it the way CG asks you need to know capacity and loadFactor. So you need to save that two values before you save the map (cause when loading you need these two values to create the map) And you probably shall have a look at the source of the HashSet to see that it is similar to the code you just have written (declare a hashset field somewhere in a class then right click, goto -> declaration or usages -> enjoy the code)

12 July 2021, 10:00

Ah, OK. That makes sense. Thanks! 👍

How in God's name does it know, that one readtInt() is capacity and the next readInt() is size?