在J2ME中模拟C语言中的文件操作
最近在写一个模拟器(OR虚拟机),用于运行文曲星(一种电子词典)上的一种类C语言开发的GVmaker程序(不知道这里有没有玩过文曲星的,关于GVmaker可以看这里).做这个东西主要是怀念一下以前玩文曲星的日子.另外刚刚买了个智能手机,尝试一下J2ME的开发,这也是我第一个J2ME程序.
这个东西并不复杂,而且因为刚学JAVA的时候写过一个桌面版的(只不过那个写的比较烂),所以构思好大体框架把各种接口定义好后就一路写过去.待到写文件系统这一块的时候才发现J2ME对文件的访问没有C语言中那么方便,也不像J2SE中有RandomAccessFile可以用.google了一下,也没有发现相关资料.于是我自己写了个在内存中模拟C语言文件操做.当然,通过内存模拟文件操作具有很大的局限性,消耗内存并且当文件过大的时候就不适用了.不过我这个就是为了模拟器中操作文件用的,而文曲星上的程序操作的文件都不会太大,所以这样用是没问题的.
下面是实现的几个主要类:
内存文件的实现

/** * 虚拟文件,使用内存模拟文件操作<p> * 每个虚拟文件除了读写数据外,还有三个属性:position,limit,capacity<p> *     其capacity描述了这个虚拟文件当前能容纳的最大数据量,这个值不能从外部修改,但在向其写入数据时根据需要内部会适当扩充其capacity<p> *     limit描述的是虚拟文件当前存储的数据总量,外部可以读取或修改或增加数据到虚拟文件.这个值在调用readFromStream时自动初始化,并且内部自动维护<p> *     position表示下一个读/写数据的地址,相当于普通文件操作中的文件指针.其初始值应该由调用者在调用readFromStream方法后正确设置<p> * 对于一个含有数据,并正确初始化的VirtualFile,应有以下关系成立:<p> *     0<=position<=limit<=capacity * @author Eastsun * @version 2008-2-25 */public final class VirtualFile {    //每次增量的最小值:128K    private static final int MIN_ADD_CAPS = 0x20000;    private static final int MAX_COUNT = 5;    //内存块,最多支持5块,也就是640K,对GVmaker来说足够了    private byte[][] bufs = new byte[MAX_COUNT][];    //caps[k]表示第0,..k-1块内存的总容量    private int[] caps = new int[MAX_COUNT + 1];    //内存块数量    private int count;    //当前所在内存块下标    private int index;    //文件长度    private int limit;    //the index of the next element to be read or written    private int position;    /**     * 使用一个初始容量构造VirtualFile     * @param size     */    public VirtualFile(int size) {        bufs[0] = new byte[size];        for (int n = 1; n <= MAX_COUNT; n++) {            caps[n] = size;        }        count = 1;    }    /**     * 得到该VirtualFile总容量     * @return capacity     */    public int capacity() {        return caps[count];    }    /**     * 得到VirtualFile中实际存储数据的长度,也就是文件的长度     * @return length of file     */    public int limit() {        return limit;    }    /**     * 得到VirtualFile中的读写指针位置,也就是文件指针     * @return position     */    public int position() {        return position;    }    /**     * 设置文件指针     * @param newPos 新的指针位置     * @return newPos 设置后的指针,若出错返回-1     */    public int position(int newPos) {        if (newPos < 0 || newPos > limit) {            return -1;        }        position = newPos;        //修改index,使其满足caps[index]<=position<caps[index+1]        while (caps[index + 1] <= position) {            index++;        }        while (caps[index] > position) {            index--;        }        return position;    }    /**     * 读取文件数据,并且position加1     * @return 当前position出的文件内容;若已到文件位(>=limit()),返回-1     */    public int getc() {        if (position >= limit) {            return -1;        }        int c = bufs[index][position - caps[index]] & 0xff;        position++;        if (position >= caps[index + 1]) {            index++;        }        return c;    }    public int putc(int ch) {        if (position > limit) {            return -1;        }        ensureCapacity(position + 1);        bufs[index][position - caps[index]] = (byte) ch;        position++;        if (position > limit) {            limit = position;        }        if (position >= caps[index + 1]) {            index++;        }        return ch;    }    /**     * 将position,limit清零     */    public void refresh() {        index = position = limit = 0;    }    /**     * 从in读取数据到VirtualFile,初始limit的值,并设置position的值为0<p>     * 操作完成后关闭in     * @param in 数据来源     * @throws java.io.IOException 发生IO错误     */    public void readFromStream(InputStream in) throws IOException {        int size = in.available();        limit = size;        ensureCapacity(size);        int n = 0;        while (size > 0) {            size -= in.read(bufs[n++]);        }        in.close();    }    /**     * 将VirtualFile中的内容写入到out<p>     * 操作完成后关闭out     * @param out 写入目标     * @throws java.io.IOException 发生IO错误     */    public void writeToStream(OutputStream out) throws IOException {        int n = 0;        while (limit > caps[n + 1]) {            out.write(bufs[n++]);        }        if (limit > caps[n]) {            out.write(bufs[n], 0, limit - caps[n]);        }        out.close();    }    //确保至少有minCap大小的内存可用    private void ensureCapacity(int minCap) {        if (caps[count] >= minCap) {            return;        }        //每次至少增加128K        int addCap = Math.max(MIN_ADD_CAPS, minCap - caps[count]);        bufs[count] = new byte[addCap];        for (int n = count + 1; n <= MAX_COUNT; n++) {            caps[n] = caps[count] + addCap;        }        count++;    }}

模拟C文件操作

/** * * @author Eastsun * @version 2008-2-22 */public class DefaultFileModel extends FileModel {    public static final String READ_MODE = "r";    public static final String READ_PLUS_MODE = "r+";    public static final String READ_B_MODE = "rb";    public static final String READ_B_PLUS_MODE = "rb+";    public static final String WRITE_MODE = "w";    public static final String WRITE_PLUS_MODE = "w+";    public static final String WRITE_B_MODE = "wb";    public static final String WRITE_B_PLUS_MODE = "wb+";    public static final String APPEND_MODE = "a";    public static final String APPEND_PLUS_MODE = "a+";    public static final String APPEND_B_MODE = "ab";    public static final String APPEND_B_PLUS_MODE = "ab+";    private static final int SEEK_SET = 0;    private static final int SEEK_CUR = 1;    private static final int SEEK_END = 2;    //同时访问文件的最大个数    private final static int MAX_FILE_COUNT = 3;    private FileSys fileSys;    private String workDir;    private boolean[] canRead;    private boolean[] canWrite;    private String[] fileNames;    //是否可用,也就是是否空闲    private boolean[] usable;    private VirtualFile[] files;    //用于生成String的byte数组    private byte[] strBuf;    //用于保存屏幕缓冲区数据    private Accessable graphBuffer;    public DefaultFileModel(FileSys fileSys) {        this.fileSys = fileSys;        workDir = "";        canRead = new boolean[MAX_FILE_COUNT];        canWrite = new boolean[MAX_FILE_COUNT];        usable = new boolean[MAX_FILE_COUNT];        files = new VirtualFile[MAX_FILE_COUNT];        fileNames = new String[MAX_FILE_COUNT];        for (int index = 0; index < MAX_FILE_COUNT; index++) {            usable[index] = true;            //初始容量:64K            files[index] = new VirtualFile(0x10000);        }        strBuf = new byte[200];    }    public boolean changeDir(Getable source, int addr) {        String newDir = getFileName(source, addr);        FileInf inf = fileSys.getFileInf(newDir);        if (inf.isDirectory()) {            workDir = newDir;            return true;        }        else {            return false;        }    }    public boolean makeDir(Getable source, int addr) {        String dir = getFileName(source, addr);        return fileSys.makeDir(dir);    }    public boolean fileList(ScreenModel screen, KeyModel key, Setable dest, int addr) {        return true;    }    public int fopen(Getable source, int fileName, int openMode) {        int num = -1;        //指示文件指针位置,true开头,false为结尾        boolean pointer = true;        //是否清除原有文件        boolean clear = false;        for (int index = 0; index < MAX_FILE_COUNT; index++) {            if (usable[index]) {                num = index;                break;            }        }        if (num == -1) {            return 0;        }        String name = getFileName(source, fileName);        String mode = getString(source, openMode);        FileInf inf = fileSys.getFileInf(name);        if (READ_MODE.equals(mode) || READ_B_MODE.equals(mode)) {            if (!(inf.isFile() && inf.canRead())) {                return 0;            }            canRead[num] = true;            canWrite[num] = false;        }        else if (READ_PLUS_MODE.equals(mode) || READ_B_PLUS_MODE.equals(mode)) {            if (!(inf.isFile() && inf.canRead() && inf.canWrite())) {                return 0;            }            canRead[num] = true;            canWrite[num] = true;        }        else if (WRITE_MODE.equals(mode) || WRITE_B_MODE.equals(mode)) {            if (inf.isFile() && !inf.canWrite()) {                return 0;            }            clear = true;            canRead[num] = false;            canWrite[num] = true;        }        else if (WRITE_PLUS_MODE.equals(mode) || WRITE_B_PLUS_MODE.equals(mode)) {            if (inf.isFile() && !inf.canWrite()) {                return 0;            }            clear = true;            canRead[num] = true;            canWrite[num] = true;        }        else if (APPEND_MODE.equals(mode) || APPEND_B_MODE.equals(mode)) {            if (!(inf.isFile() && inf.canWrite())) {                return 0;            }            canRead[num] = false;            canWrite[num] = true;            pointer = false;        }        else if (APPEND_PLUS_MODE.equals(mode) || APPEND_B_PLUS_MODE.equals(mode)) {            if (!(inf.isFile() && inf.canRead() && inf.canWrite())) {                return 0;            }            canRead[num] = true;            canWrite[num] = true;            pointer = false;        }        else {            return 0;        }        VirtualFile file = files[num];        if (clear) {            file.refresh();        }        else {            int length = 0;            try {                InputStream in = fileSys.getInputStream(name);                length = in.available();                file.readFromStream(in);                in.close();            } catch (IOException ex) {                return 0;            }            file.position(pointer ? 0 : length);        }        fileNames[num] = name;        usable[num] = false;        return num | 0x80;    }    public void fclose(int fp) {        fp &= 0x7f;        if (fp >= MAX_FILE_COUNT) {            return;        }        if (usable[fp]) {            return;        }        if (canWrite[fp]) {            try {                OutputStream out = fileSys.getOutputStream(fileNames[fp]);                files[fp].writeToStream(out);            } catch (IOException e) {            //do nothing            }        }        usable[fp] = true;    }    public int getc(int fp) {        fp &= 0x7f;        if (fp >= MAX_FILE_COUNT) {            return -1;        }        if (usable[fp] || !canRead[fp]) {            return -1;        }        return files[fp].getc();    }    public int putc(int c, int fp) {        fp &= 0x7f;        if (fp >= MAX_FILE_COUNT) {            return -1;        }        if (usable[fp] || !canWrite[fp]) {            return -1;        }        return files[fp].putc(c);    }    public int fread(Setable dest, int addr, int size, int fp) {        fp &= 0x7f;        if (fp >= MAX_FILE_COUNT) {            return -1;        }        if (usable[fp] || !canRead[fp]) {            return -1;        }        VirtualFile file = files[fp];        int count = 0, b;        while (count < size && (b = file.getc()) != -1) {            dest.setByte(addr++, (byte) b);            count++;        }        return count;    }    public int fwrite(Getable source, int addr, int size, int fp) {        fp &= 0x7f;        if (fp >= MAX_FILE_COUNT) {            return -1;        }        if (usable[fp] || !canWrite[fp]) {            return -1;        }        VirtualFile file = files[fp];        int count = 0, b;        while (count < size) {            b = source.getByte(addr++);            if (file.putc(b & 0xff) == -1) {                break;            }            count++;        }        return count;    }    public boolean deleteFile(Getable source, int addr) {        return fileSys.deleteFile(getFileName(source, addr));    }    public int fseek(int fp, int offset, int base) {        fp &= 0x7f;        if (fp >= MAX_FILE_COUNT || usable[fp]) {            return -1;        }        VirtualFile file = files[fp];        int pos = 0;        switch (base) {            case SEEK_SET:                pos = offset;                break;            case SEEK_CUR:                pos = file.position() + offset;                break;            case SEEK_END:                pos = file.limit() + offset;                break;            default:                return -1;        }        return file.position(pos);    }    public int ftell(int fp) {        fp &= 0x7f;        if (fp >= MAX_FILE_COUNT || usable[fp]) {            return -1;        }        return files[fp].position();    }    public boolean feof(int fp) {        fp &= 0x7f;        if (fp >= MAX_FILE_COUNT || usable[fp]) {            return true;        }        return files[fp].position() == files[fp].limit();    }    public void rewind(int fp) {        fp &= 0x7f;        if (fp >= MAX_FILE_COUNT || usable[fp]) {            return;        }        files[fp].position(0);    }    public void dispose() {        for (int index = 0; index < MAX_FILE_COUNT; index++) {            fclose(index | 0x80);        }    }    private String getFileName(Getable src, int addr) {        String name = getString(src, addr);        if (!name.startsWith("/")) {            name = workDir + "/" + name;        }        return name;    }    private String getString(Getable src, int addr) {        int length = 0;        byte b;        while ((b = src.getByte(addr++)) != 0) {            strBuf[length++] = b;        }        return new String(strBuf, 0, length);    }}

其中用到的两个interface:
FileSys提供了与底层文件系统的交互接口

/** * 文件系统接口<p> * 注意:方法中涉及的文件名都是GVM中用到的文件名,不一定与底层实际文件一一对应.其解释由具体实现者提供<p> * @author Eastsun * @version 1.0 */public interface FileSys {    /**     * 得到该文件的InputStream,以读取其内容     * @return in 当文件存在且canRead返回true时返回指向该文件的InputStream     * @throws java.io.IOException 文件不存在或不可读或发生IO错误     */    public InputStream getInputStream(String fileName) throws IOException;    /**     * 得到该文件的OutputStream以向其写入内容<p>     * 当文件不存在时会创建一个新的文件     * @return out  返回指向该文件的OutputStream     * @throws java.io.IOException 若文件不可写或发生IO错误     */    public OutputStream getOutputStream(String fileName) throws IOException;    /**     * 删除文件     * @param fileName 文件名     * @return true,如果删除成功     */    public boolean deleteFile(String fileName);    /**     * 建立文件夹     * @param dirName 文件夹名     * @return true,如果创建成功     */    public boolean makeDir(String dirName);    /**     * 得到指定文件/文件夹的相关信息<p>     * @param fileName 文件名     * @return 其相关信息     */    public FileInf getFileInf(String fileName);}

FileInf提供了文件的相关信息

/** * 一个描述文件信息的接口 * @author Eastsun * @version 1.0 */public interface FileInf {    /**     * 是否为一个文件     */    public boolean isFile();    /**     * 是否为一个文件夹     * @return 当仅当存在且为文件夹时返回true     */    public boolean isDirectory();    /**     * 该文件夹或文件是否可读     * @return 当且仅当存在且可读时返回true     */    public boolean canRead();    /**     * 该文件夹或文件是否可写     * @return 当仅当存在且可写时返回true     */    public boolean canWrite();    /**     * 得到文件夹下文件个数     * @return 为文件夹时返回其目录下文件个数(含子目录);否则返回-1     */    public int getFileNum();    /**     * 得到目录下第start个开始的num个文件名,保存到names中     * @param names 用于保存文件名的String数组     * @param start 开始文件号     * @param num   个数     * @return      实际得到的个数,如出错,返回-1     */    public int listFiles(String[] names, int start, int num);}