Arrayelemente in verschiedenen Variationen zurückgeben

[sisko78]

Hallo,

ich wußte beim besten Willen nicht, wie ich mein Problem im Titel beschreiben sollte. Ich hoffe, dass triffts einigermaßen.

Habe einen Array oder einen Vector von String-Elementen, also z.b.
[The, Boston, teaparty] (kann aber auch mehr als 3 Elemente enthalten)

und möchte jetzt alle Kombinationen von Groß und Kleingeschrieben kombinieren und ebenfalls als Array oder Vector zurückgegeben haben,
also in diesem Fall 8 Stück:
[the boston teaparty, The boston teaparty, the Boston teaparty,...usw]

Groß- und Kleinschreibweise ist mit den Methoden toUpperCase und toLowerCase und substring ja kein Problem (da hätte ich 2 Methoden dafür)
Jemand eine Idee, wie man diesen Array erhalten könnte? Stehe hier irgendwie auf dem Schlauch.

 

[mic_checker]

und möchte jetzt alle Kombinationen von Groß und Kleingeschrieben kombinieren und ebenfalls als Array oder Vector zurückgegeben haben,

Meinst du damit nur jeweils die Anfangsbuchstaben der Wörter oder die kompletten Wörter ?

Beispiel:
the boSton TeaParty

Willst du auch sowas?

 

[sisko78]

Nur die Anfangsbuchstaben. Hier mal einer meiner abenteuerlichen Versuche. Funktioniert nicht.

private Vector getPossibleSearchWords(String[] tokenArray) {
    this.tokenArray = tokenArray;
    int k = 1;
    recursive(k);
    return queryVector;
  }

private void recursive(int k) {

    for (int j = 0; j < 2; j++) {
      switch (j) {
        case 0: //uppercase
          while (k < tokenArray.length) {
            queryTempVector.add(firstLetterToUpperCase(tokenArray[k]));
            k++;
            recursive(k);
          }
          StringBuffer queryBuffer = new StringBuffer();
          for (int y = 0; y < queryTempVector.size(); y++) {
            queryBuffer.append(queryTempVector.get(y).toString());
          }
          //System.out.println(queryBuffer.toString());
          queryVector.add(queryBuffer.toString());
          queryTempVector.remove(queryTempVector.lastElement());
          k--;

        case 1: //lowercase
          while (k < tokenArray.length) {
            queryTempVector.add(firstLetterToLowerCase(tokenArray[k]));
            k++;
            recursive(k);
          }
          StringBuffer queryBuffer2 = new StringBuffer();
          for (int y = 0; y < queryTempVector.size(); y++) {
            queryBuffer2.append(queryTempVector.get(y).toString());
          }
          //System.out.println(queryBuffer2.toString());
          queryVector.add(queryBuffer2.toString());

          queryTempVector.remove(queryTempVector.lastElement());
          k--;
      }
    }
  }

private String firstLetterToUpperCase(String word) {
    String firstLetter = word.substring(0, 1).toUpperCase();
    String lastLetters = word.substring(1);
    searchWord = firstLetter + lastLetters;
    return searchWord;
  }

  private String firstLetterToLowerCase(String word) {
    String firstLetter = word.substring(0, 1).toLowerCase();
    String lastLetters = word.substring(1);
    searchWord = firstLetter + lastLetters;
    return searchWord;
  }

Das muss doch irgendwie einfacher gehen

 

[Wildcard]

Die Frage ist was du am Ende damit machen willst...
Kann mir nicht vorstellen für was man diese Variationen tatsächlich 'erzeugen' muss.
Erklär mal was du vorhast, dann lass ich mich entweder eines Besseren belehren, oder wir finden eine sinnvollere Methode. :wink:

 

[sisko78]

Ok, also ich bin dabei in eine Knowledge Base einfachste Abfragen der Wikipedia Datenbank einzufügen.

Hierzu benutze ich ein auf der Wikipedia Homepage herunterladbares SQL Dump File für MySQL, welches ich per JDBC abfrage. Für einfache Abfragen mit einem Wort funktioniert das auch.
Einträge, die mehrere Wörter umfassen, stehen in der Spalte "Title" der Datenbank wie folgt drin: (Groß)restwort1_(Groß|Klein)restwort2_(Groß|klein)restwort3_... usw.
Wenn ich z.b. nach Culture of Europe anfrage, dann müsste die SELECT Anfrage nach
"Culture_of_Europe" suchen, jedoch soll der Nutzer auch bei der Anfrage "culture of europe" das gewünschte Ergebniss erhalten. Das erste Wort ist immer Groß geschrieben, aber bei den restlichen scheint das recht willkürlich zu sein, deshalb habe ich den Suchstring per Tokenizer zerlegt und will dann alle Möglichkeiten (nur ab Wort2) kombinieren, um die Datenbank damit abfragen. Vielleicht lässt sich das ja etwas anders anpacken?

 

[sisko78]

Habs jetzt anders gemacht, mit einem mehrdimensionalen Array und ohne Rekursion:
also praktisch so:
[The, the]
[Boston,boston]
[Teaparty,teaparty]

String[][] array=new String[tokenArray.length][2];
      for(int i =1;i<tokenArray.length;i++){
        for (int j=0;j<2;j++){
          switch (j){
            case 0:
              array[i-1][0] = firstLetterToUpperCase(tokenArray[i]);
            case 1:
              array[i-1][1] = firstLetterToLowerCase(tokenArray[i]);
           }
        }
      }

nur wie kann man dann die gewünschten Worte aus dem Multidimensionalen Array zusammensetzen?

 

[sisko78]

ich nerve bestimmt schon, vielleicht hat jemand von euch zufällig die Zeit, sich folgendes Progrämmchen mal anzuschauen. Ich verstehe hier nicht, warum das nicht richtig funktioniert. Die erste Ausgabezeile ist noch korrekt, aber dann sollte er das zweite Wort entfernen und erst mal die vorherige for-Schleife zuende abarbeiten und dann eben das zweite Wort (kleingeschrieben) hinzunehmen. Macht er aber nicht ???:L

import java.util.ArrayList;
import java.util.StringTokenizer;


public class Test {
  String[] tokenArray; //searchWord arguments
  //array[][] looks like this:
  //(First word ist left out)
  //[You,you]
  //[Go,go]
  //
  
  String[][] array;    
  ArrayList queryTempArrayList = new ArrayList();
  ArrayList queryArrayList = new ArrayList();
  String searchWord;
  
  public Test(String searchWord) {
  this.searchWord=searchWord;
  StringTokenizer searchWordTokenizer = new StringTokenizer(searchWord);
  int ct = searchWordTokenizer.countTokens();
  tokenArray = new String[ct];
  for (int i = 0; i < ct; i++) {
        tokenArray[i] = searchWordTokenizer.nextToken();
      }
      this.tokenArray=tokenArray;
      array=new String[tokenArray.length][2]; 
      for(int i =1;i<tokenArray.length;i++){  //fill array of dimension: 2*number of searchwords
        for (int j=0;j<2;j++){
          switch (j){
            case 0:
              array[i-1][0] = firstLetterToUpperCase(tokenArray[i]);
            case 1:
              array[i-1][1] = firstLetterToLowerCase(tokenArray[i]);
           }
        }
      }  
  ArrayList possibleSearchWords = getPossibleSearchWords(array);
  }

  private ArrayList getPossibleSearchWords(String[][] array) {
      this.array = array;
      int k = 1; 
      tryRecursion(k);
      return queryArrayList;
    }
  
    private void tryRecursion(int k) {  
      for (int i=0; i < 2; i++) {  
        if (k < tokenArray.length) {
          queryTempArrayList.add(array[k-1][i]);          
          k++;
          tryRecursion(k);
        } }
        StringBuffer queryBuffer = new StringBuffer();
        for (int y = 0; y < queryTempArrayList.size(); y++) {
          queryBuffer.append(queryTempArrayList.get(y).toString() + " ");
        }
        System.out.println(queryBuffer.toString());         
        queryArrayList.add(queryBuffer.toString());
        if (!queryTempArrayList.isEmpty()){
        queryTempArrayList.remove(queryTempArrayList.size()-1);}  
  }

  private String firstLetterToUpperCase(String word) {
    String firstLetter = word.substring(0, 1).toUpperCase();
    String lastLetters = word.substring(1);
    searchWord = firstLetter + lastLetters;
    return searchWord;
  }

  private String firstLetterToLowerCase(String word) {
    String firstLetter = word.substring(0, 1).toLowerCase();
    String lastLetters = word.substring(1);
    searchWord = firstLetter + lastLetters;
    return searchWord;
  }

  public static void main(String[] args) {
    Test test = new Test("hello you go");
  }
}

 

[Snape]

  for (int i = 0; i < ct; i++) {
        tokenArray[i] = searchWordTokenizer.nextToken();
      }
      this.tokenArray=tokenArray;
      array=new String[tokenArray.length][2]; 
      for(int i =1;i<tokenArray.length;i++){  //fill array of dimension: 2*number of searchwords
        for (int j=0;j<2;j++){
          switch (j){
            case 0:
              array[i-1][0] = firstLetterToUpperCase(tokenArray[i]);
            case 1:
              array[i-1][1] = firstLetterToLowerCase(tokenArray[i]);
           }
        }
      }  
  ArrayList possibleSearchWords = getPossibleSearchWords(array);
  }

Du überschreibst Dir jedes mal in der inneren Schleife array[0][0] und array[1][0]. Das ist sicher nicht gewollt und auch nicht richtig.
Im Code unten bekommst Du schon mal die drei Worte in allen Variationen, zusammenfrickeln musst Du sie dann selbst.

    for (int i = 0; i < tokenArray.length; i++)
    { // fill array of dimension: 2*number of searchwords
      for (int j = 0; j < 2; j++)
      {
        switch (j)
        {
          case 0:
            array[i][j] = firstLetterToUpperCase(tokenArray[i]);
            break;
          case 1:
            array[i][j] = firstLetterToLowerCase(tokenArray[i]);
            break;
        }
        System.out.print(String.valueOf(i) + "/" + String.valueOf(j) + ": " + array[i][j] + "\t");
      }
      System.out.println();
    }

Output:

0/0: Hello 0/1: hello
1/0: You 1/1: you
2/0: Go 2/1: go

Ah noch was: in der switch-case-Anweisung achte darauf, dass nicht ungewollt zusätzlicher Code ausgeführt wird --> break !! (vgl meinen Code mit Deinem) Bei Dir werden nämlich immer case 1 und case 0 durchlaufen.

 

[sisko78]

Du überschreibst Dir jedes mal in der inneren Schleife array[0][0] und array[1][0]. Das ist sicher nicht gewollt und auch nicht richtig.
Im Code unten bekommst Du schon mal die drei Worte in allen Variationen, zusammenfrickeln musst Du sie dann selbst.

...

Ah noch was: in der switch-case-Anweisung achte darauf, dass nicht ungewollt zusätzlicher Code ausgeführt wird --> break !! (vgl meinen Code mit Deinem) Bei Dir werden nämlich immer case 1 und case 0 durchlaufen.

Danke, hatte vergessen, dass hinter dem Sprung ja alles ausgeführt wird, jedoch war in meinem Fall der Array trotzdem richtig gefüllt (zumindest ab dem 2. Wort, was ja eigentlich beabsichtigt war), da die falschen Einträge wieder mit den richtigen überschrieben werden.
Das Hauptproblem liegt beim Zusammensetzen der Teil, was ich mit Rekursion zu machen versuche (Wie könnte man da noch rangehen?). Wenn ich versuche, dass nachzuvollziehen, komme ich auf was Anderes, als das, was mir der Rechner ausgibt.
Jedenfalls vielen Dank für die Tips. Vielleicht kann mir noch jemand beim Zusammensetzen der Worte helfen?

Gruß
sisko78

 

[sisko78]

ok, habs jetzt, ist ja ganz einfach mit 2 Schleifen hinzubekommen

private void withoutRecursion() {      
        for (int i=1; i<tokenArray.length;i++){
          for (int j=0;j<2;j++){
             System.out.print(array[i][j]+" ");
          }
         System.out.println("");
        }

 

[Snape]

Naja, Du solltest schon mit i=0 beginnen. Außerdem ist das eine gute Übung zur Rekursion.

 

[sisko78]

i=1 passt schon, den ersten Eintrag brauche ich nicht. Aber mit der Rekursion haste recht, mal schauen, wenn ich noch ein bissel Zeit übrig habe...

 

[sisko78]

Ich depp , diese 2 Schleifen geben mir ja nur nochmal das Array aus, aber umgeordnet ist ja noch nix, hab jetzt aber endlich ne Möglichkeit gefunden

Statt

k++;
tryRecursion(k);

tryRecursion(k+1)

und plötzlich kommt was ganz anderes raus

Gruß
sisko78