String zerlegen

[Börmt-die-Buse]

Hallo
ich möchte ein bisschen Java üben und habe mir folgende Übungsaufgabe rausgesucht.

Gegeben ist ein String mit Wörtern, die durch ein oder mehrere Leerzeichen
voneinander getrennt sind (Wort = beliebige Zeichenfolge ohne Leerzeichen). Geben
Sie eine Java-Methode woerterListe an, die aus einem solchen, als Parameter
woerter übergebenen String die einzelnen Wörter extrahiert und alle diese Wörter als
Liste zurückliefert:
LinkedList<String> woerterListe(String woerter) { ... }

mein problem ist nun das der int anfang, fest sitzt zwischen "Hallo" und "du".
ich weiß wirklich nicht, wie ich auf das nächste wort komm um es zu separieren.

gibt es vllt. auch eine elegantere Lösung, als so wie ich es probiere?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package Test;
import java.util.*;
 
class Test2 {
 
    public LinkedList<String> woerterListe(String woerter){
        LinkedList<String> liste1 = new LinkedList<String>();
        String hilf = " ";
        int anfang = 0;
       // int ende = 0;
        woerter = woerter.trim();
        woerter = woerter + hilf;
        while(woerter.length() > anfang){
          //  ende = woerter.indexOf("");
            hilf= woerter.substring(anfang,woerter.indexOf(" "));
            anfang = woerter.indexOf(" ");       // index von "" reinspeichern
            liste1.add(hilf);
        }
        
        return liste1;
    }
    
    public static void main(String[] args){
        Test2 run = new Test2();
        String woerter = "    Hallo du, du hast alles richtig gemacht!    ";
        LinkedList<String> liste = run.woerterListe(woerter);
        System.out.println(liste);
    }
}

[HimBromBeere]

Ich glaub, du musst den Angang auf Index(Leerzeichen) + 1 setzen.

[EikeB]

Musst du das so "manuell" machen? Die Klasse String kennt ne Methode split() mit der du das wunderbar lösen könntest.

[Cola_Colin]

1
2
3
public LinkedList<String> woerterListe(String woerter){
  return new LinkedList<String>(Arrays.asList(woerter.split(" ")));
}

[EikeB]

Wenn schon vorsagen dann aber auch richtig

Zitat: Börmt-die-Buse

	[...] Wörtern, die durch ein oder mehrere Leerzeichen voneinander getrennt sind [...]

[Börmt-die-Buse]

mit Index(Leerzeichen) + 1 hab ich mir auch schon gedacht, dann bekomm ich aber eine
(java.lang.StringIndexOutOfBoundsException: String index out of range: -1) Exception.

wenn ich split() benutzt muss ich den string woerter zu String[] woerter setzen, weil die einzelnen Worter ja dann in Arrays gespeichert werden. Aber der Kopf der methode ist vorgegeben.
Kann es sein das split(" ") gar nicht funktionieren würde, weil es eine Reguläre Expression sein müsste?

[iKnwWhtUDidLast]

String.split arbeitet mit Pattern und Matcher, du kannst dir das ja mal bei grepcode.com anschauen: GrepCode: java.util.regex.Pattern (.java) - Class - Source Code View

[Cola_Colin]

Hmm ja, wenn die ganzen Leerstrings stören, dann muss man es noch anpassen, hast recht:

1
2
3
4
5
6
7
8
    public static void main(String[] args) {
        String test = "hallo welt    viele leeerzeichen   test";
        System.out.println(woerterListe(test));
    }
    
    public static LinkedList<String> woerterListe(String woerter){
          return new LinkedList<String>(Arrays.asList(woerter.split(" +"))); //trenne bei einem oder mehreren leerzeichen
    }

[Börmt-die-Buse]

Zitat: Cola_Colin

	1 2 3 public LinkedList<String> woerterListe(String woerter){   return new LinkedList<String>(Arrays.asList(woerter.split(" "))); }

dieser Code funktioniert, mit einem kleinen

1
woerter = woerter.trim()

noch davor.

würde trotzdem noch gerne wissen, was ich bei meinem Code ändern müsste damit es funktioniert.

[iKnwWhtUDidLast]

Zitat: Börmt-die-Buse

	dieser Code funktioniert, mit einem kleinen 1 woerter = woerter.trim() noch davor.

trim trennt nur voran- oder nachgestellte Leerzeichen ab!

[Börmt-die-Buse]

Zitat: hüteüberhüte

	trim trennt nur voran- oder nachgestellte Leerzeichen ab!

ich weiß

[Cola_Colin]

Für deinen originalen Code schaue dir mal diese Version von indexOf an:
String (Java Platform SE 6)

[mla.rue]

du solltest wirklich mit split arbeiten

zu deinem Problem: anfang = woerter.indexOf(" ") sucht immer und immer wieder bei jedem Durchang der Schleife nach dem ersten vorkommenden Leerzeichen, und das steckt wohl zwischen "Hallo" und "du". Solltest also "woerter" nach dem Zuweisen von "hilf" entsprechend anpassen ...

[iKnwWhtUDidLast]

Zitat: Börmt-die-Buse

	Gegeben ist ein String mit Wörtern, die durch ein oder mehrere Leerzeichen voneinander getrennt sind (Wort = beliebige Zeichenfolge ohne Leerzeichen). Geben Sie eine Java-Methode woerterListe an, die aus einem solchen, als Parameter woerter übergebenen String die einzelnen Wörter extrahiert und alle diese Wörter als Liste zurückliefert: LinkedList<String> woerterListe(String woerter) { ... }

Hätte das jetzt so implementiert, ohne irgendwelche Hilfsmethoden:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
22
23
24
    public static LinkedList<String> woerterListe(String woerter) {
        LinkedList<String> result = new LinkedList<String>();
        
        int i = 0;
        while (i < woerter.length()) {
        while (i < woerter.length() && woerter.charAt(i) == ' ') {
            i++;
        }
        int j = i;
        while (i < woerter.length() && woerter.charAt(i) != ' ') {
            i++;
        }
        if (i != j) {
            result.add(woerter.substring(j, i));
        }
        }
        
        return result;
    }
 
    public static void main(String[] args) {
        System.out.println(woerterListe("bla   blaa blaaa  a    "));
    }

Jetzt noch kurz zur Erklärung Kommentare:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
        LinkedList<String> result = new LinkedList<String>();
        
        int i = 0;
        // i = aktuell untersuchtes Zeichen
        while (i < woerter.length()) {
        while (i < woerter.length() && woerter.charAt(i) == ' ') {
            // übergehe alle Leerzeichen
            i++;
        }
        int j = i;
        // j = Position des ersten Nicht-Leerzeichens
        while (i < woerter.length() && woerter.charAt(i) != ' ') {
            i++;
            // übergehe alle Nicht-Leerzeichen
        }
        // i = Position des ersten Leerzeichens
        if (i != j) {
            result.add(woerter.substring(j, i));
        }
        }
        
        return result;

Also drei while-Schleifen. Klar würde das auf mit for-Schleifen funktionieren:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    public static LinkedList<String> woerterListe(String woerter) {
        LinkedList<String> result = new LinkedList<String>();
        
        for (int i = 0; i < woerter.length();) {
        for (; i < woerter.length() && woerter.charAt(i) == ' '; i++)
            ;
        int j = i;
        for (; i < woerter.length() && woerter.charAt(i) != ' '; i++)
            ;
        if (i != j) {
            result.add(woerter.substring(j, i));
        }
        }
        
        return result;
    }

Aber das ist mehr oder weniger Geschmackssache. Die einen bevorzugen das, die anderen das..

Grüße!

[iKnwWhtUDidLast]

Achja, ohne .substring müsstest du dir ein char[] erstellen, in das dann die einzelnen Zeichen kopiert werden. Aber denke mal, des ist auch klar

[x22]

@hüte und TO

in etwa so:

1
2
3
                    char[] x= a.toCharArray();
                    a= String.valueOf(x[0]);
                    eins= Integer.parseInt(a)

[iKnwWhtUDidLast]

...das wäre ja nur ein Zeichen/Integer...:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    public static LinkedList<String> woerterListe(String woerter) {
        LinkedList<String> result = new LinkedList<String>();
 
        int i = 0;
        while (i < woerter.length()) {
            while (i < woerter.length() && woerter.charAt(i) == ' ') {
                i++;
            }
            int j = i;
            while (i < woerter.length() && woerter.charAt(i) != ' ') {
                i++;
            }
            if (i != j) {
                // result.add(woerter.substring(j, i));
                char[] ca = new char[i - j];
                for (int k = 0; j < i; k++, j++) {
                    ca[k] = woerter.charAt(j);
                }
                result.add(new String(ca));
            }
        }
 
        return result;
    }

Oder:

1
2
3
4
5
6
7
                // result.add(woerter.substring(j, i));
                int len = i - j;
                char[] ca = new char[len];
                for (int k = 0; k < len; k++) {
                    ca[k] = woerter.charAt(j + k);
                }
                result.add(new String(ca));

Freilich, ganz ohne zumindest den String-Konstruktor und .charAt geht es nicht...

[iKnwWhtUDidLast]

ok, hab mal nachgesehen, was bei .substring passiert:

GrepCode: java.lang.String (.java) - Class - Source Code View

http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/String.java#String.%3Cinit%3E%28int%2Cint%2Cchar[]%29

Es wird ein package private constructor aufgerufen, der mit demselben char[] (Referenz wird kopiert) ein neues String-Objekt erstellt/instantiiert. Das geht ja, weil sich das char[] nicht ändern darf.
Es werden also keine Zeichen kopiert. Damit sollte .substring schneller sein, als ein neues char[] zu erstellen

[ssoul26]

Noch eine Lösung wäre:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
   /**
    * Liefert die einzelnen Wörter aus einem String (BETA).
    * @param woerter
    * @return
    */
   public static LinkedList<String> woerterListe(String woerter) {
      LinkedList<String> liste1 = new LinkedList<String>();
      String wort = "";
      for (char c : woerter.toCharArray()) {
         if (c == 32) {
            if (wort.length() != 0) {
               liste1.add(wort);
               wort = "";
            }
         } else {
            wort += c;
         }
      }
      if (wort.length() != 0) {
         liste1.add(wort);
      }
      return liste1;
   }

[iKnwWhtUDidLast]

Eyi, des arbeitet mit StringKonkatenation , evil