在java中，键盘永远无法键入的字符

目前，我正在使用java创建一个应用程序，在该应用程序中，我试图添加一个代码，手动将类序列化为字符串，并将其保存到文件中

例如，有这样一个类

public class dog{
    int age;
    int type; 
    String name;
}

我选择使用这个函数手动将这个类变成一个字符串，结果类似于xml，但只是我编造的东西

public String classToString(dog d){
    String resultString = "" ;
    resultString + "#" ; 
    resultString + d.age;
    resultString + "#" ; 
    resultString + d.type;
    resultString + "#" ; 
    resultString + d.name;
    resultString + "#" ; 
    return resultString;

}

sp此函数将返回某种字符串，如

#7#4#Rex#

然后，当我读取文件时，我将使用#作为某种分隔不同数据的标记来区分不同的数据

我想知道的是

这是一种好的做法吗？我不需要对直接从文本查看器打开文件的人隐藏数据，所以我认为这是可以的。但它是否有效？有更好的方法吗

我面临的最大问题是，如果应该存储的字符串中包含我选择的特殊字符（“#”），该怎么办

为了解决这个问题，我想知道是否有一个特殊的保留字符不能用键盘或其他用户界面写入，这样我就不必保存包含该字符的字符串

我也在考虑每5个字符都是空的，所以我只在4个空格上写数据，每5个空格都是空的，这样我就可以用它来做特殊的标记。例如，如果年龄为7岁，类型为10，狗的名称为“abcdefghijklmnopqrstuvwxyz”，则结果字符串为

---

#0007#0010#abcd^efgh^ijkl^………^yz只需使用有状态的或可序列化的类。下面是一个可序列化类的示例：

public class Dog implements Serializable {
 ...
 }

然后可以使用

ObjectOutputStream

和

ObjectInputStream

分别写入和读取对象

ObjectOutputStream out = new ObjectOutputStream( yourFileStream );
out.writeObject(yourDogObject);

---

这将把

yourDogObject

写入

yourdfilestream

，只需使用

Stateful

或

Serializable

类即可。下面是一个可序列化类的示例：

public class Dog implements Serializable {
 ...
 }

然后可以使用

ObjectOutputStream

和

ObjectInputStream

分别写入和读取对象

ObjectOutputStream out = new ObjectOutputStream( yourFileStream );
out.writeObject(yourDogObject);

---

例如，这将把

yourDogObject

写入

yourdfilestream

创建一个名为

Stateful

的接口。实现此接口的任何类都将负责加载和保存

DogTest.java Stateful.java

公共接口有状态{
静态最终字符串数据_SEP=“#”；
静态最终字符串段_SEP=“^”；
T加载（字符串数据）；
字符串save（）；
}

Dog.java

公共类Dog实现有状态{
私人互联网；
私有int型；
私有字符串名称；
公犬（）{
这（0，0，“”）；
}
公用狗（整数年龄、整数类型、字符串名称）{
超级（）；
这个。年龄=年龄；
this.type=type；
this.name=名称；
}
@凌驾
公共字符串toString（）{
返回“Dog[age=“+age+”，type=“+type+”，name=“+name+””；
}
@凌驾
公共狗负载（字符串数据）{
String[]fragments=StatefulUtil.parse（数据）；
this.age=Integer.parseInt（片段[1]，10）；
this.type=Integer.parseInt（片段[2]，10）；
this.name=StatefulUtil.decode（片段[3]）；
归还这个；
}
@凌驾
公共字符串保存（）{
StringBuffer buff=新的StringBuffer（Stateful.DATA_SEP）；
append（StatefulUtil.format（this.age））.append（Stateful.DATA_SEP）；
append（StatefulUtil.format（this.type））.append（Stateful.DATA_SEP）；
buff.append（StatefulUtil.encode（this.name））.append（Stateful.DATA_SEP）；
返回buff.toString（）；
}
}

StatefulUtil.java

公共类StatefulUtil{
公共静态字符序列编码（字符串值）{
返回单独的（转义（值），有状态。段_SEP，4）；
}
公共静态字符串解码（字符串值）{
返回join（value.split（“\\”+Stateful.SEGMENT\u SEP），“”）。toString（）；
}
私有静态字符串转义（字符串值）{
返回值.replace（Stateful.DATA\u SEP，“\\”+Stateful.DATA\u SEP）；
}
公共静态字符序列格式（int值）{
返回字符串。格式（“%04d”，值）；
}
公共静态字符序列分隔符（字符串值、字符串分隔符、int偏移量）{
StringBuffer buff=新的StringBuffer（值）；
int n=buff.length（）/偏移量；
对于（int i=0；i0）{
buff.append（arr[0]）；
}
对于（int i=1；i

例如，创建一个名为

有状态的接口。实现此接口的任何类都将负责加载和保存

DogTest.java
Stateful.java
公共接口有状态{
静态最终字符串数据_SEP=“#”；
静态最终字符串段_SEP=“^”；
T加载（字符串数据）；
字符串save（）；
}

Dog.java
公共类Dog实现有状态{
私人互联网；
私有int型；
私有字符串名称；
公犬（）{
这（0，0，“”）；
}
公用狗（整数年龄、整数类型、字符串名称）{
超级（）；
这个。年龄=年龄；
this.type=type；
this.name=名称；
}
@凌驾
公共字符串toString（）{
返回
public class Dog implements Stateful<Dog> {
    private int age;
    private int type;
    private String name;

    public Dog() {
        this(0, 0, "");
    }

    public Dog(int age, int type, String name) {
        super();
        this.age = age;
        this.type = type;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dog [age=" + age + ", type=" + type + ", name=" + name + "]";
    }

    @Override
    public Dog load(String data) {
        String[] fragments = StatefulUtil.parse(data);

        this.age = Integer.parseInt(fragments[1], 10);
        this.type = Integer.parseInt(fragments[2], 10);
        this.name = StatefulUtil.decode(fragments[3]);

        return this;
    }

    @Override
    public String save() {
        StringBuffer buff = new StringBuffer(Stateful.DATA_SEP);

        buff.append(StatefulUtil.format(this.age)).append(Stateful.DATA_SEP);
        buff.append(StatefulUtil.format(this.type)).append(Stateful.DATA_SEP);
        buff.append(StatefulUtil.encode(this.name)).append(Stateful.DATA_SEP);

        return buff.toString();
    }
}

public class StatefulUtil {
    public static CharSequence encode(String value) {
        return separate(escape(value), Stateful.SEGMENT_SEP, 4);
    }

    public static String decode(String value) {
        return join(value.split("\\" + Stateful.SEGMENT_SEP), "").toString();
    }

    private static String escape(String value) {
        return value.replace(Stateful.DATA_SEP, "\\" + Stateful.DATA_SEP);
    }

    public static CharSequence format(int value) {
        return String.format("%04d", value);
    }

    public static CharSequence separate(String value, String separator, int offset) {
        StringBuffer buff = new StringBuffer(value);
        int n = buff.length() / offset;

        for (int i = 0; i < n; i++) {
            int index = i + ((i + 1) * offset);
            buff.insert(index, separator);
        }

        return buff;
    }

    public static CharSequence join(String[] arr, String separator) {
        StringBuffer buff = new StringBuffer();

        if (arr != null) {
            if (arr.length > 0) {
                buff.append(arr[0]);
            }

            for (int i = 1; i < arr.length; i++) {
                buff.append(separator).append(arr[i]);
            }
        }

        return buff;
    }

    // Regular expression: /^#|[^\\\\]#/ - Match beginning '#' and each non-escaped '#"
    public static String[] parse(String data) {
        return data.split("^" + Stateful.DATA_SEP + "|[^\\\\]" + Stateful.DATA_SEP);
    }
}

Dog dog = load(Dog.class, "dog.xml");

public <T> T load(Class<T> type, String path) {
    JAXBContext jc = JAXBContext.newInstance();
    Unmarshaller u = jc.createUnmarshaller();
    return type.cast(u.unmarshal(new FileInputStream(path));
}

public <T> void save(T obj, String path) {
    JAXBContext jc = JAXBContext.newInstance();
    Marshaller m = jc.createMarshaller();
    m.unmarshal(obj, new FileOutputStream(path));
}

@XmlRootElement(name="dog")
public class Dog implements Stateful<Dog> {

    @XmlAttribute(name = "vs")
    private String dataVersion = "1.0";

    @XmlAttribute(name = "age")
    private int age;

    @XmlAttribute
    private int type;

    @XmlElement(name = "name")
    private String name;
}

<dog vs="1.0" age="6" type="3">
    <name>Cerberus</name>
</dog>