java - java中永远无法通过键盘输入的字符

Question

目前我正在使用 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#

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

我想知道的是这个，

1. 这是一个好的做法吗？我不需要向直接从文本查看器打开文件的人隐藏数据，所以我认为这没问题。但它有效率吗？还有更好的方法吗？

2. 我面临的最大问题是，如果应该存储的字符串包含我选择的特殊字符('#')怎么办？

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

3. 我还在考虑将每 5 个字符设为空，这样我只在 4 个空格上写入数据，并将每 5 个空格设为空，这样我就可以将其用于特殊标记。例如，如果年龄为 7，类型为 10，狗的名字为“abcdefghijklmnopqrstuvwxyz”，则结果字符串将为

   #0007#0010#abcd^efgh^ijkl^.........^yz <

'#'是数据分隔符

^ 只是一个字符，表示此时不应分隔数据

< 表示如果此标记左侧有空格字符，则不应将其视为数据的一部分，应将其截掉

Answer 1

例如，创建一个名为 Stateful 的接口(interface)。任何实现此接口(interface)的类都将负责加载和保存。

DogTest.java

public class DogTest {
    public static void main(String[] args) {
        Dog dogA = new Dog(7, 10, "abcdefghijklmnopqrstuvwxyz");

        String state = dogA.save();
        System.out.println(state); // #0007#0010#abcd^efgh^ijkl^mnop^qrst^uvwx^yz#

        Dog dogB = new Dog().load(state);
        System.out.println(dogB); // Dog [age=7, type=10, name=abcdefghijklmnopqrstuvwxyz]
    }
}

Stateful.java

public interface Stateful<T> {
    static final String DATA_SEP = "#";
    static final String SEGMENT_SEP = "^";

    T load(String data);
    String save();
}

Dog.java

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

StatefulUtil.java

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);
    }
}