【问题标题】:How do I split strings in J2ME?如何在 J2ME 中拆分字符串?
【发布时间】:2010-09-17 01:50:12
【问题描述】:

如何在 J2ME 中有效地拆分字符串?

在标准版(J2SE)中有StringTokenizerString.split(String regex),但在微型版(J2ME、MIDP)中没有。

【问题讨论】:

  • 附注一点,对 J2ME 没有帮助,但将来可能会帮助其他人......不幸的是,StringTokenizer 在 J2SE 中已被弃用。建议的替换是只使用字符串拆分方法。不幸的是,StringTokenizer 编写了一些漂亮的代码。将其更改为仅使用 String 拆分方法会导致代码更笨拙。不过,这似乎是 Java 的方式,弃用了好的功能并告诉人们只使用笨重的功能。

标签: java algorithm string java-me


【解决方案1】:

有一些 J2ME 的 StringTokenizer 类的实现。 Ostermiller 的这个很可能包含您需要的功能

另请参阅this page on Mobile Programming Pit Stop 了解一些修改和以下示例:

String firstToken;
StringTokenizer tok;

tok = new StringTokenizer("some|random|data","|");
firstToken= tok.nextToken();

【讨论】:

    【解决方案2】:

    另一种替代解决方案:

     public static Vector split(String stringToSplit, String separator){
         if(stringToSplit.length<1){
             return null;
         }
    
         Vector stringsFound = new Vector();
    
         String remainingString = stringToSplit;
    
         while(remainingString.length()>0){
             int separatorStartingIndex = remainingString.indexOf(separator);
    
             if(separatorStartingIndex==-1){
                 // Not separators found in the remaining String. Get substring and finish
                 stringsFound.addElement(remainingString);
                 break;
             }
    
             else{
                 // The separator is at the beginning of the String,
                 // Push the beginning at the end of separator and continue
                 if(remainingString.startsWith(separator)){
                     remainingString = remainingString.substring(separator.length());
                 }
                 // The separator is present and is not the beginning, add substring and continue
                 else{
                     stringsFound.addElement(remainingString.substring(0, separatorStartingIndex));
                     remainingString = remainingString.substring(separatorStartingIndex + separator.length());
                 }
             }
         }
    
         return stringsFound;
     }
    

    【讨论】:

      【解决方案3】:

      在 J2ME 中没有拆分,但您可以使用此代码进行拆分。此代码仅使用 1 个 simbol 分隔符!!! 使用 NetBeans.File\Create Project\Java ME\MobileApplication\Set project name(split)\Set checkmark.Delete all code in your (Midlet.java).Copy this code and past in your (Midlet.java).

      //IDE NetBeans 7.3.1
      //author: UserSuperPupsik 
      //email: usersuperpupsik@gmail.com
      
      
      
      package split;
      
      
      import javax.microedition.lcdui.*;
      import javax.microedition.midlet.*;
      import java.util.Vector;
      
      public class Midlet extends MIDlet {
       public String e1;
          public Vector v=new Vector();
       public int ma;
       int IsD=0;
       int vax=0;
       public String out[];
       private Form f;
      
       public void split0(String text,String delimiter){
                                  if (text!=""){
                                  IsD=0;
      
                                  int raz=0;
      
                                  //v.removeAllElements();
                                  v.setSize(0);
                                  int io;
                                  String temp=""; 
                                   int ni=(text.length()-1);
      
      
                                   for(io=0;io<=ni;io++){
      
                                          char ch=text.charAt(io);
                                          String st=""+ch;                                    
                                          if(io==0 && st.equals(delimiter)){IsD=1;}
      
                                          if(!st.equals(delimiter)){temp=temp+st;} //Not equals (!=)
                                          else if(st.equals(delimiter)&&temp!="")//equals (==)
                                                                      {
                                          IsD=1;
                                          //f.append(temp);   
                                          v.addElement(temp);
                                          temp="";                   
      
                                                                       }
      
      
                                           if(io==ni && temp!="") {
                                                    v.addElement(temp);
                                                    temp="";  
                                                    }           
      
                                           if((io==ni)&&IsD==0&&temp!=""){v.addElement(temp);}
      
      
      
      
                                                  }
      
      
      
                                             if(v.size()!=0){
      
                                             ma=(v.size());
      
                                             out=new String[ma];
      
      
                                             v.copyInto(out);
      
                                             }
                                             //else if(v.size()==0){IsD=1; }
      
      
                                  }
                                       }
      
      
      public void method1(){
          f.append("\n");
          f.append("IsD: " +IsD+"");
          if (v.size()!=0){
          for( vax=0;vax<=ma-1;vax++){
                                      f.append("\n");
      
                                      f.append(out[vax]);
      
      
                                          }
                                }  
      }
          public void startApp() {
      
          f=new Form("Hello J2ME!");
          Display.getDisplay(this).setCurrent(f);
      
          f.append("");
          split0("Hello.World.Good...Luck.end" , ".");
          method1();
      
          split0(".",".");
          method1();
      
          split0("   First WORD2 Word3 "," ");
          method1();
      
          split0("...",".");
          method1();            
                                                      }
      
          public void pauseApp() {
          }
      
          public void destroyApp(boolean unconditional) {
          }
      
      
      
      
      }
      

      位于名为 (out) 的数组中的拆分元素。例如 out[1]:Hello。 祝你好运!!!

      【讨论】:

        【解决方案4】:
        public static Vector splitDelimiter(String text, char delimiter) {
            Vector splittedString = null;
            String text1 = "";
        
            if (text != null) {
                splittedString = new Vector();
                for (int i = 0; i < text.length(); i++) {
                    if (text.charAt(i) == delimiter) {
                        splittedString.addElement(text1);
                        text1 = "";
                    } else {
                        text1 += text.charAt(i);
                        // if(i==text.length()-1){
                        // splittedString.addElement(text1);
                        // }
                    }
                }
                splittedString.addElement(text1);
            }
            return s
             }
        

        您可以使用此方法来分割分隔符。

        【讨论】:

          【解决方案5】:

          这取决于你到底想达到什么,但函数 String.substring() 会在某个地方:

          String myString = "Hello World";
          

          这将打印从索引 6 开始到字符串末尾的子字符串:

          System.out.println(myString.substring(6));
          

          这将打印从索引 0 到索引 5 的子字符串:

          System.out.println(myString.substring(0,5));
          

          以上所有代码的输出:

          世界 你好

          将此与其他字符串函数(indexOf(). 等)结合起来,以达到预期的效果!

          重新阅读您的问题,您似乎一直在寻找String.split()。这将根据给定的正则表达式将您的输入字符串拆分为字符串数组:

          String myString = "Hi-There-Gang";
          
          String[] splitStrings = myString.split("-");
          

          这将导致 splitStrings 数组包含三个字符串,"Hi""There""Gang"

          再次阅读您的问题,String.split 在 J2ME 中不可用,但使用 substringindexOf 可以达到相同的效果。

          【讨论】:

            【解决方案6】:

            我希望这个对您有所帮助...这是我在我的应用程序中使用的我自己的实现。当然,这仍然可以优化。我只是没有时间去做......而且,我正在这里处理 StringBuffer 。只需将其重构为能够使用 String 代替。

            public static String[] split(StringBuffer sb, String splitter){
                String[] strs = new String[sb.length()];
                int splitterLength = splitter.length();
                int initialIndex = 0;
                int indexOfSplitter = indexOf(sb, splitter, initialIndex);
                int count = 0;
                if(-1==indexOfSplitter) return new String[]{sb.toString()};
                while(-1!=indexOfSplitter){
                    char[] chars = new char[indexOfSplitter-initialIndex];
                    sb.getChars(initialIndex, indexOfSplitter, chars, 0);
                    initialIndex = indexOfSplitter+splitterLength;
                    indexOfSplitter = indexOf(sb, splitter, indexOfSplitter+1);
                    strs[count] = new String(chars);
                    count++;
                }
                // get the remaining chars.
                if(initialIndex+splitterLength<=sb.length()){
                    char[] chars = new char[sb.length()-initialIndex];
                    sb.getChars(initialIndex, sb.length(), chars, 0);
                    strs[count] = new String(chars);
                    count++;
                }
                String[] result = new String[count];
                for(int i = 0; i<count; i++){
                    result[i] = strs[i];
                }
                return result;
            }
            
            public static int indexOf(StringBuffer sb, String str, int start){
                int index = -1;
                if((start>=sb.length() || start<-1) || str.length()<=0) return index;
                char[] tofind = str.toCharArray();
                outer: for(;start<sb.length(); start++){
                    char c = sb.charAt(start);
                    if(c==tofind[0]){
                        if(1==tofind.length) return start;
                        inner: for(int i = 1; i<tofind.length;i++){ // start on the 2nd character
                            char find = tofind[i];
                            int currentSourceIndex = start+i;
                            if(currentSourceIndex<sb.length()){
                                char source = sb.charAt(start+i);
                                if(find==source){
                                    if(i==tofind.length-1){
                                        return start;
                                    }
                                    continue inner;
                                } else {
                                    start++;
                                    continue outer;
                                }
                            } else {
                                return -1;
                            }
            
                        }
                    }
                }
                return index;
            }
            

            【讨论】:

            • 顺便说一句,这里是你如何使用代码... String[] elements = split(new StringBuffer("Hello|World"), "|");或 String[] elements = split(new StringBuffer("HelloblahWorld"), "blah");都返回 {"Hello", "World"}
            【解决方案7】:

            String.split(...) 在 J2SE 中可用,但在 J2ME 中不可用。
            您需要编写自己的算法:related post with sample solution

            【讨论】:

              【解决方案8】:

              没有内置的方法来分割字符串。您必须使用自己编写 String.indexOf()String.substring()。不难。

              【讨论】:

              • 是的,但它会有效记忆吗? String.substring() 将创建新的字符串,这将占用内存直到垃圾收集。
              • StringTokenizer.nextToken() 在内部包含“return string.subString(...)”,所以我认为你的情况不会更糟...
              • Substring 使用 String 的私有构造,它共享(不可变的)char 数组,所以是的 - 它会节省内存。
              猜你喜欢
              • 1970-01-01
              • 1970-01-01
              • 1970-01-01
              • 2011-06-26
              • 2017-06-06
              • 2014-12-25
              • 2013-10-30
              • 2011-03-29
              • 2011-12-05
              相关资源
              最近更新 更多