Split af streng ved hhv. punktum og mellemrum

Du kan eventuelt bruge StringTokenizer

public class SpiltTest {
    public SpiltTest() {
    }

    public static void main(String[] args) {
        String s = "Dette  er rene, .abeka.tt,e stre ger";
       
        StringTokenizer token = new StringTokenizer(s, " ,.");
       
        while(token.hasMoreTokens()){
            System.out.println(token.nextToken());
        }
    }
}

Vil det så også løse problemet med de tomme strenge ved mellemrum? Det er i 2 omgange, jeg gør der, først splitter jeg på komma og punktum, løber arrayet igennem og splitter så på mellemrum.

Ja.

Prøv at køre eksemplet her

public class SpiltTest {
   
    public SpiltTest() {
    }
    public static void main(String[] args) {
        String s = "Dette            er rene, .abeka.tt,e stre ger";
       
        StringTokenizer token = new StringTokenizer(s, " ,.");
       
        String[] result = new String[token.countTokens()];
       
        int i = 0;
        while(token.hasMoreTokens()){
            String t = token.nextToken();
            result[i] = t;
            i++;
            System.out.println(t);
        }
       
        System.out.println("");
        i = 0;
        while(i < result.length){
            System.out.println(result[i]);
            i++;
        }
       
    }
}

He he, ja jeg testede også din forrige kode, og det virkede jo fint :) Jeg vil nu også godt lige for en god ordens skyld høre hvordan man gør det tilsvarende med regulære udtryk, da jeg ikke har så meget styr på dem, og gerne vil lære lidt om dem.

Hmm...det får mig egentlig til at tænke på, hvad er forskellen egentlig mellem at bruge en StringTokenizer, og så regulære udtryk? De ser lidt ens ud for mig.

Der halter jeg, bruger dem så sjældent at jeg ikke har sat mig ordentlig ind det, og kan derfor ikke give dig et dybt seriøst svar på det - sorry.

Det er okay, jeg regnede heller ikke med at du ville gøre det, jeg mente blot at jeg vil lade spørgsmålet stå åben da det egentlig var regulære udtryk, jeg oprindeligt havde i tankerne. Men du skal nok få point, når jeg lige har set om nogle kan hjælpe mig mht. regulære udtryk.

Se metode split() i klassen String:
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html#split(java.lang.String,%20int)

den vil have en regular experession streng som parameter,

String udeltStreng = "  tekst med .  og ,  i  ";
String[] deltStreng = udeltStreng.split( "(\.|,)" ); // opdel på pumktum og komma.

Du kan evt udvide din regular expression så blanktegn foran og bagefter . eller , fjernes:

String[] deltStreng = udeltStreng.split( " *(\.|,) *" ); // opdel på pumktum og komma.

men de allerforreste og allerbarste blanktegn må du selv fjerne med trim metoden. fx

String[] deltStreng = udeltStreng.trim().split( " *(\.|,) *" ); // opdel på pumktum og komma.

læs om regular expressions: http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html#sum (ja jeg ville også foretrække et der var et eksempel eller to, istedet for blot teorien)

mvh JakobA

Her er lidt eksempler: http://www.javaworld.com/javaworld/jw-07-2001/jw-0713-regex.html

og her: http://java.sun.com/docs/books/tutorial/extra/regex/index.html

Det er netop det jeg i forvejen havde kigget på, men uden at få noget brugbart ud af det. Men okay, så langt så godt. Men som jeg skrev, skal jeg først opdele min streng efter punktum og komma. Det streng array jeg så får ud af det, må gerne indeholde mellemrum. Så kører jeg igennem hver streng i arrayet og splitter så på mellemrum.

Så hvis jeg har forstået det rigtige kan jeg splitte på mellemrum ved at bruge split("* *"); eller hvad?

Jeg kan for øvrigt se at jeg da i det mindste selv har været inde på noget af det rigtige, jeg havde split("\.|,"), jeg var blot ikke klar over at det skulle puttes ind i parenteser.

splitte på eet og kun et mellemrum:  split( " " );    //bare et mellemrum i strengen
splitte på eet eller flere mellemrum  split( " +" );  // + betyder 'mindste 1, men gerne flere'

* betyder at der slet ikke behøver at være noget, eller også tegnet foran såmange gange det skal være. nødvendig ovenfor fordi . og , jo ofte står lige efter et ord uden noget imellem.

Hmm, jeg får en fejl, der siger "illegal escape character" pga. \.

så skal der nok stå  \\.  istedet for kun  \.  (det kommer an på hvor tæt fortolkningen af den parameter er på fortolkningen af den regular expression parameteren indeholder)

Hmm, jeg hader de åbenlyse løsninger, der er når man ikke kan se skoven for bare træer :( Hvis I begge vil smide et svar, så er der point, det virker fint nu :)

Svar

med hensyn til forskellen på StringTokenizer og String split

API docs siger:

StringTokenizer is a legacy class that is retained for compatibility reasons although its use is discouraged in new code. It is recommended that anyone seeking this functionality use the split  method of String or the java.util.regex package instead.

The following example illustrates how the String.split method can be used to break up a string into its basic tokens:

    String[] result = "this is a test".split("\\s");
    for (int x=0; x<result.length; x++)
        System.out.println(result[x]);

så SUN's holdning er klar, men inden man nu hopper på vognen så check lige
dette program:

import java.util.StringTokenizer;
import java.util.regex.Pattern;

public class SplitTest2 {
  private final static int N = 1000000;
  public static void main(String[] args) {
      String s = "a\0b\0";
      long t1 = System.currentTimeMillis();
      for(int i = 0; i < N; i++) {
        String[] ss = s.split("\0");
        for(int j = 0; j < ss.length; j++) {
            String sss = ss[j];
            if(!sss.equals("a") && !sss.equals("b")) System.err.println("Oops");
        }
      }
      long t2 = System.currentTimeMillis();
      long t3 = System.currentTimeMillis();
      for(int i = 0; i < N; i++) {
        StringTokenizer st = new StringTokenizer(s, "\0");
        while(st.hasMoreTokens()) {
            String sss = st.nextToken();
            if(!sss.equals("a") && !sss.equals("b")) System.err.println("Oops");
        }
      }
      long t4 = System.currentTimeMillis();
      long t5 = System.currentTimeMillis();
      Pattern p = Pattern.compile("\0");
      for(int i = 0; i < N; i++) {
        String[] ss = p.split(s);
        for(int j = 0; j < ss.length; j++) {
            String sss = ss[j];
            if(!sss.equals("a") && !sss.equals("b")) System.err.println("Oops");
        }
      }
      long t6 = System.currentTimeMillis();
      System.out.println("regex split = " + (t2 - t1) +
                        " string tokenizer = " + (t4 - t3) +
                        " smart regex split = " + (t6 - t5));
  }
}

performance er stadig ikke helt på toppen.

osse svar

Arne, jeg læste også API'en og det var derfor jeg foretrak en regexp løsning. Men det jeg mente er hvad forskellen er i hvordan de finder resultatet. Jeg mener med en StringTokenizer er det åbenbart nok bare at skrive de tegn man vil splitte på, mens man bruger regulære ekspressions i den anden, men er de ikke lige gode? Ja, det er svært at forklare helt hvad jeg mener, jeg håber det er forståeligt.

regexp er en lidt mere generel måde

og med så meget andet der er mere generelt så koster det en lille smule

du kan lave en regexp med præcist samme funktionalitet som ved brug
af StringTokenizer

performance kan du måle med ovenstående program