Question

要根据命令保存传送点，我有一个HashMap：

public HashMap<Player, Location> mapHomes = new HashMap<>();

可以这样访问：

if(cmd.getName().equalsIgnoreCase("sethome")){
    Location loc = player.getLocation();
    mapHomes.put(player, loc);
    sender.sendMessage("Home set !");
    return true;
}
if(cmd.getName().equalsIgnoreCase("home")){
    Location loc1 = mapHomes.get(player);
    player.teleport(loc1);
    sender.sendMessage("Teleported to home");
    return true;
}
return false;

由于这些设置应该在重启时保留，我已经实现了一种保存方法：

public void save(HashMap<Player,Location> mapHome, String path) throws NotSerializableException{
    try{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path));
        oos.writeObject(mapHome);
        oos.flush();
        oos.close();
    }catch(Exception e){
        e.printStackTrace();
    }
}

但它没有用。它抛出NotSerializableException。

我认为主要问题是Player和Location不是可序列化的类型，那么我该怎么做呢HashMap？

Answer 1

HashMap已经Serializable。

问题是地图中的对象不是，所以你也必须使它们可序列化。

public class SerializedPlayer extends Player implements Serializable {
    public SerializedPlayer() {}
    public SerializedPlayer(Player playerToClone) {
        this.setField1(playerToClone.getField1());
        // Set all the fields
    }
}

添加到地图时：

map.put(new SerializedPlayer(player), new SerializedLocation(location));

Answer 2

当一个实例需要NotSerializableException接口时，抛出

Serializable。

class YourClass implements Serializable {
    // ...
}

Answer 3

class Player implements Serializable {}

class Location implements Serializable {}

请记住，您只能序列化实现Serializable接口的对象。因此，您的Player和Location类也必须实现该接口。

Answer 4

我认为你正在写HashMap<Player, Location>到档案。

您需要做的是让您的Player和Location类可序列化。

public class Player implements java.io.Serializable {
    // ...
}

public class Location implements java.io.Serializable {
    // ...
}

HashMap已经可序列化了。

Answer 5

要使Location可序列化，我建议使用this class。我自己写了，只是请你在代码中给我信用。

package com.github.JamesNorris.Class;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Server;
import org.bukkit.World;

/**
 * The class that allows location to be serialized, and be used
 * in a file. This class should not be changed, otherwise it
 * will not work for older files.
 * 
 * @author Jnorr44
 */

public final class SerializableLocation implements Serializable {
    private static final long serialVersionUID = 8650311534439769069L;

    private final String world;
    private final String uuid;
    private final double x, y, z;
    private final float yaw, pitch;
    private transient Location loc;

    /**
     * Creates a new SerializableLocation instance of any org.bukkit.Location.
     * 
     * @param l
     */

    public SerializableLocation(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();
    }

    /**
     * Gets the org.bukkit.Location back from any SerializableLocation.
     * 
     * @param l
     * @return
     */

    public static Location returnLocation(SerializableLocation l) {
        float pitch = l.pitch;
        float yaw = l.yaw;
        double x = l.x;
        double y = l.y;
        double z = l.z;
        World world = Bukkit.getWorld(l.world);
        Location location = new Location(world, x, y, z, yaw, pitch);
        return location;
    }

    // FROM HERE ON NEEDS DOC NOTES

    public SerializableLocation(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 = ((Float) map.get("yaw")).floatValue();
        this.pitch = ((Float) map.get("pitch")).floatValue();
    }

    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) {
            World world = server.getWorld(this.uuid);
            if (world == null) {
                world = server.getWorld(this.world);
            }
            loc = new Location(world, x, y, z, yaw, pitch);
        }
        return loc;
    }
}

现在只需：

SerializableLocation loc = new SerializableLocation(LOCATION);

这是必需的，因为Location包含world，x，y，z，yaw和{{1} }，pitch不可序列化。

Answer 6

实际上，您正在尝试序列化Player和Location，尝试实现新类等。但为什么要这样做呢？

如果不存储Player和Location对象，而是存储它们的字符串表示形式会更好。例如，您可以使用Player.getName()和类似"world:100:65:100"的位置（因此我们可以轻松通过String.split(":")获取所有数据。我认为这是一种更好的方法。

使用ObjectOutputStream保存HashMap

6 个答案: