在 J2ME 中从 txt 文件中解析数据

Question

基本上我是在 J2ME 中创建一个室内导航系统。我已将位置详细信息放在 .txt 文件中，即

位置名称及其坐标。

具有各自起始节点和结束节点以及权重（节点长度）的边。

我将这两个详细信息放在同一个文件中，这样用户就不必下载多个文件来使他们的地图正常工作（它可能会变得耗时且看起来很复杂）。 所以我所做的是通过首先输入位置名称和坐标来分隔不同的细节，然后我通过绘制一条带有多个下划线的线将该部分与下一部分分开，即边缘。

现在我遇到的问题是通过设置命令（同时手动标记输入流）来检查下一个标记是否是下划线，从而将不同的详细信息解析为单独的数组。

如果是，（在伪代码术语中），移动到流中的下一行，创建一个新数组并用下一组详细信息填充它。

我找到了一些解释/代码HERE，它做了类似的事情，但仍解析为一个数组，尽管它手动标记输入。关于做什么的任何想法？谢谢

文本文件说明
文本格式如下...

/**
* 第一节的格式如下
* xCoordinate;yCoordinate;位置名称
*/

12;13;纽约市
40;12;华盛顿特区
...等c

_________________________ 



/**

* 它实际上是一个邻接列表，但间接提供了“边缘”详细信息。

* 它是这种形式

* StartNode/MainReferencePoint;Endnode1;distance2endNode1;Endnode2;distance2endNode2;...e.t.c

*/


费城；华盛顿特区；7；纽约市；2

纽约市；佛罗里达州；24；伊利诺伊州；71

...等c
    

Answer 1

package filereader;

import java.io.IOException;
import java.io.InputStream;
import java.util.Hashtable;
import java.util.Vector;

public class FileReader {
    String locationSection;
    String edgeSection;
    Vector locations;
    Vector edges;

    public FileReader(String fileName) {
        // read the contents into the string
        InputStream is = getClass().getResourceAsStream(fileName);
        StringBuffer sb = new StringBuffer();
        int ch;
        try {
            while ((ch = is.read()) != -1) {
                sb.append((char) ch);
            }
        } catch (IOException e2) {
            e2.printStackTrace();
        }
        try {
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        String text = sb.toString();

        // separate locations and edges
        String separator = "_________________________";

        // read location section, without last end-of-line char
        int endLocationSection = text.indexOf(separator) - 1;
        locationSection = text.substring(0, endLocationSection);

        // read edges section, without end-of-line char after separator
        int startEdgeSection = endLocationSection + separator.length() + 3;
        edgeSection = text.substring(startEdgeSection, text.length());

        // parse locations and edges
        locations = getLocationsVector(locationSection);
        edges = getEdgesVector(edgeSection);
    }

    // parse locations section
    public Vector getLocationsVector(String section) {
        Vector result = new Vector();
        int startLine = 0;
        int endLine = section.indexOf('\n');
        while (endLine != -1) {
            String line = section.substring(startLine, endLine);
            result.addElement(parseLocationsLine(line, ';'));
            startLine = endLine + 1;
            if (endLine == section.length() - 1)
                break;
            endLine = section.indexOf('\n', startLine);
            // if no new line found, read to the end of string
            endLine = (-1 == endLine) ? section.length() - 1 : endLine;
        }
        return result;
    }

    // parse edges section
    public Vector getEdgesVector(String section) {
        Vector result = new Vector();
        int startLine = 0;
        int endLine = section.indexOf('\n');
        while (endLine != -1) {
            String line = section.substring(startLine, endLine - 1);
            result.addElement(parseEdgesLine(line, ';'));
            startLine = endLine + 1;
            if (endLine == section.length() + 1)
                break;
            endLine = section.indexOf('\n', startLine);
            // if no new line found, read to the end of string
            endLine = (-1 == endLine) ? section.length() + 1 : endLine;
        }
        return result;
    }

    // parse locations line
    public Hashtable parseLocationsLine(String value, char splitBy) {
        Hashtable result = new Hashtable();
        int xCEnd = value.indexOf(splitBy);
        int yCEnd = value.indexOf(splitBy, xCEnd + 1);
        result.put("x", value.substring(0, xCEnd));
        result.put("y", value.substring(xCEnd + 1, yCEnd));
        result.put("location", value.substring(yCEnd + 1, 
            value.length() - 1));
        return result;
    }

    // parse edges line
    public Hashtable parseEdgesLine(String value, char splitBy) {
        Hashtable result = new Hashtable();
        int snEnd = value.indexOf(splitBy);
        result.put("startnode", value.substring(0, snEnd));
        int n = 1;
        int start = snEnd + 1;
        int enEnd = value.indexOf(splitBy, snEnd + 1);
        int dstEnd = value.indexOf(splitBy, enEnd + 1);
        while (enEnd != -1 && dstEnd != -1) {
            result.put("endnode" + String.valueOf(n), 
                    value.substring(start, enEnd));
            result.put("distance" + String.valueOf(n), value.substring(
                    enEnd + 1, dstEnd));
            start = dstEnd + 1;
            enEnd = value.indexOf(splitBy, start);
            if (dstEnd == value.length())
                break;
            dstEnd = value.indexOf(splitBy, enEnd + 1);
            // if last endnode-distance pair, read to the end of line
            dstEnd = (-1 == dstEnd) ? value.length() : dstEnd;
            n++;
        }
        return result;
    }

    // getters for locations and edges
    public Vector getLocations() {
        return locations;
    }

    public Vector getEdges() {
        return edges;
    }

}

在应用程序屏幕的某处：

fr = new FileReader("/map.txt");
Vector vct1 = fr.getLocations();
for (int i = 0; i < vct1.size(); i++) {
    Hashtable location = (Hashtable) vct1.elementAt(i);
    Enumeration en = location.keys();
    String fv = "";
    while (en.hasMoreElements()) {
        String key = (String) en.nextElement();
        String value = (String)location.get(key);
        fv = fv + value + "-";
    }
    this.add(new LabelField(fv));       

}
Vector vct2 = fr.getEdges();
for (int i = 0; i < vct2.size(); i++) {
    Hashtable location = (Hashtable) vct2.elementAt(i);
    Enumeration en = location.keys();
    String fv = "";
    while (en.hasMoreElements()) {
        String key = (String) en.nextElement();
        String value = (String)location.get(key);
        fv = fv + value + "-";
    }
    this.add(new LabelField(fv));       

}

通过键从哈希表中获取值将很容易：

(String)location.get("x")  
(String)location.get("y")  
(String)location.get("location")  
(String)edge.get("startnode")  
(String)edge.get("endnode1")  
(String)edge.get("distance1")  
(String)edge.get("endnode2")  
(String)edge.get("distance2")  
...