Analisando dados de arquivo txt em J2ME

votos
1

Basicamente eu estou criando um sistema de navegação interior em J2ME. Eu coloquei os detalhes de localização em um ou seja arquivo .txt

  • Locais nomes e suas coordenadas.
  • Arestas com o respectivo nó inicial e nó final, bem como o peso (comprimento do nó).

    Eu coloquei ambos os detalhes no mesmo arquivo para que os usuários não tem que baixar vários arquivos para obter o seu mapa de trabalho (ele poderia se tornar demorado e parecer complexo). Então o que eu fiz é para separar os detalhes deferentes, digitando a localização Nomes e coordena primeiro, Depois que eu separados essa seção a partir da próxima seção que é as bordas, traçando uma linha com vários sublinhados.

    Agora, o problema que estou tendo é analisar os detalhes diferentes em matrizes separadas através da criação de um comando (enquanto tokenizing manualmente o fluxo de entrada) para verificar wether o próximo token é um sublinhado.

  • Se for, (em termos pseudocode), passar para a próxima linha no fluxo, criar uma nova matriz e preenchê-lo com o próximo conjunto de detalhes.

    Eu encontrei um alguma explicação / code AQUI que faz algo semelhante, mas ainda analisa em um array, embora tokenizes manualmente a entrada. Alguma idéia do que fazer? obrigado

    Arquivo de texto Explicação
    O texto tem o seguinte formato ...

    <- 1stSection ->
     / **
      * Seção um tem o seguinte formato
      * xCoordinate; yCoordinate; LocationName
      * /

    12; 13; New York City
    40; 12; Washington DC
    ... etc

    _________________________ <- (sublinhado divisor)

    <- 2ndSection ->
     / **
      * É realmente uma lista de adjacência mas indiretamente fornece detalhes borda.
      * Seu neste formulário
      * StartNode / MainReferencePoint; Endnode1; distance2endNode1; Endnode2; distance2endNode2; ... etc
      * /

    philadelphia, Washington DC; 7; New York City; 2
    New York City; Flórida; 24; Illinois; 71
    ... etc

  • Publicado 05/01/2009 em 21:33
    fonte usuário
    Em outras línguas...                            


    1 respostas

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

    e em algum lugar da tela do aplicativo:

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

    ele vai ser fácil de obter valores de hashtable por chaves:

    (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")  
    ...
    
    Respondeu 23/04/2009 em 06:40
    fonte usuário

    Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more