1

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

  • 地点名称及其坐标。
  • 具有各自起始节点和结束节点的边以及权重(节点的长度)。

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

    现在我遇到的问题是通过设置命令(同时手动标记输入流)将不同的细节解析为单独的数组,以检查下一个标记是否是下划线。

  • 如果是,(在伪代码术语中),移动到流中的下一行,创建一个新数组并用下一组细节填充它。

    我在这里找到了一些解释/代码,它做了类似的事情,但仍然解析成一个数组,尽管它手动标记了输入。关于做什么的任何想法?谢谢

    文本文件说明
    文本具有以下格式...

    <--1stSection-->
     /**
      * 第一节的格式如下
      * xCoordinate;yCoordinate;LocationName
      */

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

    _________________________ <--(下划线分隔符)

    <--2ndSection-->
     /**
      * 它实际上是一个邻接列表,但间接提供了“边缘”细节。
      * 它的形式
      * StartNode/MainReferencePoint;Endnode1;distance2endNode1;Endnode2;distance2endNode2;...等
      */

    费城;华盛顿特区;7;纽约市;2
    纽约市;佛罗里达;24;伊利诺伊州;71
    ...等

  • 4

    1 回答 1

    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")  
    ...
    
    于 2009-04-23T05:40:13.760 回答