Java中高效的字符串读取？

我收到一个包裹，如

“c~imk_”M:0013A20040559361 Ax:48 Ay:10 Az:1012 Tp:25 B:45？Tm:2013年2月1日星期三-16:16.57秒~“

和其他无法粘贴的字符。我必须读取冒号后的值。例如，

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:
              }
        }

---

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

定义要分析的标记和结束标记

这是我的结果

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

}

import java.util.Iterator；
导入java.util.Properties；
导入java.util.Set；
公共类字符串解析{
私有字符串[][]令牌={{{“Ax:”，“}，
{“Ay:，”}，{“Az:，”}，{“Tp:，”}，{“B:，”}，
{“Tm:，“Sº”}；
公共属性解析字符串（字符串s）{
属性p=新属性（）；
for（int i=0；i=0）{
int ePos=s.indexOf（endToken，sPos+1）；
如果（ePos>sPos）{
sPos+=token.length（）；
返回s.substring（sPos、ePos）；
}
}
返回“”；
}
公共静态void main（字符串[]args）{
字符串s=“c~ª\”M:0013A20040559361 Ax:48 Ay:10 Az:1012”+
“Tp:25B:45？Tm:2013年1月2日星期三-16:16.57秒~”；
StringParsing=新建StringParsing（）；
Properties p=parsing.parseString；
设置键=p.键集（）；
迭代器iter=keys.Iterator（）；
while（iter.hasNext（））{
字符串键=（字符串）iter.next（）；
字符串值=p.getProperty（键）；
System.out.println（键+“”+值）；
}
}
}

编辑以添加代码以响应注释

我没有测试过这个，因为我没有您的数据文件，但下面是如何加载地图的。重要的是，您必须为每个映射条目创建一个新的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();
        }
    }

public void processStrings（）{
Map dataMap=newtreemap（）；
StringParsing=新建StringParsing（）；
试一试{
BufferedReader reader=新BufferedReader（新文件读取器(
“dataFile.txt”）；
字符串行=”；
而（（line=reader.readLine（））！=null）{
Properties p=parsing.parseString（第行）；
put（p.getProperty（“M:”），p）；
}
reader.close（）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}

您不能将正则表达式与两个组一起使用吗？一个组返回betfore'：'值，另一个组返回值？什么是“字符串垃圾收集器”？您确定字符编码没有问题吗？您会遇到什么类型的“错误”？您确定数据是字符串，而不是字节流吗？错误是不正确的值，有时是异常。嗯，我通过字节读取它，但我必须以字符串形式显示它，因为这是从另一个设备接收的。谢谢。这比我以前做的更有效率。我现在面临一个问题。我现在正在读取不同的设备，它们有不同的M:（MACs）值，然后我用一个键将每个MAC存储在HashMap中，然后用HashMap中相应的键将这些数据发送到图形、拨号盘等。问题在于数据混合，比如数据上附加了错误的键。有什么建议吗？我该怎么过来？谢谢您还可以看到代码稍后生成Ax，但它出现在字符串中。@user1109443:Properties实例中的属性不保证以任何顺序出现。通过传递键来请求属性值。至于你的另一个问题，HashMap应该可以工作。@user1109443:我认为树映射更好，因为它可以按M值排序。查看更新的答案。