String vergleichen.

Ich versuche gerade, 2 Strings zu vergleichen. Einer hat ein Wort und der andere hat das gleiche Wort aus verschiedenen chars zusammengefügt.
Auch wenn ich diese mit System.out.println() ausgebe, sehen die gleich aus, doch, wenn ich die beiden Strings mit .equals versuche, zu vergleichen, geht das nicht...

Java:
    public String getString() {
        all = "";
        for(int i = 0; i < A.length; i++){
            all += "" + A[i];
           //System.out.println(all);
        }
        return all;
    }

//ander funktion:
try {
    R = r[i][j];
    R2 = N.getString();
    System.out.println(R + "=" + R2);
    catch(NullPointerException e) {
        }
    if(R.equals(R2)) {
        r1 = true;
        System.out.println("Kennwort Richtig!");
    }

Wäre nett, könntet ihr mir da helfen.
 

kneitzel

Top Contributor
Hier kann ich erst einmal nichts sagen, da der Auszug einfach nicht ausreichend ist. Also evtl. genug Code zeigen, so dass die Typen der variablen, ggf. deren Füllung und so alle gesehen werden. Im idealen Fall ein einfaches, kleines, lauffähiges Beispiel liefern, dass die Problematik aufzeigt.

Generelle Hinweise:
- Java Naming Convention: Variablen bitte mit einem kleinen Buchstaben starten!
- Aussagekräftige Bezeichner. Bezeichner mit nur einem Zeichen sind in der Regel schlecht.
- Eine NPE wird nicht gefangen! Schreibe statt dessen Code, der halt Elemente, die null sein können, prüft!
- Wenn eine Exception gefangen wird: Keine leeren Catch Blöcke! Das ist ein absolutes No Go, denn damit versteckst Du Fehler und die Fehlersuche wird erschwert bis unmöglich.
 
Zum letzten Punkt: Das läuft in einer Schleife und ich möchte nicht die ganze Zeit zugespammt werden.
Der Fehler hat aber nichts mit dem catch zutun, da in der try Klammer ein System.out gesagt wird und da da Admin=Admin rauskommt.
"all" ist ein String, A[] ist ein char Array mit dem Wort "Admin" drin, r[][] ist ein String Array, was mit dem code
Java:
 try {
            datei = new File("account.txt");
            if(!datei.exists()) {
                datei.createNewFile();
            }
            bw = new BufferedWriter (new FileWriter ("account.txt", true));
            bw.close();
        }
        catch(java.io.IOException e) {
        }
Und
Java:
private void read() {
        try {
            fis = new FileInputStream("account.txt");
            isr = new InputStreamReader(fis);
            br = new BufferedReader(isr);
            L = br.readLine();
            while(L != null) {
                lenght++;
                if("/".equals(L)) {
                    accounts++;
                }
                L = br.readLine();
            }
            r = new String[accounts][lenght];
            fis2 = new FileInputStream("account.txt");
            isr2 = new InputStreamReader(fis2);
            br2 = new BufferedReader(isr2);
            L = br2.readLine();
            while(A<accounts) {
                x++;
                r[A][x] = L;

                if("/".equals(L)) {
                    A++;
                    x = 0;
                }
                L = br2.readLine();
            }
        }
        catch(java.io.IOException e) {
        }
    }

gefüllt wird, was unteranderem den String "Admin" hat.
 

kneitzel

Top Contributor
Also die Code-Teile passen nicht zusammen:
Im Teil jetzt ist A plötzlich ein integer Wert. In #1 war A noch ein Array.

Und der Code ist schlicht extrem unleserlich -
- Java Naming Convention: Variablen bitte mit einem kleinen Buchstaben starten!
- Aussagekräftige Bezeichner. Bezeichner mit nur einem Zeichen sind in der Regel schlecht.
hatte ich ja schon genannt - arbeite mal daran!

Dann ist dieser Punkt auch bi dem jetzt gebrachten Code wichtig:
- Wenn eine Exception gefangen wird: Keine leeren Catch Blöcke! Das ist ein absolutes No Go, denn damit versteckst Du Fehler und die Fehlersuche wird erschwert bis unmöglich.

Dann fällt aber weiterhin auf: Dateien werden gelesen ohne dass diese geschlossen werden. Das - zusammen mit den leeren Catch Blöcken - kann schon fatal sein. Eine Exception würdest Du dann ja nicht sehen.

Dann scheint alles über Instanzvariablen gemacht worden zu sein! Das ist auch nicht Sinn der Sache. Gerade so Dinge, die rein lokal genutzt werden wie deine Streams und so gehören nicht in eine Instanzvariable!

Vom Algorithmus her fällt auf, dass dein 2d Array viel zu groß ist. Du hast irgendwie ein Format, bei dem Accounts durch / getrennt sind. Die Anzahl der Zeilen zählst Du gnadenlos hoch. Aber beim Füllen des 2d Arrays wird das immer zurück gesetzt. Daher wird es nicht mit der Länge length benötigt. Maximal wäre es also eine max Anzahl Zeilen pro Account, die Du ermitteln müsstest. Aber wenn Accounts nicht die gleiche Anzahl Elemente haben, dann wären dynamische Datentypen sinnvoller als so ein statisches Array. Wobei natürlich auch ein 2d Array denkbar wäre, aber das ist ja auch nur ein Array of Arrays, d.h. die einzelnen Unter-Arrays könnten unterschiedliche Längen haben.

Also erneut sieht man keine wirkliche Fehlerursache, aber das sind alles Punkte, an denen Du aktiv ansetzen solltest:
- Benenne alles zu was Sinnvollem um - eine IDE hat dazu gute Möglichkeiten. Halte Dich dabei an die Java Naming Conventions!
- Tue wenigstens eine Ausgabe in die catch Blöcke! Das ist das absolute Minimum, so dass Du die Exception und den Stacktrace siehst.
- Schließe eine Datei, nachdem Du diese gelesen hast. Dazu wäre "try with resources" ideal.
- Nutze für alles, das Du nur lokal brauchst, wirklich lokale Variablen!

Das kann schon helfen, den Fehler zu finden.
 
Ok... das sind 2 verschiedene Funktionen und A ist beim 2. ein Int. Ich habe halt das Problem, dass das, was ich aus den Chars zusammengebaut habe, nicht das gleiche ist, wie der String, obwohl beides gleich ausgegeben wird. das habe ich herausgefunden, als ich bei if(R.equals(R2)) {
jeweils statt R und R2 den String "Admin" ersetzt habe und als ich R2 mit Admin ersetzt habe, ging es, bei R nicht. Also ist etwas mit dem
Java:
public String getString() {
        all = "";
        for(int i = 0; i < A.length; i++){
            all += "" + A[i];
           //System.out.println(all);
        }
        return all;
    }
falsch.
 

kneitzel

Top Contributor
Zeig den ganzen Code! Die ganzen Klassen. Und bitte befolge die Hinweise!

Je schwerer Code lesbar ist, desto leichter sind Fehler möglich und um so schwerer sind die Fehler zu finden.
Je weniger Du Daten kapselst, desto leichter passiert es, dass Daten ungewollt verändert werden.

Dein letzter Code als Beispiel:
Java:
public String getString() {
        all = ""; // Dies ist eine Instanzvariable! 
        for(int i = 0; i < A.length; i++){
            all += "" + A[i];
           //System.out.println(all);
        }
        return all;
    }

Du setzt da eine Instanzvariable:
1. Problem: "getString()" ist eine Methode, die irgendwas ausliest. Dass dabei der Zustand der Instanz verändert wird, wird bei so einem Aufruf nicht erwartet!
2. Problem: Du passt ja die Instanzvariable all an. Dann kann man ja mit der weiter arbeiten. Aber wer weiss, vielleicht wird die noch woanders verändert? Du gibst die ggf. direkt nach der ersten Erstellung aus. Wer weiss, was der Wert ist, wenn Du dann irgendwann zu dem Vergleich kommst?

Fakt ist: Aus den bisher uns hingeworfenem Code können wir keinen Fehler ableiten. Uns fehlen wichtige Dinge. Und wenn A mal den einen Typ hat und mal den anderen: Dann sind die Methoden auch noch in unterschiedlichen Klassen. Hast Du denn da überhaupt einen Überblick, wenn Du mehrere Klassen hast und die haben alle tolle Variablen A, B, C, R, X, Y, Z?

Sorry - ich will Dir nicht zu nahe treten. Aber mehr als diese allgemeinen Ratschläge kann ich Dir nicht geben, da einfach nicht genug Informationen vorliegen, um das genannte Problem zu lokalisieren. Aber es fallen viele Dinge auf, die dringend (!!) behoben werden sollten, da sie Dir das Leben schwer machen. (Davon bin ich überzeugt. Du magst es anders sehen, aber die Tatsache, dass Du da einen Fehler nicht finden kannst, sollte doch auch eigentlich Bände sprechen.)
 
Schreibfeld:
package Tools.Menu;

import sum.kern.*;

public class Schreibfeld
{
    Maus M;
    Buntstift bst;
    Tastatur tt;
    private double vpos;
    private double hpos;
    private double v;
    private double h;
    private int c;
    private String s;
    private double Hpos;
    private double Vpos;
    private boolean a = true;
    private boolean g = false;
    private boolean ge;
    private int x;
    private String all = " ";
    thread th;
    char[] A;

    public Schreibfeld(double hPos, double vPos, double hBreite, double vBreite, int Color, String Text)
    {
        M = new Maus();
        tt = new Tastatur();
        vpos = vPos;
        hpos = hPos;
        h = hBreite;
        v = vBreite;
        c = Color;
        s = Text;
        A = new char[16];
        bst = new Buntstift();
        bst.setzeFarbe(c);
        bst.bewegeBis(hpos, vpos);
        bst.zeichneRechteck(h, v);
        bst.bewegeBis((hpos+(h/10)), (vpos+(v/1.5)));
        bst.schreibeText(s);
        th = new thread();
        th.start();
    }
    class thread extends Thread {
        public void run() {
            Hpos = hpos + h;
            Vpos = vpos + v;
            while(a==true) {
                if(M.hPosition()<=Hpos&M.hPosition()>=hpos&M.vPosition()<=Vpos&M.vPosition()>=vpos&M.istGedrueckt()) {
                    g = true;
                    loesche();
                    a = true;
                    bst.bewegeBis(hpos, vpos);
                    bst.zeichneRechteck(h, v);
                    bst.bewegeBis((hpos+(h/10)), (vpos+(v/1.5)));
                    x = 0;
                    for(int i = 0; i < A.length; i++){
                        A = new char[16];
                        System.out.println(all);
                    }
                }
                else if(M.istGedrueckt()){
                    g = false;
                }
                if(g==true) {
                    if (tt.wurdeGedrueckt()) {
                        if(x<=16) {
                            switch(tt.zeichen()) {
                                case '^': bst.schreibeText("^");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '1': bst.schreibeText("1");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '2': bst.schreibeText("2");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '3': bst.schreibeText("3");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '4': bst.schreibeText("4");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '5': bst.schreibeText("5");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '6': bst.schreibeText("6");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '7': bst.schreibeText("7");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '8': bst.schreibeText("8");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '9': bst.schreibeText("9");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '0': bst.schreibeText("0");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'ß': bst.schreibeText("ß");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '´': bst.schreibeText("´");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '°': bst.schreibeText("°");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '!': bst.schreibeText("!");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '"': bst.schreibeText('"');
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '²': bst.schreibeText("²");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '§': bst.schreibeText("§");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '³': bst.schreibeText("³");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '$': bst.schreibeText("$");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '%': bst.schreibeText("%");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '&': bst.schreibeText("&");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '/': bst.schreibeText("/");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '{': bst.schreibeText("{");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '(': bst.schreibeText("(");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '[': bst.schreibeText("[");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case ')': bst.schreibeText(")");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case ']': bst.schreibeText("]");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '=': bst.schreibeText("=");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '}': bst.schreibeText("}");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '?': bst.schreibeText("?");
                                x++;
                                A[x] = tt.zeichen(); break;
                                //case '\': bst.schreibeText(""); break;
                                case '`': bst.schreibeText("`");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'q': bst.schreibeText("q");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'Q': bst.schreibeText("Q");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '@': bst.schreibeText("@");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'w': bst.schreibeText("w");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'W': bst.schreibeText("W");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'e': bst.schreibeText("e");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'E': bst.schreibeText("E");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'r': bst.schreibeText("r");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'R': bst.schreibeText("R");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 't': bst.schreibeText("t");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'T': bst.schreibeText("T");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'z': bst.schreibeText("z");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'Z': bst.schreibeText("Z");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'u': bst.schreibeText("u");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'U': bst.schreibeText("U");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'i': bst.schreibeText("i");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'I': bst.schreibeText("I");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'o': bst.schreibeText("o");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'O': bst.schreibeText("O");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'p': bst.schreibeText("p");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'P': bst.schreibeText("P");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '+': bst.schreibeText("+");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '*': bst.schreibeText("*");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '~': bst.schreibeText("~");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'a': bst.schreibeText("a");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'A': bst.schreibeText("A");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 's': bst.schreibeText("s");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'S': bst.schreibeText("S");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'd': bst.schreibeText("d");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'D': bst.schreibeText("D");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'f': bst.schreibeText("f");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'F': bst.schreibeText("F");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'g': bst.schreibeText("g");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'G': bst.schreibeText("G");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'h': bst.schreibeText("h");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'H': bst.schreibeText("H");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'j': bst.schreibeText("j");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'J': bst.schreibeText("J");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'k': bst.schreibeText("k");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'K': bst.schreibeText("K");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'l': bst.schreibeText("l");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'L': bst.schreibeText("L");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '<': bst.schreibeText("<");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '>': bst.schreibeText(">");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '|': bst.schreibeText("|");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'y': bst.schreibeText("y");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'Y': bst.schreibeText("Y");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'x': bst.schreibeText("x");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'X': bst.schreibeText("X");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'c': bst.schreibeText("c");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'C': bst.schreibeText("C");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'v': bst.schreibeText("v");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'V': bst.schreibeText("V");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'b': bst.schreibeText("b");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'B': bst.schreibeText("B");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'n': bst.schreibeText("n");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'N': bst.schreibeText("N");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'm': bst.schreibeText("m");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case 'M': bst.schreibeText("M");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case ',': bst.schreibeText(",");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case ';': bst.schreibeText(";");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '.': bst.schreibeText(".");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case ':': bst.schreibeText(":");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '-': bst.schreibeText("-");
                                x++;
                                A[x] = tt.zeichen(); break;
                                case '_': bst.schreibeText("_");
                                x++;
                                A[x] = tt.zeichen(); break;
                                default: ge = false;
                            }
                            tt.weiter();
                        }
                    }
                }
            }
        }
    }
    public void loesche() {
        a = false;
        bst.bewegeBis(hpos, vpos);
        bst.setzeFuellMuster(1);
        bst.radiere();
        bst.zeichneRechteck(h, v);
        bst.setzeFuellMuster(0);
        bst.normal();
        bst.bewegeBis((hpos+(h/10)), (vpos+(v/1.5)));
    }
    public boolean getGecklickt() {
        return g;
    }
    public String getString() {
        all = "";
        for(int i = 0; i < A.length; i++){
            all += "" + A[i];
           //System.out.println(all);
        }
        return all;
    }
}
Accounts:
package Tools.Menu;

import java.io.*;
import sum.komponenten.*;
import sum.werkzeuge.*;
import sum.kern.*;

public class Accounts
{
    File datei;
    BufferedWriter bw;
    BufferedReader br;
    FileInputStream fis;
    InputStreamReader isr;
    BufferedReader br2;
    FileInputStream fis2;
    InputStreamReader isr2;
    Bildschirm sc;
    Buntstift bst;
    //Textfeld n;
    //Textfeld p;
    Schreibfeld N;
    Schreibfeld P;
    Button be;
    //Knopf be;
    Knopf a;
    Knopf b;
    int lenght;
    int accounts;
    int A;
    int x;
    boolean neu = false;
    boolean fertig = false;
    String L;
    String R;
    String R2;
    String[][] r;
    boolean r1;
    boolean r2;

    public Accounts()
    {
        try {
            datei = new File("account.txt");
            if(!datei.exists()) {
                datei.createNewFile();
            }
            bw = new BufferedWriter (new FileWriter ("account.txt", true));
            bw.close();
        }
        catch(java.io.IOException e) {
        }
        read();
        anmelden();
    }
    public void anmelden() {
        sc = new Bildschirm(400, 400);
        bst = new Buntstift();
        //n = new Textfeld(200, 200, 100, 20, "Name");
        N = new Schreibfeld(200, 150, 100, 20, 0, "Name");
        P = new Schreibfeld(200, 190, 100, 20, 0, "Password");
        //p = new Textfeld(200, 240, 100, 20, "Password");
        //be = new Knopf(200, 260, 50, 20, "Fertig");
        be = new Button(300, 360, 50, 20, 0, "Fertig");

        while(fertig!=true) {
            for(int i = 0; i < r.length; i++){
                for(int j = 0; j < r[i].length; j++){
                    if(r[i][j] != null) {
                        try {
                            R = r[i][j];
                            R2 = N.getString();
                            System.out.println(R + "=" + R2);
                        }
                        catch(NullPointerException e) {
                        }
                        if("Admin".equals(R2)) {
                            r1 = true;
                            System.out.println("Kennwort Richtig!");
                        }
                    }
                }
            }
            if(r1 == true) {
                System.out.println("Name richtig");
                r1 = false;
                for(int i = 0; i < r.length; i++){
                    for(int j = 0; j < r[i].length; j++){
                        if(r[i][j] != null) {
                            if(r[i][j]== P.getString()) {
                                r1 = true;
                            }
                        }
                    }
                }
            }
        }
    }
    private void read() {
        try {
            fis = new FileInputStream("account.txt");
            isr = new InputStreamReader(fis);
            br = new BufferedReader(isr);
            L = br.readLine();
            while(L != null) {
                lenght++;
                if("/".equals(L)) {
                    accounts++;
                }
                L = br.readLine();
            }
            r = new String[accounts][lenght];
            fis2 = new FileInputStream("account.txt");
            isr2 = new InputStreamReader(fis2);
            br2 = new BufferedReader(isr2);
            L = br2.readLine();
            while(A<accounts) {
                x++;
                r[A][x] = L;

                if("/".equals(L)) {
                    A++;
                    x = 0;
                }
                L = br2.readLine();
            }
        }
        catch(java.io.IOException e) {
        }
    }
}
Ich gib halt nicht so gerne den ganzen code raus, da viele Leute die Bibliothek sum nicht kennen (benutzen wir im Moment im Untericht und kann echt nicht wenig)

Doch es kann sich doch nichts zwischen dem System.out und dem checken geändert haben, oder?
Ich weiß, dass man an dem Ganzen noch viel ändern kann, um es übersichtlicher zu machen, doch alles, was dort steht, funktioniert (der Button, der auch eine meiner eigenen Klassen hat ist noch nicht funktionstüchtig, sondern ist einfach nur da)
 

kneitzel

Top Contributor
Was ist denn die genaue Ausgabe?

Und bei einer Ausgabe wie:
System.out.println(R + "=" + R2);
Würde ich immer Quote-Zeichen mitschreiben um auch mögliche Leerzeichen und so zu sehen:
System.out.println("'" + R + "'='" + R2+ "'");

Ansonsten ist später noch ein if(r[i][j]== P.getString()) - da wird ein String per == verglichen, was falsch ist. Aber wenn er Deiner Aussage nach nicht bis dahin kommt.

Ansonsten läuft es einem kalt den Rücken runter wenn man die Instanzvariablen sieht: a, A, r, R, r1, R2, r2, ...
 

kneitzel

Top Contributor
Ok, vermutlich hast Du noch nicht anzeigbare Zeichen mit drin. Deine Methode getString geht ja das ganze Array durch und erstellt somit einen String, der immer so lang ist, wie da Dein Array A auch groß ist.

Du hast in x ja gespeichert, wie viele Zeichen eingegeben wurden bzw. bis zu welchem Zeichen. Du darfst dann natürlich auch nur bis zu diesem Zeichen den String aufbauen.
 

kneitzel

Top Contributor
Weil es so immer noch falsch ist. Schau Dir genau an, was für ein Wert die Variable x hat und wie dann die Schleife aussehen muss.

Das ist übrigens auch genau das, was ich meinte mit vernünftigen Bezeichnern. Wenn x etwas wäre wie positionNaechstesZeichen, dann würdest Du es einfacher sehen, was falsch ist. Variablennamen sollten verständlich aussagen, was sie beinhalten!
 

kneitzel

Top Contributor
Wie wäre es, den Code lesbarer zu machen? Oder mal im Debugger zu schauen, wie denn das Array aussieht. Dann ist vermutlich auf Position 0 ein 0 und kein Zeichen.
 

mihe7

Top Contributor
@NicoHatProbleme2, ich misch mich mal nicht in den Code ein (anders gesagt: ich hab grad keine Lust :)) aber Du meintest bzgl. der Exceptions:
Das läuft in einer Schleife und ich möchte nicht die ganze Zeit zugespammt werden.
Das hat damit nichts zu tun. Wenn Du eine Exception in einer Methode nicht behandelst, wird sie an den Aufrufer zur Behandlung gereicht (dort gilt dann das gleiche Spiel) und Exceptions kannst Du sowohl innerhalb als auch außerhalb der Schleife behandeln.

Java:
while (true) {
    try {
        methodeDieExceptionAusloest();
    } catch (EineException ex) { 
        // behandle ex
        ex.printStackTrace();
    }
}
würde Dich also "zumüllen", dagegen würde bei
Java:
    try {
        while (true) {
            methodeDieExceptionAusloest();
        } 
    } catch (EineException ex) { 
        // behandle ex
        ex.printStackTrace();
    }
}
die Schleife im Fall einer Exception abgebrochen und nur einmal eine Ausgabe erfolgen. Wenn es sein muss, kannst Du Exceptions auch sammeln oder Dir nur die letzte merken und diese ausgeben:

Java:
Optional<Exception> lastThrown = Optional.empty();
while (bedingung) {
    try {
        methodeDieExceptionAusloest();
    } catch (EineException ex) { 
        lastThrown = Optional.of(ex);
    }
}
lastThrown.ifPresent(Throwable::printStackTrace);
 

kneitzel

Top Contributor
Also ich habe auch wenig Lust, mich durch Deinen Code zu wühlen, da er einfach extrem schlecht zu lesen und zu verstehen ist. Aber x wird bei leerem Feld 0 sein. So wird beim Löschen wohl auch x=0 gesetzt so ich Deinen Code richtig verstanden habe.

Wenn dann ein Wert eingegeben wird, dann wird da x erst hochgezählt und dann der Wert zugewiesen:
Java:
case '2':
    bst.schreibeText("2");
    x++;
    A[x] = tt.zeichen();
    break;

(Auch so ein Ding: Warum mehrere Dinge in eine Zeile packen? Das kann man doch schön auf die Zeilen verteilen!)

Damit dürfte in dem Array erst ab Zeichen 1 alles gefüllt werden. Aber Du liest in der Schleife ab Zeichen 0.

Das sind aber nur kleine Auszüge, die ich hier betrachte. Das kann man im Debugger bestimmt näher betrachten. Du kannst z.B. per Breakpoint anhalten wenn da die 2 gedrückt wurde um dann zu schauen, wo das im Array A landet und Du kannst Dir anschauen, wie das Array A aussieht, sprich die Werte selbst ansehen.
 

kneitzel

Top Contributor
Ansonsten noch eine Option, wie Du einen String prüfen könntest:
System.out.println(Arrays.toString(test.toCharArray()));

Das test musst Du natürlich mit der Variablen testen, die da das Problem hat (die Du also mit getName gefüllt hast).

BlueJ zeigt nicht darstellbare Zeichen leider nicht an - das ist schade. Andere Umgebungen zeigen das an.

Beispielcode:
Java:
import java.util.Arrays;

public class StringTest
{
    public static void main(String[] args) {
        String test = (char)0 + "TEST" + (char)0;
        System.out.println(test);
        System.out.println(Arrays.toString(test.toCharArray()));
    }

}

In BlueJ:
TEST
[, T, E, S, T, ]

In IntelliJ wird vor und nach dem TEST noch ein Zeichen angezeigt, das anzeigt, dass ein nicht darstellbares Zeichen vorhanden ist. Das sieht man dann sowohl beim println des Strings als auch bei der Darstellung des Arrays.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
P einen public <Optinal String> in einer anderen Klasse mit einem Int vergleichen Allgemeine Java-Themen 2
KeVoZ_ JSoup - Website Inhalt/Element mit String vergleichen Allgemeine Java-Themen 2
S Zwei String vergleichen, Fehler markieren Allgemeine Java-Themen 3
A Kann String nicht vergleichen (Android) Allgemeine Java-Themen 4
S String vergleichen Allgemeine Java-Themen 1
J String nur erste Zeichen vergleichen Allgemeine Java-Themen 6
S String Zeichen für Zeichen vergleichen Allgemeine Java-Themen 4
D String mit Wörterbuch vergleichen Allgemeine Java-Themen 12
1 String mit contains vergleichen (ignore case) Allgemeine Java-Themen 2
Developer_X Problem mit String vergleichen Allgemeine Java-Themen 3
M String mit equals() vergleichen - Frage Allgemeine Java-Themen 3
O String auf ungleichheit vergleichen Allgemeine Java-Themen 5
O String in Long Hexerdezimal umwandel Allgemeine Java-Themen 14
P String.replace() funktioniert nicht? Allgemeine Java-Themen 3
SaschaMeyer Arbeitet String.split falsch? Allgemeine Java-Themen 4
Mart Switches ohne String Allgemeine Java-Themen 18
AmsananKING String Iteration Allgemeine Java-Themen 5
S Shuffle String aus if-clause Allgemeine Java-Themen 11
Besset Variablen Ist String = "" + int inordnung? Allgemeine Java-Themen 6
M Map <Long, String> zu Map<String, Long> Allgemeine Java-Themen 9
S String Encoding Verständnisproblem Allgemeine Java-Themen 22
N Prüfen, ob ein String 2x das selbe Zeichen hat Allgemeine Java-Themen 10
SaftigMelo Bug Fixen von String-spliten Allgemeine Java-Themen 8
Monokuma String List nach Zahlen und Worten sortieren Allgemeine Java-Themen 9
Kingamadeus2000 Alle mehrfach vorkommenden Buchstaben rekursiv aus einem String entfernen. Allgemeine Java-Themen 6
YohnsonM String - Aufteilung und Nutzung einzelner Chars Allgemeine Java-Themen 7
O Formatierte String ausgabe bei vier Variablen in einer Zeile Allgemeine Java-Themen 1
S String umbenennen: wie? Allgemeine Java-Themen 4
x46 String Format Fehler Allgemeine Java-Themen 2
S ISO 8601 -> getter / setter String Allgemeine Java-Themen 3
L String zu repräsentativen Wert Allgemeine Java-Themen 0
H Array mit dem Datentype String[] initializieren Allgemeine Java-Themen 7
L ArrayList mit String Arrays in ein Array umwandeln Allgemeine Java-Themen 1
L regex ganzer string? Allgemeine Java-Themen 2
L Ist ein string ein erlaubter variabel name? Allgemeine Java-Themen 2
Z JNA Cpp-DLL String Verwendung Allgemeine Java-Themen 2
A String auf Zahlen überprüfen Allgemeine Java-Themen 5
N String Array Eingabe Allgemeine Java-Themen 6
M Datum von String zu LocalDateTime Allgemeine Java-Themen 8
W String -> byte[] -> String - Sieht jemand was ich nicht sehe? Allgemeine Java-Themen 10
R char aus String entfernen Allgemeine Java-Themen 10
L Mittels Streams aus Strings A B C den String A, B und C machen Allgemeine Java-Themen 12
M Programm erkennt String aus .txt Datei nicht Allgemeine Java-Themen 3
S Ini Text aus String parsen Allgemeine Java-Themen 1
T String-Manipulation beim Ablauf in Eclipse und als JAR-File Allgemeine Java-Themen 8
M String lässt sich nicht Zusammenfügen Allgemeine Java-Themen 10
Drachenbauer Wie kann ich das Wort "concrete" in einem String durch ein anderes Wort ersetzen lassen? Allgemeine Java-Themen 5
R Schlüsselworte "Throw new exception" gibt nicht den String als Fehlermeldung aus Allgemeine Java-Themen 2
R Variablen String mit split-Funktion aufteilen Allgemeine Java-Themen 7
F Datei in String-Array einlesen Allgemeine Java-Themen 8
S Marker aus String ermitteln Allgemeine Java-Themen 5
T Objekt mit String und Int aus TxT Datei erstellen Allgemeine Java-Themen 23
M Bei String.format ein Komma statt einem Punkt ausgeben lassen Allgemeine Java-Themen 1
S MSSQL Exception & Connection String Allgemeine Java-Themen 19
B Bei Email: FW / AW... - Hilfe bei String suche Allgemeine Java-Themen 21
J String - Vergleiche Allgemeine Java-Themen 7
K Aus String zwei Jahreszahlen auslesen Allgemeine Java-Themen 18
Drachenbauer Wie kann eine vorgegebene Farbe über einen String erkannt werden? Allgemeine Java-Themen 11
G CSV in String Allgemeine Java-Themen 7
P String-Verschlüsselung - Frage zur Sicherheit Allgemeine Java-Themen 21
K Methodenaufruf mit String / String zu Objekt konvertieren Allgemeine Java-Themen 8
D Erste Schritte Fehler mit negativen und 0 Zahlen im String Allgemeine Java-Themen 6
Xge Replace x Zeichen aus String Allgemeine Java-Themen 2
coolian warum bekomme ich ein string index out of bounds exception Allgemeine Java-Themen 17
F In String 2 Buchstaben vertauschen Allgemeine Java-Themen 2
J Class Decompile als String (Procyon) Allgemeine Java-Themen 2
I Datentypen String in class sicher verwahren Allgemeine Java-Themen 17
J Falls der String ein "X" beinhaltet Allgemeine Java-Themen 2
T String mehrere Worte Allgemeine Java-Themen 2
D String Groß-/Kleinschreibung Allgemeine Java-Themen 2
D String und Klassenvariable Allgemeine Java-Themen 6
Aruetiise Funktion(y = mx+n) in String speichern und berechnen Allgemeine Java-Themen 9
C String in Objektnamen umwandeln Allgemeine Java-Themen 3
E Variablen Aus .txt ausgelesener string mit if() überprüfen? Allgemeine Java-Themen 2
L String-Schema-Aufspaltung Allgemeine Java-Themen 2
E String in Zahl umwandeln, ohne Befehl Integer.parseInt Allgemeine Java-Themen 3
L String splitten und multiplizeren Allgemeine Java-Themen 10
G String mit umbekannter länge splitten. Allgemeine Java-Themen 2
S Einzigartigen String in Datenbank finden und löschen Allgemeine Java-Themen 23
A Byte zu String Allgemeine Java-Themen 4
B Von String zu <Objekt> ||Speichern/Laden Allgemeine Java-Themen 17
T Komplexitätsoptimierung String vergleich Allgemeine Java-Themen 4
heinz ketchup String im JLabel ausgeben und erneuern Allgemeine Java-Themen 6
S Input/Output Beste Möglichkeit einen String in einen Datei zu Schreiben Allgemeine Java-Themen 2
V Eingegeben String Splitten und in Integer umwandeln Allgemeine Java-Themen 2
L Decrypt String Allgemeine Java-Themen 1
X Variablen AtmicLong größer als String ? Allgemeine Java-Themen 4
S String literal und Referenzvariablen Allgemeine Java-Themen 6
J Datentypen Absätze mit String im Word Dokument Allgemeine Java-Themen 3
D "Paste" String doppelt Allgemeine Java-Themen 14
E String Frage Allgemeine Java-Themen 9
T String aus While Schleife für ganze Klasse sichtbar machen Allgemeine Java-Themen 5
D JSON to String Allgemeine Java-Themen 31
M String automatisch in nächste Zeile umbrechen (Graphics) Allgemeine Java-Themen 6
U Methoden Algorithmus MergeSort String [ ] array sortieren programmieren Allgemeine Java-Themen 17
T Swing Font String Pixellänge Allgemeine Java-Themen 1
G Substrings in einen String zusammenfassen Allgemeine Java-Themen 5
Tommy Nightmare String.replaceAll(...) fehlerhaft? Allgemeine Java-Themen 3
L String auf zahlenwert prüfen Allgemeine Java-Themen 13
U OOP Warum kann ich aus meiner Methode keinen String auslesen Allgemeine Java-Themen 4

Ähnliche Java Themen


Oben