Comment séparer des chaînes dans J2ME?

Comment puis-je diviser les chaînes en J2ME de manière efficace?

Il y a un StringTokenizer ou String.split(String regex) dans la standard edition (J2SE), mais ils sont absents dans le micro edition (J2ME, MIDP).

source d'informationauteur Spoike

11

Il y a quelques implémentations de la classe StringTokenizer pour J2ME. Ce Ostermiller sera très probablement inclure les fonctionnalités dont vous avez besoin

Voir aussi cette page sur la Programmation Mobile Pit Stop pour quelques modifications, et l'exemple suivant:
```
String firstToken;
StringTokenizer tok;

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

Il n'est pas construit dans la méthode de fractionnement des chaînes de caractères. Vous avez de l'écrire sur votre propre en utilisant
String.indexOf() et String.substring(). Pas dur.
3

Chaîne.split(...) est disponible dans J2SE, mais pas J2ME.

Vous devez écrire votre propre algorithme: related post avec la solution de l'échantillon.

J'espère que cela va vous aider... C'est ma propre mise en œuvre que j'ai utilisé dans mon application. Bien sûr, cela peut encore être optimisé. je viens juste de ne pas avoir le temps de le faire... et aussi, je suis en train de travailler sur StringBuffer ici. Juste refactoriser cela être capable d'utiliser des chaînes de caractères à la place.

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

2

Qui dépend exactement ce que vous voulez atteindre, mais la fonction de la Chaîne.substring() va être là quelque part:
```
String myString = "Hello World";
```
Cela permettra d'imprimer la sous-chaîne commençant à partir de l'index de 6 à la fin de la chaîne:
```
System.out.println(myString.substring(6));
```
Cela permettra d'imprimer la sous-chaîne commençant à partir de l'index 0 jusqu'à ce que l'indice 5:
```
System.out.println(myString.substring(0,5));
```
Sortie de tout le code ci-dessus:
```
Monde 
Bonjour 
```
Combinez cela avec les autres fonctions de Chaîne (indexOf(). etc.) pour obtenir l'effet désiré!

Re-lecture de votre question, il semble que si vous avez été à la recherche pour String.split(). Cela permettra de diviser votre chaîne d'entrée dans un tableau de chaînes de caractères en fonction d'un regex:
```
String myString = "Hi-There-Gang";
String[] splitStrings = myString.split("-");
```
Cela se traduira dans le splitStrings tableau contenant des trois chaînes, "Hi""There" et "Gang".

Re-lecture de votre question, String.split n'est pas disponible dans J2ME, mais le même effet peut être obtenu avec substring et indexOf.

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
}

Vous pouvez utiliser cette méthode pour diviser un délimiteur.

En J2ME pas de rupture, mais vous pouvez utiliser ce code pour le split.Ce code fonctionne avec seulement 1 simbol délimiteur!!!
L'Utilisation De NetBeans.Fichier\Créer un Projet\ Java ME\ MobileApplication\nom du projet(split)\coche.Supprimer tout le code dans votre (Midlet.java).Copiez ce code et passé dans votre (Midlet.java).

//IDE NetBeans 7.3.1
//author: UserSuperPupsik 
//email: [email protected]
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) {
}
}

Découpé les éléments situés dans le tableau appelé ().Par Exemple[1]:Bonjour.
Bonne Chance!!!

Une autre solution alternative:

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

Vous devez vous connecter pour publier un commentaire.