Question

我已经尝试了很长时间才能完成这项工作。我的下面的代码非常混乱而且没有工作，主要是为了显示我之前的尝试...

Soo我需要什么帮助？我想创建一个Stack对象，从文本字段中逐个字符地读取（推送），然后弹出并反向打印单词。哪个应该自动考虑Stack是后进先出（LIFO）。

 charStack stack = new charStack();
    String entering = textfield.getText();
    for(int i = 0; i < entering.length(); i++){
        //stack.push(i);
        char ch = entering.charAt(i);
        if(Character.isHighSurrogate(ch)){
          i++;
        if (i < entering.length()){
          stack.push(entering.charAt(i));
        }
        }
        stack.push(ch);
        while(entering.length() != 0){
        label.setText(stack.pop().toString());
    }
}

控制器：

public class FXMLDocumentController implements Initializable {

    @FXML
    private Label label;

    @FXML
    private TextField textfield;

    Stack<Character> stack = new Stack<>();

    @Override
    public void initialize(URL url, ResourceBundle rb) {
        //label.textProperty().bind(textfield.textProperty());



    }    

    @FXML
    private void exeCute(ActionEvent event) {
       // String a = textfield.getText();
        //for (char c: a.toCharArray()){
          //  stack.push(c);

        //}

        //while(!stack.empty()){
          //  label.setText(stack.pop().toString());
        //}

        //char[] stack = textfield.getText().toCharArray();
        //char[] reverse = new char[stack.length];
        //int position = stack.length - 1;
        //for(int i = 0; i<stack.length; i++){
          //  reverse[i] = stack[position--];
        //}
        //System.out.print(reverse);
        //String newone = reverse.toString();
        //label.setText(newone); //Works (sort of) but need to do this with stack-object

        //String entering = textfield.getText();
        //for (int i = 0; i < entering.length(); i++){
          //  char ch = entering.charAt(i);
            //if(Character.isHighSurrogate(ch)){
              //  i++;
                //if (i < entering.length()){
                  //  stack.push(entering.charAt(i));
                //}
            //}
            //stack.push(ch);
            //System.out.print(stack.pop());  

        String e = textfield.getText();
            for (int i = 0; i < e.length(); i++){
            char ch = e.charAt(i);
            if(Character.isHighSurrogate(ch)){
                i++;
                if (i < e.length()){
                    stack.push(e.charAt(i));

                }
            }
            stack.push(ch);
            //stack.pop();
            //printStack(stack);


            }
    }
    private void printStack(Stack<Character> s){
        if (s.isEmpty()){
            System.out.println("Stack is empty!");
        }
        else {
            System.out.printf("%s TOP\n" + s);
        }
    }
}

Answer 1

考虑这个循环：

while(entering.length() != 0){
    label.setText(stack.pop().toString());
}

让我们说你原来的字符串是＆＃34; abcd＆＃34;。在进入此循环之前，您的筹码包含＆＃39;＆＃39; c＆＃39;，＆＃39; b＆＃39;，＆＃39; a＆＃39;。在循环中，您可以将标签上的文字设置为＆＃39; d＆＃39;然后设置为＆＃39; c＆＃39;然后设置为＆＃39; b＆＃39;然后设置为＆＃39; a＆＃39; ;。最后，标签上的文字应为＆＃34; a＆＃34;。你想要的是使用这个循环来构建一个字符串，最终将是＆＃34; dcba＆＃34;然后，然后将标签上的文本设置为此反转字符串。看看StringBuilder课程，如果你还不知道，那就是你需要做的事情：https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html。

编辑：另一个问题在于这段代码：

if (Character.isHighSurrogate(ch)) {
    i++;
    if (i < entering.length()) {
        stack.push(entering.charAt(i));
    }
}
stack.push(ch);

我不确定你想在这里实现什么，但如果你只想省略高代理人，你应该写一下

if (Character.isHighSurrogate(ch)) {
    continue;
}
stack.push(ch);

Answer 2

我建议不要编写自己的逐字符串反转逻辑。由于用于字符编码Java字符串的unicode系统，这样做所涉及的逻辑有点棘手，因为它需要考虑unicode surrogate pairs（并且你的实现可能会出错）。

相反，重用JDK库中现有的反转逻辑：StringBuilder::reverse。绑定可用于使标签文本与反转字符串保持同步。

label.textProperty().bind(
        Bindings.createStringBinding(
                () -> new StringBuilder(textField.getText()).reverse().toString(),
                textField.textProperty()
        )
);

在此示例中，每次文本字段的文本更改时，都会完全构建反向字符串。它不是最有效的编码方式。但是，考虑到TextField中预期的字符串长度很短，预计解决方案的效率不会导致任何类型的性能问题。

示例应用

import javafx.application.Application;
import javafx.beans.binding.Bindings;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class InputReversal extends Application {    
    @Override
    public void start(Stage stage) {
        TextField textField = new TextField();
        Label label = new Label();
        label.textProperty().bind(
                Bindings.createStringBinding(
                        () -> new StringBuilder(textField.getText()).reverse().toString(),
                        textField.textProperty()
                )
        );

        VBox layout = new VBox(10, textField, label);
        layout.setPadding(new Insets(10));
        stage.setScene(new Scene(layout));
        stage.show();
    }

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

哦，我们的老师希望我们尝试不同类型的高级编程，例如，以更好的方式理解不同的数据结构和javafx接口。

基于简单堆栈的解决方案是：

private String reverse(String text) {
    final Stack<Character> stack = new Stack<>();
    for (int i = 0; i < text.length(); i++) {
        stack.push(text.charAt(i));
    }

    StringBuilder builder = new StringBuilder(text.length());
    for (int i = 0; i < text.length(); i++) {
        builder.append(stack.pop());
    }

    return builder.toString();
}

通过以下方式调用：

Bindings.createStringBinding(
        () -> reverse(textField.getText()),
        textField.textProperty()
)

但是，这并没有考虑到需要代理对逻辑的逆转。由于这似乎是一项任务，我将把这部分留给你。为此，咨询in-built JavaFX library source处理字符串反转如何帮助确定正确的逻辑，尽管它可能会让您感到困惑。

通过char Stack创建一个char并将其分配给标签。 JavaFX的

2 个答案: