Verwenden rekursiven und rekursiven Helper, um Benutzer eingegeben Kapital Zeichen von TexField zu TextArea

Question

Ich schrieb dieses Java-Fx-Programm und es funktioniert perfekt ohne die rekursiven Implementierungen. Ich habe die Schaltfläche onAction Lambda geschrieben, um sicherzustellen, dass das Programm korrekt funktioniert, bevor es in die Rekursion konvertiert wird. Ich habe die letzten paar Stunden damit verbracht, die beiden erforderlichen Rekursiven herauszufinden und sie mit dem Lambda-Ausdruck button.onAction aufzurufen, aber ich brauche einen Schub in die richtige Richtung. Hier ist was ich habe.

static TextField textField = new TextField(); 
static String text = textField.getText(); 
static TextArea textArea = new TextArea(); 
static Button btSubmit = new Button ("Submit"); 

@Override 
public void start(Stage primaryStage){ 

Label label1 = new Label("Enter letters and I will " 
     + "count the capitals.\t"); //Create textfield label. 

textArea.setEditable(false); 
textArea.setMaxWidth(450); 
textArea.setMaxHeight(100); 

HBox hbox = new HBox(); //Create hbox. 
hbox.setAlignment(Pos.BASELINE_CENTER); //Set hbox to center. 
hbox.getChildren().addAll(label1, textArea, textField, 
     btSubmit); //Add children to hbox. 


BorderPane pane = new BorderPane(); //Create pane. 
pane.setTop(hbox); //Set hbox to top of pane. 
pane.setCenter(textArea); //Set text area to center. 

Scene scene = new Scene (pane, 450, 200); //Create scene. 
primaryStage.setTitle("Count Capital Letters"); 
primaryStage.setScene(scene); 
primaryStage.show();  

btSubmit.setOnAction(e -> { 
    String text = textField.getText(); 
    int upperCase = 0; 
    for (int i = 0; i < text.length(); i++){ 
     if (Character.isUpperCase(text.charAt(i))) upperCase++; 
    } 
    String numCaps = String.valueOf(upperCase); 
    textArea.appendText("Number of capitals: " + numCaps); 
    }); 
} 

public static int count(char[] chars) { 
    String text = textField.getText(); 
    chars = text.toCharArray(); 
    if (chars.length == 0); 
    return 0; 
} 
public static int count(char[] chars, int high) { 
    high = 0; 
    String text = textField.getText(); 
    chars = text.toCharArray(); 
    for (int i = 0; i < chars.length; i++){ 
     if (Character.isUpperCase(chars[i])) { 
      high++; 
      } 
     } 
    return high; 
} 

public static void main(String[] args){ 
launch(args); 
}} 

Was ich versuche, die Button-Aktion Aufruf der rekursiven Methoden zu tun ist, aber ich bin verwirrt, wie meine aktuelle Aktion mit einem Aufruf an die recursives zu ersetzen.

Nachdem ich darauf geschlafen habe, hier ist, was ich für die beiden rekursiven Methoden entwickelt habe. Ich wusste, dass ich letzte Nacht zwei verschiedene Methoden hatte und dass sich ein Rekursiv selbst nennen sollte. Hier ist, was ich bisher geändert habe.

Anstelle der beiden separaten Methoden:

public static int count(char[] chars, int high) { 
    int count = 0; 
    if (high < chars.length) { 
      if (Character.isUpperCase(chars[high])) { 
       return 1 + count; 
      } 
      else { 
       return count(chars, high+1); 
      } 
    } 
    return 0; 
} 

Bin ich zumindest auf dem richtigen Weg? Die Notwendigkeit, die beiden rekursiven Methoden (Original und dessen Helfer) zu verwenden, bringt mich um.

Answer 1

Es ist nicht klar aus Ihrem Code, was high sein soll. Ich nehme an, dass es der Index des letzten Zeichens in dem Zeichenarray sein soll, das Sie untersuchen werden (wahrscheinlich exklusiv).

Also Ihr rekursiver Schritt müsste wirklich high reduzieren, nicht erhöhen, und Sie nur chars[high-1] direkt untersuchen. Sie benötigen auch einen Beendigungsschritt, bei dem keine weiteren Zeichen angezeigt werden.

So würde ich dies umzusetzen als

private int count(char[] chars, int high) { 
    // if high==0 we are looking at zero characters, so there are no upper-case characters: 
    if (high == 0) { 
     return 0 ; 
    } 

    if (Character.isUpperCase(chars[high-1])) { 
     // if the last character we look at is upper-case, then the total 
     // for this set of characters is one more than the total for the 
     // set of characters omitting the last one: 
     return 1 + count(chars, high-1); 
    } else { 
     // otherwise (the last character is not upper-case), the total 
     // for this set of characters is the same as the total for the 
     // set of characters omitting the last one: 
     return count(chars, high-1); 
    } 
} 

Der Einfachheit halber auch

public int count(String text) { 
    return count(text.getChars(), text.length()); 
} 

und dann Ereignishandler muss implementieren könnte nur

label1.setText("Number of upper case: "+count(textField.getText())); 

(Warum nennen Erde du hast alles gemacht static ist eine ganze andere Diskussion.)

Answer 2

Schließlich stellen Sie das Programm zusammen. Nahm mich eine Weile, danke für den Stoß James.

@Override 
public void start(Stage primaryStage){ 

    Button btSubmit = new Button ("Submit"); //Create button. 
    TextField textField = new TextField(); //Create text field and label. 
    Label label1 = new Label("Enter letters and I will count the capitals.\t"); 

    TextArea textArea = new TextArea(); //Create text area. 
    textArea.setEditable(false); //Make it so text area cannot be edited. 
    textArea.setMaxWidth(450); 
    textArea.setMaxHeight(100); 

    HBox hbox = new HBox(); //Create hbox, set position, and add children. 
    hbox.setAlignment(Pos.BASELINE_CENTER); 
    hbox.getChildren().addAll(label1, textArea, textField, btSubmit); 

    BorderPane pane = new BorderPane(); //Create pane. 
    pane.setTop(hbox); //Set hbox to top of pane. 
    pane.setCenter(textArea); //Set text area to center. 

    Scene scene = new Scene (pane, 450, 200); //Create scene. 
    primaryStage.setTitle("Count Capital Letters"); 
    primaryStage.setScene(scene); 
    primaryStage.show();  

    //Create button lambda expression to call the recursive method. 
    btSubmit.setOnAction(e -> { 
     String text = textField.getText(); //Convert entered text to string. 
     char[] chars = text.toCharArray(); //Fill array with the chars. 
     count(chars); 
     //Add the number of capitals to the text area. 
     textArea.appendText("Number of capitals: " + count(chars)); 
     }); 
} 


public static int count(char[] chars) { 
    //Set up the recursive helper and index. 
    return count(chars, chars.length - 1); 
} 

public static int count(char[] chars, int high) { 
    //If nothing is entered return 0. 
    if (high == -1) 
     return 0; 
    //If char is uppercase increase count. 
    if (Character.isUpperCase(chars[high])) 
     return 1 + count(chars, high - 1); 
    //If both both previous conditions are not true, the fucntion passes 
    //over that character to test the next one. 
    return count(chars, high - 1); 
} 

public static void main(String[] args) { 
    launch(args); 
} 

}