Der unendlich tippende Affe

[Lucaaa]

Hallo!
Ich möchte die Theorie des unendlich tippenden Affen in Java umsetzen.
Das Programm soll einen Text der getippt werden soll entgegennehmen.
Dann sollen Zeichen A-Z und Leerzeihen generiert werden, solange bis das eingegebene Wort generiert wurde.
Ich habe bisher folgendes (funktionsunfähig) es hängt sich immer auf.
P.S. Da der String in dem der generierte Text gespeichert wird, ziemlich lang werden kann (also wirklich extrem lang) sollten die bereits auf das Wort geprüften Zeichen wieder entfernt werden.

package com.ludevstudio.desktop.unendlichtippenderaffe;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextArea;
import javax.swing.JTextField;
public class Main extends JFrame implements ActionListener{
 private JLabel labelText, labelStatus, labelGetipptHead, labelGetippt;
 private JTextArea taText;
 private JButton btnStart, btnStop;
 private JTextField tfText;
 
 private int getippteZeichen = 0;
 private String getippterText;
 private String text;
 
 Boolean gestoppt = false;
 
 public static void main(String[] args) {
  new Main();
 }
 
 public Main() {
  setTitle("Der undendlich tippende Affe");
  setDefaultCloseOperation(EXIT_ON_CLOSE);
  setLayout(null);
  setSize(500, 170);
  setLocationRelativeTo(null);
  initKomponenten();
  setVisible(true);
  
 }
 
 private void initKomponenten() {
  labelText = new JLabel("Zu tippender Text:");
  labelText.setBounds(10, 10, 550, 30);
  this.add(labelText);
  
  btnStart = new JButton("Starten");
  btnStart.setBounds(10, 75, 100, 30);
  btnStart.addActionListener(this);
  this.getContentPane().add(btnStart);
  
  btnStop = new JButton("Stoppen");
  btnStop.setBounds(120, 75, 100, 30);
  this.getContentPane().add(btnStop);
  
  tfText = new JTextField();
  tfText.setBounds(10, 40, 212, 30);
  this.getContentPane().add(tfText);
  
  labelStatus = new JLabel("Status: Inaktiv");
  labelStatus.setBounds(240, 10, 550, 30);
  this.add(labelStatus);
  
  labelGetipptHead = new JLabel("Getippte Zeichen:");
  labelGetipptHead.setBounds(240, 40, 550, 30);
  this.add(labelGetipptHead);
  
  labelGetippt = new JLabel("0");
  labelGetippt.setBounds(240, 60, 550, 30);
  this.add(labelGetippt);
 }
 @Override
 public void actionPerformed(ActionEvent event) {
  if(event.getSource()==btnStart) {
   text = tfText.getText();
   
   starteTippen(text);
  }
  
 }
 private void starteTippen(String text) {
  
    char[] zeichen = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
    ' '};
    int counter = 0;
    StringBuilder sb = new StringBuilder();
    Random random = new Random();
    for (int i = 0; i>-1; i++) {
     
    // sb.append(zeichen[random.nextInt(26)]);
    // getippterText = sb.toString();
     counter++;
     labelGetippt.setText(Integer.toString(counter)); 
     
     if(gestoppt=true) {
     // return;
     }
     
    }
              
              
    
   }
 
  
 }

Bitte um Hilfe!
Vielen Dank.

 

[Blender3D]

P.S. Da der String in dem der generierte Text gespeichert wird, ziemlich lang werden kann (also wirklich extrem lang) sollten die bereits auf das Wort geprüften Zeichen wieder entfernt werden.

Du hast Dir das Problem nicht wirklich überlegt.
Zwar stimmt es, dass der Algorithmus theoretisch immer terminiert ...
Die Frage lautet aber wie lange. Bei einem Wort von 10 Buchstaben brauchst du 26^10 = 141.167.095.653.376 Tippversuche, um das Wort zu finden. Das kann schon sehr lange dauern.
Das heißt:
1) der Algorithmus gehört in einen separaten Thread, um die Hauptanwendung nicht zu blockieren.

int counter = 0;

2) int ist für den Zähler ungeeignet ( maximal 2^32-1 Werte dann folgt ein Überlauf) besser BigInteger

import java.math.BigInteger;
import java.util.Random;
public class TypingApe implements Runnable {
   public final static String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   private Random rnd = new Random(System.currentTimeMillis());
   private BigInteger count = BigInteger.ZERO;
   private char[] word = null;
   private boolean found = false;
   public TypingApe(String word) {
      word = word.toUpperCase();
      this.word = word.toCharArray();
      Thread thread = new Thread(this);
      thread.start();
   }
   public BigInteger getCount() {
      return Count;
   }
   private char getRandomLetter() {
       count = count.add(BigInteger.ONE);
      return alphabet.charAt(rnd.nextInt(alphabet.length()));
   }
@Override
   public void run() {
      char[] wordTest = new char[word.length];
      int pos = 0;
      while (!found) {
         wordTest[pos] = getRandomLetter();
         pos = (wordTest[pos] != word[pos]) ? 0 : pos + 1;
         if (pos == wordTest.length)
            found = true;
       }
  }
   public boolean isFound() {
      return found;
   }
}

    TypingApe ape = new TypingApe("test");
        while (!ape.isFound()) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e1) {            
                e1.printStackTrace();
            }
        }
        System.out.println(ape.getCount());