使用FileWriter进行Java UTF-8编码

Question

I am currently making a game in java with random world gen, at the beginning of the game I want it to store the tile ID, the X position, and the Y position so that when I re-load the game it will be able to generate it again.

When I write my file it all works but I have one issue, the output to the file is a weird combination of characters.

Code:

import java.io.*;

public class FileWrite {    
    public static FileWriter writeFile;
    public static BufferedWriter write;

    public static void recordItem(int blockID, int blockX, int blockY, String filePath, String fileName) throws Exception {
        writeFile = new FileWriter("res/save/" + filePath+ fileName, true);
        write = new BufferedWriter(writeFile);

        write.write(blockID);
        write.write(blockX);
        write.write(blockY);
        write.newLine();
        write.flush();
    }
}

Output in file:

 @ 
 ` 
 ? 
   
 ? 
 ? 
 ? 
 ? 
 ? 
 ? 
 ? 
 ? 

How do I encode my FileWriter to UTF-8 so it displays numbers? Thanks for the help. :)

Answer 1

Just a suggestion, if you would like to make a little more robust form of your persistent info, you might consider object serialization. It's easier than it sounds. Just have a static inner class that implements Serializable, something like this:

static class JunkRec implements Serializable
{
    private static final long serialVersionUID = 1L;
    final int _blockID, _blockX, _blockY;
    final String _filePath, _fileName;
    public JunkRec(int blockID, int blockX, int blockY, 
                    String filePath, String fileName) 
   {
        _blockID = blockID;
        _blockX = blockX;
        _blockY = blockY;
        _filePath = filePath;
        _fileName = fileName;
    }
    @Override
    public String toString() {
        return String.format("id=%08d x=%04d y=%04d fp=%s fn=%s", 
                _blockID, _blockX, _blockY, _filePath, _fileName);
    }
}

Now, one method to store a JunkRec...

public static void storeJunk(JunkRec jr)
{
    try (
        FileOutputStream fos = new FileOutputStream(
                jr._filePath + jr._fileName + ".ser");
        ObjectOutputStream oos = new ObjectOutputStream(fos);) {
        oos.writeObject(jr);
    } catch (IOException ioe) {
        ioe.printStackTrace();
    }
}

Another method to restore a JunkRec, given the filename.

public static JunkRec retrieveJunk(String filePath, String fileName)
{
    try (
        FileInputStream fis = new FileInputStream(
                filePath + fileName + ".ser");
        ObjectInputStream ois = new ObjectInputStream(fis);) {
        return (JunkRec) ois.readObject();
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }
    return null;
}

And finally a little test driver in main()...

public static void main(String[] args)
{
    // generate and restore 10 records
    Random r = new Random();
    List<String> names = new ArrayList<>();
    /* do a few in two ways */
    for (int i = 0; i < 5; ++i) {
        int blk = r.nextInt(10000);
        String fname = String.format("BLKID_%02d", i);
        if (names.add(fname)) {
            JunkRec jr = new JunkRec(
                    r.nextInt(10000),
                    r.nextInt(50),
                    r.nextInt(50),
                    "/tmp/",
                    fname);
            storeJunk(jr);
            System.out.println("Wrote: "+jr);
        }
    }

    /* read them all back */
    for (String fname : names) {
        JunkRec jr = retrieveJunk("/tmp/", fname);
        System.out.println("Retrieved: " + jr + " from " + fname);
    }

    /* clean up */
    for (String fname : names) {
        ((File) new File("/tmp/" + fname + ".ser")).delete();
    }
}

This is not production-quality code, but it shows how easy serialization can be. There are a gotchas, but in general Serialization is a solid solution for file-based persistence.

Just a suggestion.

Answer 2

The write method writes a single character, so you're writing characters with the Unicode codepoint of blockID, blockX, blockY which is not what you want.

Whether your Writer is encoded as UTF-8 is not so relevant here, although it is always good to be explicit about encoding if you want your files to be portable across machines, so try new OutputStreamWriter(new FileOutputStream("res/save/" + filePath+ fileName, true), "UTF-8"); instead of creating a FileWriter directly. Creating it directly doesn't allow you to specify the encoding.

Instead do something like this:

writer.write(String.format("%d %d %d\n", blockID, blockX, blockY));

This will format your three numbers as one string on one line before sending it to the file.

Note that you shouldn't create a new Writer/BufferedWriter every time that you want to write a line. You should keep them in a class field and re-use the same writer. You also need to close the file after you are done with it, since the operating system has a limit to the number of files that you have open at the same time, and you will run out of that number quickly with your current code.