Pytanie Jak podzielić ciągi znaków w J2ME?


Jak w efektywny sposób podzielić łańcuchy w J2ME?

Tam jest StringTokenizer lub String.split(String regex) w wersji standardowej (J2SE), ale nie ma ich w wersji mikro (J2ME, MIDP).


14
2017-10-14 11:12


pochodzenie


Trochę uwagi, nie pomaga J2ME, ale może pomóc innym w przyszłości ... Niestety, StringTokenizer został wycofany w J2SE. Sugerowana zamiana polega na użyciu metody dzielenia ciągu. Raczej niefortunny, StringTokenizer stworzony dla jakiegoś fajnego kodu. Zmiana tego po prostu przy użyciu metody podziału na łańcuch powoduje, że kod jest bardziej spójny. Wydaje się, że jest to metoda Java, ale należy odrzucić dobre funkcje i powiedzieć ludziom, aby zamiast tego używali zamiast nich niezgrabnych. - Brian Knoblauch


Odpowiedzi:


Istnieje kilka implementacji klasy StringTokenizer dla J2ME. Ten przez Ostermiller najprawdopodobniej będzie zawierał potrzebną funkcjonalność

Zobacz też tę stronę na Mobile Programming Pit Stop w przypadku niektórych modyfikacji i następującego przykładu:

String firstToken;
StringTokenizer tok;

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

11
2017-10-14 11:57



Dzięki, to było dokładnie to, czego potrzebowałem. - Spoike
martwy link do biblioteki. Czy możesz zapewnić działający? - Nitesh Verma


Nie ma wbudowanej metody dzielenia łańcuchów. Musisz napisać to na własny użytek String.indexOf() i String.substring(). Nietrudny.


3
2017-10-14 11:16



Tak, ale czy będzie to efektywna pamięć? StringSubstring () utworzy nowe ciągi, które będą przenosić pamięć, dopóki nie zostaną zebrane śmieci. - Spoike
StringTokenizer.nextToken () zawiera "return string.subString (...)" wewnętrznie, więc nie wydaje mi się, że jesteś w gorszej sytuacji ... - Cowan
Substring używa prywatnego konstruktu dla String, który ma wspólną (niezmienną) tablicę znaków, więc tak - będzie to pamięć wydajna. - ddimitrov


String.split (...) jest dostępny w J2SE, ale nie J2ME.
Musisz napisać własny algorytm: powiązany wpis z przykładowym rozwiązaniem.


3
2017-10-14 11:51



link obecnie nie działa - Abdull


Mam nadzieję, że to ci pomoże ... To jest moja własna implementacja, której użyłem w mojej aplikacji. Oczywiście można to jeszcze zoptymalizować. Po prostu nie mam na to czasu ... i pracuję tutaj nad StringBuffer. Po prostu zmień to, aby móc używać 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;
}

3
2017-07-27 12:42



btw, oto jak możesz użyć kodu ... String [] elements = split (nowy StringBuffer ("Hello | World"), "|"); lub String [] elements = split (nowy StringBuffer ("HelloblahWorld"), "bla"); oba zwraca {"Hello", "World"} - demotics2002


To zależy od tego, co dokładnie chcesz osiągnąć, ale funkcja String.substring () będzie gdzieś tam:

String myString = "Hello World";

Spowoduje to wydrukowanie podciągu rozpoczynającego się od indeksu 6 na końcu ciągu znaków:

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

Spowoduje to wydrukowanie podciągu zaczynającego się od indeksu 0 do indeksu 5:

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

Wyjście całego kodu powyżej:

Świat
cześć

Połącz to z innymi funkcjami String (indexOf(). itp.), aby osiągnąć pożądany efekt!

Ponowne przeczytanie pytania wygląda tak, jakbyś tego szukał String.split(). Spowoduje to podzielenie łańcucha wejściowego na tablicę łańcuchów na podstawie danego wyrażenia regularnego:

String myString = "Hi-There-Gang";

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

Spowoduje to utworzenie w tablicy splitStrings trzech ciągów znaków, "Hi", "There" i "Gang".

Ponownie przeczytaj pytanie, String.split nie jest dostępny w J2ME, ale ten sam efekt można osiągnąć za pomocą substring i indexOf.


2
2017-10-14 11:35





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
     }

Możesz użyć tej metody do podziału ogranicznika.


1
2017-09-25 08:47





W J2ME nie ma podziału, ale możesz użyć tego kodu do podziału. Ten kod działa tylko z 1 ogranicznikiem simbol !!! Użyj NetBeans.File \ Create Project \ Java ME \ MobileApplication \ Ustaw nazwę projektu (split) \ Ustaw znacznik wyboru.Wybierz cały kod z (Midlet.java). Skopiuj ten kod i przeszłość w swoim (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) {
    }




}

Podział elementów znajdujących się w tablicy nazywa się (out) .Do przykładu out [1]: Hello. Powodzenia!!!


1
2017-09-29 17:10





Inne alternatywne rozwiązanie:

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

0
2017-08-19 10:58