Best way to store this HashMap in a file

I've got a HashMap which has a Block as key and a String as value.

How can I save it in a file?

I've tried ObjectOutputStream but since the Block class doesn't implement Serializable I can't use that one.

I've tried using a Object to Byte array converter and writing the byte array to a file:

Code:

public class ObjectConverter {
    public static byte[] convert(Object obj) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(obj);
        oos.flush();
        oos.close();
        return baos.toByteArray();
    }

    public static Object convert(byte[] bytes) throws Exception {
        Object object = null;
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));

        object = ois.readObject();

        ois.close();
        return object;
    }
}

Same result as ObjectOutputStream.

 

What's your purpose for using a Block as a key? Is it the getLocation() of the block that matters for uniqueness in your plugin? Is it the getType() of the block that matters for uniqueness? Consider making the map key more specific to the unique characteristic of the block that matters. If even that is not serializable, it will be easier to make a serializable key from it. For example mymap.put(myBlock.getType().toString(), myString).

 

I need both, getType() and getLocation().

 

You can't store a location in a hashMap

 

But you can store a location analog in a hashmap and in turn, Bukkit's Configuration

Code:java

public final class LocationSerialProxy implements ConfigurationSerializable {
 
    private final String world;
    private final String uuid;
    private final double x;
    private final double y;
    private final double z;
    private final float yaw;
    private final float pitch;
    private transient Location loc;
 
    public LocationSerialProxy(Location l) {
        this.world = l.getWorld().getName();
        this.uuid = l.getWorld().getUID().toString();
        this.x = l.getX();
        this.y = l.getY();
        this.z = l.getZ();
        this.yaw = l.getYaw();
        this.pitch = l.getPitch();
    }
 
    public LocationSerialProxy(Map<String, Object> map) {
        this.world = (String) map.get("world");
        this.uuid = (String) map.get("uuid");
        this.x = (Double) map.get("x");
        this.y = (Double) map.get("y");
        this.z = (Double) map.get("z");
        this.yaw = ((Double) map.get("yaw")).floatValue();
        this.pitch = ((Double) map.get("pitch")).floatValue();
    }
 
    public static LocationSerialProxy deserialize(Map<String, Object> map) {
        return new LocationSerialProxy(map);
    }
 
    public final Map<String, Object> serialize() {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("world", this.world);
        map.put("uuid", this.uuid);
        map.put("x", this.x);
        map.put("y", this.y);
        map.put("z", this.z);
        map.put("yaw", this.yaw);
        map.put("pitch", this.pitch);
        return map;
    }
 
    public final Location getLocation(Server server) {
        if (loc == null) {
            loc = new Location(server.getWorld(this.world), x, y, z, yaw, pitch);
        }
        return loc;
    }

 

@Sagacious_Zed Your just too pro

 

I think you misunderstand what it means to be a key in a hash. You want to capture the unique, the unchanging, the easily distinguished aspects of the data. Location isn't a good key component because very similar sub-block floating-point locations don't compare as equal. Maybe you only need the integer block locations, and not the sub-block floating-point locations. Block types change over time as people make and break their buildings.

Why are you using Block as a key?

If you really think you're on the right track, then make a custom class, which implements Serializable and maybe getHash(), and contains nothing but the features you need. Use that as your key.

Code:

class MyBlockInfo
    implements Serializable
{
    private static final long serialVersionUID = 75266236872922776147L;
    int typeid;
    String world;
    int blockx;
    int blocky;
    int blockz;
    public MyBlockInfo() { ; }
    public MyBlockInfo(Block block)
    {
        typeid = block.getTypeId();
        Location loc = block.getLocation();
        world = loc.getWorld();
        blockx = loc.getBlockX();
        blocky = loc.getBlockY();
        blockz = loc.getBlockZ();
    }
}

D'oh, ninja'd by Zed. I still don't like the idea of storing the floating-point stuff as a component of a unique hash key, though.

 

Block can't implement Serializable because it contains a Location object, which in turn contains a reference to a World object. And it should be quite obvious why you can't serialize a World object.

So you'll definitely have to do what Sagacious_Zed proposed: Break unserializable objects down into primitive dataTypes and Strings and serializable objects, then when deserializing reassemble them to something that is at least similar to the original.

 

I'll try that tomorrow.

 

@Sagacious_Zed
That bit of code was exactly the help I needed. Thanx!