java - Java中高效的字符串读取？

Question

我收到一个数据包，例如

“c~ 1”M:0013A20040559361 Ax:48 Ay:10 Az:1012 Tp:25 B:45？时间:星期三，02/01/13 - 16:16.57 S°~"

和其他无法粘贴的字符。我必须读取冒号后面的值。例如，M:、Ax:、Ay: 并将其存储或绘制在图表中。我知道两种方法:StreamTokenizer 或简单的java 逻辑。问题是我已经尝试了这两种方法，但在读取值时仍然收到太多错误。另外，我尝试了字符串垃圾收集器，它也不起作用。

下面是两者的代码:

if(message2.contains("Ax:"))
    {
    int index = message2.indexOf("Ax:");
    String Ax = message2.substring(index+3);
    ChartAcceleration.tsAx.addOrUpdate(new Millisecond(), Double.valueOf(Ax));
    }

StreamTokenizer Code:

StreamTokenizer st = new StreamTokenizer(
                new StringReader(message));

         boolean eof = false;
        while(st.nextToken() != StreamTokenizer.TT_EOF){

              int token = st.nextToken();
              switch (token) {
                 case StreamTokenizer.TT_WORD:
                     String word = st.sval;
                     if(word.contains("Ax"))
                     {
                         Ax = true;
                     }
                     else
                         if(word.contains("Ay"))
                     {
                         Ay = true;
                     }
                         else
                             if(word.contains("Az"))
                         {
                             Az = true;
                         }
                             else
                                 if(word.contains("P"))
                             {
                                 P = true;

                             }
                                 else
                                     if(word.contains("B"))
                                 {
                                     B = true;
                                 }
                                     else
                                         if(word.contains("Tp"))
                                     {
                                         Tp = true;
                                        }
                                         else
                                         {
                                             Ax = false;
                                             Ay = false;
                                             Az = false;
                                             P = false;
                                             B = false;
                                             Tp = false;
                                         }
                 //   System.out.println("Word: " + word);
                    break;
                 case StreamTokenizer.TT_NUMBER:
                     double number = st.nval;
                     if(Ax)
                     {
                         Ax = false;
                    //   errorChecker(AxStr,number);
                        AxStr = number;
                         Sender.publishAccelerator("Ax:" + String.valueOf(AxStr));
                     }
                     else
                         if(Ay)
                         {
                             Ay = false;
                             AyStr = number;
                             Sender.publishAccelerator("Ay:"+String.valueOf(AyStr));
                         }
                         else if(Az)
                         {
                             Az = false;
                             AzStr = number;
                             Sender.publishAccelerator("Az:"+String.valueOf(AzStr));
                            // System.out.println("Az:"+AzStr);

                         }
                         else
                            if(P)
                                 {
                                     P = false;
                                     PStr = number;
                                     Sender.publishPressure(String.valueOf(PStr));
                                     //System.out.println("P:"+PStr);

                                 }
                                 else
                                     if(B)
                                     {
                                         B = false;
                                         BStr = number;
                                         Sender.publishBattery(String.valueOf(BStr));
                                     }
                                     else
                                         if(Tp)
                                         {
                                             Tp = false;
                                             TpStr = number;
                                             Sender.publishTemp(String.valueOf(TpStr));
                                         }
                    break;

                 default:
              }
        }

Answer 1

我为您的文本编写了一个字符串解析程序。

您定义要解析的标记和结束标记。

这是我的结果。

Ay: 10
Az: 1012
Tp: 25
B: 45
Ax: 48
Tm: Wednesday, 02/01/13 - 16:16.57

这是解析代码。

import java.util.Iterator;
import java.util.Properties;
import java.util.Set;

public class StringParsing {

    private String[][] tokens = { {"Ax:", " "}, 
            {"Ay:", " "}, {"Az:", " "}, {"Tp:", " "}, {"B:", " "},
            {"Tm:", " Sº"} };

    public Properties parseString(String s) {
        Properties p = new Properties();

        for (int i = 0; i < tokens.length; i++) {
            String value = getValue(s, tokens[i][0], tokens[i][1]);
            p.setProperty(tokens[i][0], value);
        }
        return p;
    }

    private String getValue(String s, String token, String endToken) {
        int sPos = s.indexOf(token);
        if (sPos >= 0) {
            int ePos = s.indexOf(endToken, sPos + 1);
            if (ePos > sPos) {
                sPos += token.length();
                return s.substring(sPos, ePos);
            }
        }
        return "";
    }


    public static void main(String[] args) {
        String s = "c~ ¹\" M:0013A20040559361 Ax:48 Ay:10 Az:1012 " + 
                "Tp:25 B:45 ? Tm:Wednesday, 02/01/13 - 16:16.57 Sº~";

        StringParsing parsing = new StringParsing();
        Properties p = parsing.parseString(s);

        Set<Object> keys = p.keySet();
        Iterator<Object> iter = keys.iterator();

        while(iter.hasNext()) {
            String key = (String) iter.next();
            String value = p.getProperty(key);
            System.out.println(key + " " + value);
        }
    }

}

已编辑以添加代码以响应评论。

我还没有对此进行测试，因为我没有您的数据文件，但这是加载 map 的方法。重要的是，您必须为每个 Map 条目创建一个新的 Properties 对象，因为映射包含一个指向 Properties 对象的指针。

   public void processStrings() {
        Map<String, Properties> dataMap = new TreeMap<String, Properties>(); 
        StringParsing parsing = new StringParsing();
        try {
            BufferedReader reader = new BufferedReader(new FileReader(
                    "dataFile.txt"));
            String line = "";
            while ((line = reader.readLine()) != null) {
                Properties p = parsing.parseString(line);
                dataMap.put(p.getProperty("M:"), p);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }