Unterschiedliche Werte bei return/print

rosima26

Aktives Mitglied
Moin, ich habe eine Methode geschrieben, soweit auch alles perfekt allerdings möchte ich einen bestimmten Wert am Ende returnen, nur kommt da völliger Quatsch raus. Wenn ich das printe dann passt alles aber ausgeben tut er immer die Anzahl an characters die ich ihm übergebe... Völlig egal was ich returne. Sollte für jemandem mit Blick dafür nicht allzu komliziert sein.
Vielen Dank und VG
Java:
public int suche(char[] text) throws Exception {

        // String pattern = "(ab)*k?d";
        int status = 1;
        int c = 0;
        int StVrk = 1;
        boolean arraycontainsd = false;

        for (int j = 0; j < text.length; j++) {
            if (text[j] == 'd')
                arraycontainsd = true;
        }

        if (arraycontainsd == false)
            throw new IllegalArgumentException("d ist nicht im Muster enthalten !");

        for (int ind = 0; status != 3; ind++) {
            c++;

            if (status == 1) {
                if (text[ind] == 'd')
                    status = 3;
                else if (text[ind] == 'a')
                    status = 2;
                else if ((text[ind] == 'b' || (text[ind] == 'c')))
                    status = 1;

            }

            else if (status == 2) {
                if (text[ind] == 'd')
                    status = 3;
                else if (text[ind] == 'b' || text[ind] == 'c')
                    status = 1;
                else if (text[ind] == 'a')
                    status = 2;
                else
                    status = 1;
            }
        }

        System.out.println(c);
        if ((c == 2 || c == 3) && text[c - 2] == 'c') {
            StVrk = 2;
            System.out.println("Checkpoint0");
        } else if (c == 3 && text[c - 2] == 'b' && text[c - 3] == 'a')
            StVrk = 3;
        else if (c == 4 && text[c - 2] == 'c' && text[c - 3] == 'b' && text[c - 4] == 'a')
            StVrk = 4;

        else if (text[c - 2] == 'c') {
            StVrk++;

            System.out.println("Checkpoint");
            if (text[c - 4] == 'a' && text[c - 3] == 'b') {

                for (int i = c - 5; (text[i] == 'b' || text[i] == 'a') && i > 0; i -= 1) {

                    if (text[i] == 'b' && text[i - 1] == 'a') {
                        StVrk += 2;

                    }

                }

            }

        } else if (text[c - 2] == 'b' && text[c - 3] == 'a') {
            StVrk += 2;
            if (text[c - 4] == 'b' && text[c - 5] == 'a') {

                for (int i = c - 4; (text[i] == 'b' || text[i] == 'a') && i > 0; i -= 1) {
                    if (text[i] == 'b' && text[i - 1] == 'a')
                        StVrk += 2;
                }
            }

        }

        
        return 0;
        

    }
    

}
 

rosima26

Aktives Mitglied
Edit: Nevermind, bin völlig übermüdet und hatte Zeile 42 übersehen und vergessen die Funktion in der Main zu printen.
Kann man also löschen hier, ist ja peinlich. Saß an diesem Fehler jetzt ne Stunde dran und hat mich fast in die irre getrieben 😁
 

berndoa

Top Contributor
Nur so aus Interesse:
Was tut die Methode eigentlich?
Wirkt ja recht komplex mit den 3 verschiedenen Statusen und entsprechenden Statuswechseln bei verschiedenen Buchstaben
 

rosima26

Aktives Mitglied
Ging um einen endlichen Automaten der ein Muster im Text finden soll. Darauf basierend sollte berechnet werden, nach wievielen Zeichen im Text das Muster beginnt. @mihe7 gab noch ein paar Vorgaben
 

KonradN

Super-Moderator
Mitarbeiter
Also wenn Du das Pattern per Automat finden sollst: Dann ist Deine Lösung schlicht falsch.

Du machst die eigentliche Erkennung ganz ohne Automat. Der Automat, den Du im Code hast, ist einfach nur Unsinn was die Lösung angeht.
a) Die erste Schleife kann ja direkt die Position von d speichern statt nur, ob es ein d gab. Und damit hättest Du alles, was dein Automat macht!
b) damit ist Dein Automat auch schlicht viel zu kompliziert denn das geht mit deutlich weniger Prüfungen und nur zwei Stati - der "Suche nach d" und deinem Status 3 "d gefunden".

Sarkasmus ein
Wieso machst Du nicht einfach einen Automat, der einfach nur 3 Stati hat. Einen Start Status. Der ruft dann einfach nur ein findePattern() auf und abhängig von der Rückgabe wechselt er dann in den Fehler Status oder den Erfolg Status. Dann hättest Du auch einen Automaten (natürlich ohne die Aufgabe in den Augen des Prof. / Dozenten / Lehrers gelöst zu haben).
Sarkasmus aus

Die Aufgabe soll ja sein, einen Automaten zu entwickeln, der das Pattern rein über Statusübergänge findet.

So als kleine Anregung:
Vom Startpunkt aus: Was für Fälle kann es geben?
a gefunden mit a als Start des Pattern
k gefunden mit k als Start des Pattern
d gefunden mit d als Start des Pattern.
Irgend etwas anderes gefunden, kein Pattern.
Ende des Strings erreicht -> Endstatus "Kein Pattern im Sting gefunden"

Von "a Start des Pattern" aus kann es zu "b im Pattern" gehen. Oder das a war kein Pattern-Start - k als Start und d als Start gehen hier aber.
"b im Pattern": Was ist hier möglich? a, k, d gehen alle als Fortführung des Pattern.
u.s.w.

Also wirklich einen Automaten aufbauen!

Und dann kannst Du Dir überlegen, was der Automat so braucht an Variablen. Die aktuelle Position des Zeichens um Zeichen für Zeichen zu verarbeiten und den Startpunkt des Pattern.

Dann hast Du einen ganz einfachen aufbau:
a) Es wird der StartDesPattern (ggf) umgesetzt.
b) es folgt ein switch auf das nächste Zeichen mit den Statusübergängen.

Und benenne die Stati richtig. Können ja Zahlen sein, aber dann setzt Konstanten so dass Du den Überblick behalten kannst. Dann ist der Status hat A_GEFUNDEN_START_PATTERN - was den möglichen Anfang des Pattern ermöglicht.

Und du kannst auch alles aufteilen in Methoden. Du hast also Methoden für jeden Status, also sowas wie doAInPattern() und Du hast dann eine Methode die dann den Automaten steuert a.la.:

Java:
switch (status) {
    case: A_GEFUNDEN_START_PATTERN: doAInPattern(); break;
    case: ....
    default:
}
(Oder Du machst das gleich in eine Map was es deutlich vereinfacht. Oder eine Enum könnte auch interessant sein....)

Edit: Sarkasmus-Bemerkungen hinzu gefügt. Das wäre ein gültiger Automat, der die Aufgabe löst, aber den Hinweis zu der Lösung habe ich natürlich erst danach geschrieben.

Und evtl. ist es sogar deutlich einfacher:
  • Erst im Automat bis zum d gehen
  • dann rückwärts zum Anfang des Pattern

Dann hat man deutlich weniger Stati-Übergänge. Das liegt einfach daran, dass ein dk?(ba)* einfacher zu erkennen ist. Ist also wirklich Abhängig zu genau diesem Pattern und nichts allgemeines.
 
Zuletzt bearbeitet:

MarvinsDepression

Bekanntes Mitglied
Die "Endliche Maschine" kannte ich ja bisher nur vom Hörensagen. Jetzt habe ich mal ein bischen an der Oberfläche der Materie gekratzt und mir die Worte des Vorredners zu Herzen genommen (zumindest hab ich es versucht). Der Entstandene Code ist in Anbetracht der eigentlichen Problemstellung doch sehr aufgeblasen und allein deswegen leider nicht so übersichtlich, wie ich es erhofft habe.
Meine Frage ist aber: Habe ich überhaupt aus informatischer Sicht das Konzept einer Endlichen Maschine umgesetzt?

Java:
public class FiniteStateMachine {
    
    private final char[] text;
    private int startIndex, patternLength;
    private State state;
    
    private enum State {
        START (1, 1),
        ONE   (2, 3),
        TWO   (1, 0),
        THREE (4, 4),
        FOUR  (5, 0),
        END   (5, 5);
        
        final int branchTrue, branchFalse;
        
        private State (int t, int f) {
            branchTrue = t;
            branchFalse = f;
        }
        
        private static State get(int i) {
            if (i < 0) {
                i = 0;
            }
            if (i >= State.values().length) {
                i = State.values().length - 1;
            }
            return State.values()[i];
        }
    }
    
    public FiniteStateMachine(String str) {
        text = str.toCharArray();
        state = State.START;
    }
    // (ab)*c&d
    public String search() {
        int index = 0;
        while (index < text.length) {
            if (switch(state) {
                case START -> acceptor_Start();
                case ONE ->   acceptor_One(index);
                case TWO ->   acceptor_Two(index);
                case THREE -> acceptor_Three(index);
                case FOUR ->  acceptor_Four(index);
                case END ->   acceptor_End();
            } ) {
                index++;
            }
            if (state.equals(State.END) && patternLength == 0) {
                patternLength = index - startIndex;
            }
        }
        return (patternLength > 0) ? String.valueOf(text, startIndex, patternLength) : "";
    }
    
    private boolean acceptor_Start() {
        state = State.get(state.branchTrue);
        
        if (startIndex == -1) return true;
        startIndex = -1;
        return false;
    }
    // (a..
    private boolean acceptor_One(int i) {
        if (text[i] == 'a') {
            startIndex = (startIndex < 0) ? i : startIndex;
            state = State.get(state.branchTrue);
            return true;
        }
        state = State.get(state.branchFalse);
        return false;
    }
    // ..b)*
    private boolean acceptor_Two(int i) {
        if (text[i] == 'b') {
            state = State.get(state.branchTrue);
            return true;
        }
        state = State.get(state.branchFalse);
        return false;
    }
    // c&
    private boolean acceptor_Three(int i) {
        if (text[i] == 'c') {
            startIndex = (startIndex < 0) ? i : startIndex;
            state = State.get(state.branchTrue);
            return true;
        }
        state = State.get(state.branchFalse);
        return false;
    }
    // d
    private boolean acceptor_Four(int i) {
        if (text[i] == 'd') {
            startIndex = (startIndex < 0) ? i : startIndex;
            state = State.get(state.branchTrue);
            return true;
        }
        state = State.get(state.branchFalse);
        return false;
    }
    
    private boolean acceptor_End() {
        state = State.get(state.branchTrue);
        return true;
    }
    
    
    public static void main(String[] args) {
        String[] testStrings = {"--------babcdddd",
            "----acd--------",
            "----abcab------",
            "d---cd---",
            "-------------ab",
            "------------cd",
            "------ababab"};
        
        for (var text : testStrings) {
            System.out.println("in \""+ text +"\" found \""
                    + new FiniteStateMachine(text).search() +"\"");
        }
    }
}
 

KonradN

Super-Moderator
Mitarbeiter
Aus meiner Sicht sieht das zumindest deutlich besser aus.

Ich finde den Ansatz interessant, dass Du nicht immer den Index versetzt sondern nur bei Erfolg (Und so habe ich jetzt auf den ersten Blick deinen Code verstanden). Das kann die Regeln in den Stati vereinfachen weil Du nur Stati für jede Position brauchst. Das ist recht geschickt finde ich.

Den index hätte ich aber auch bei der Lösung eher in dem jeweiligen Status gehalten da ich das als Logik in der Bearbeitung des Status sehen würde. (Aber das ist nur eine Anmerkung - ob das besser würde / der Code lesbarer habe ich nicht einmal ausprobiert!)

Dass search am Anfang patternLength nicht auf 0 setzt ist mir aufgefallen, aber das ist bei Deinem Code egal. Die search Methode ist die einzige Methode, die den Wert setzt und die Klasse ist nicht veränderbar. Das funktioniert so also einwandfrei. Die Gefahr wäre hier also nur, dass str ggf. ein Setter bekommen könnte in der Zukunft und dann wird evtl. in der Schleife der Endzustand nicht erreicht und patternLength hat einen alten Wert von einem früheren Durchlauf bei einem anderen str Inhalt. Also reines Clean Code denken.

Und zuletzt sehe ich etwas, dass es nicht immer einen Endzustand gibt. Wenn Du beim durchlaufen durch die Zeichen END nicht erreichst, dann ist patternLength== 0 und damit kommt das Ergebnis raus. Aber Ich selbst würde hier bei einer State Machine immer einen END Zustand erwarten - der halt auch sein kann: "Pattern nicht gefunden". Hier ist aber anzumerken, dass ich das vor ca. 25 Jahren in der Uni hatte und ob ich mich hier richtig erinnere kann ich nicht einmal sagen. Daher (so wie die anderen Punkte auch) alles nur als Anregung ansehen. Denn es kann durchaus sein, dass es legitim ist zu sagen: "Eingabe wurde verarbeitet ohne in einen Endzustand zu kommen". Aber das wirst Du evtl. jetzt besser beurteilen können (Oder jemand mit mehr Nähe zu der Thematik kein Einspringen. @httpdigest? @mihe7 @mrBrown - Evtl. wollt Ihr diesen Punkt berichtigen oder einfach eure Sicht kurz nennen?

Das wären so meine Anmerkungen zu dem Code. Sind jetzt aber halt nur einfache Anmerkungen. Und die Frage bezüglich Endlicher Maschine würde ich mit "Ja" beantworten.
 

MarvinsDepression

Bekanntes Mitglied
Danke für die Ausführliche Antwort. Tatsächlich ist mir das auch aufgefallen, dass der END-Zustand nicht zwingend erreicht wird, wenn der String fertig durchforstet wurde. Das beeiflusst zwar nicht das Resultat, entspricht aber auch nicht den Gesetzen einer Endlichen Maschine. Um dies zu erreichen müsste ich aber zwischen jeden Acceptor einen weiteren setzen, der überprüft, ob das Stringende erreicht wurde um dan ensprechend nach END zu verzweigen. Oder geht das auch anders. Darf ein Acceptor ggf. auch mehrfach verzweigen?

patternLength hatte ich ursprünglich auch in END bestimmen wollen, aber wegen obiger Thematik hat das dann eben nicht funktioniert, wenn das einzige 'd' am Stringende stand. Den Gedanken, einfach den String mit einem TerminatorZeichen zu verlängern hatte ich schon, aber ist so etwas üblich?
 

mihe7

Top Contributor
Aber Ich selbst würde hier bei einer State Machine immer einen END Zustand erwarten - der halt auch sein kann: "Pattern nicht gefunden".
@KonradN, ich hab zum Thema auch keine besondere Nähe :) Allerdings hat der Automat i. d. R. ja nur akzeptierende Endzustände und Wikipedia meint: "Endet der Automat nach dem Lesen eines Eingabewortes in einem nicht-akzeptierenden Zustand, gilt die Eingabe als verworfen."
 

mihe7

Top Contributor
Der Code in #8 geht ja schon eher in eine objektorientierte Umsetzung, ich hätte das ganz poplig prozedural gemacht:
Java:
public class Test {   
    private static final int OUTSIDE_PATTERN = 0;
    private static final int A_SEEN = 1;
    private static final int B_SEEN = 2;
    private static final int C_SEEN = 3;
    private static final int PATTERN_FOUND = 4;

    public int find(char[] text) {
        int patternStart = 0;
        int i = 0;
        int state = OUTSIDE_PATTERN;
        while (i < text.length && state != PATTERN_FOUND) {
            char ch = text[i];
            switch (state) {
                case OUTSIDE_PATTERN:
                    patternStart = i;
                    switch (ch) {
                        case 'a': state = A_SEEN; break;
                        case 'c': state = C_SEEN; break;
                        case 'd': state = PATTERN_FOUND; break;
                        default: break;
                    }
                    break;
                case A_SEEN:
                    switch (ch) {
                        case 'a': patternStart = i; state = A_SEEN; break;
                        case 'b': state = B_SEEN; break;
                        case 'c': patternStart = i; state = C_SEEN; break;
                        case 'd': patternStart = i; state = PATTERN_FOUND; break;
                        default: state = OUTSIDE_PATTERN;
                    }
                    break;
                case B_SEEN:
                    switch (ch) {
                        case 'a': state = A_SEEN; break;
                        case 'c': state = C_SEEN; break;
                        case 'd': state = PATTERN_FOUND; break;
                        default: state = OUTSIDE_PATTERN;
                    }
                    break;
                case C_SEEN:
                    switch (ch) {
                        case 'a': patternStart = i; state = A_SEEN; break;
                        case 'c': patternStart = i; state = C_SEEN; break;
                        case 'd': state = PATTERN_FOUND; break;
                        default: state = OUTSIDE_PATTERN;
                    }
                    break;
                default:
                    throw new IllegalStateException("Unknown state " + state);
            }
            i++;
        }
        // Laenge des Patterns waere einfach (i - patternStart)
        return state == PATTERN_FOUND ? patternStart : -1;
    }
}

Hier kann man natürlich noch ein wenig Refactoring betreiben.
 

berndoa

Top Contributor
Ich werfe mal kurz meine Gedanken rein, ohne jetzt zwingend jeden der vorherigen Kommentare voll verstanden zu haben:
Es geht, wie sich nahc Langem nun rausgestellt hat, um ganz simple endliche Automaten, oder?
Solche wie die, wo man so ein schönes Diagramm zeichnet mit Anfangszustand, Endzustand (zuständen?), Zwischenzustände als Knoten,
und übergänge von Knoten zu Knoten abhängig vom gerad gelesenen zeichen.
Um sowas gehts, oder?

Dann musst du doch eigentlich nur die Übergangsfunktion in Code giessen innerhalb einer Automatenklasse oder so.

Wie ich es vielleicht gemacht hätte:


PHP:
public class Automat{
    int zustand;
    int startzustand;
    int endzustand;
    
    //Konstruktor, startzustand und endzustand hardgecodet
    public Automat(){
        startzustand=1;
        endzustand=5;
    }
    
    
    public void uebergangsfunktion(char buchstabe){
        //
        if(zustand==1&&buchstabe.equals('b'){zustand=1;}
        //etc.
        //ggbfls. auch mit switch case irgendwie möglich
    }
    
    //prüft ob Wort von Automat akzeptiert wird
    //akzeptiert nur wenn der endzustand erst erreicht ist
    //nachdem alle Buchstaben verwertet wurden
    public boolean wortpruefen(String wort){
        for(char c: wort.toCharArray()){
            if(zustand==endzustand){return false;}
            uebergangsfunktion(c);
        }
        if(zustand==endzustand){return true;}
        
    }


}

Halt ein hardgecodeter Automat, der ein Wort einlesen kann und ein tur oder fals zurückgibt, je nachdem ob das Wort vom Automaten akzeptiert wird

Vermutlich kann man den Automaten auch so bauen dass man eine neue Übergangsfunktion reinbauen kann, die die alte überschreibt.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
P Static Variable -> unterschiedliche Werte? Allgemeine Java-Themen 1
OnDemand Unterschiedliche jar Dateien zusammen führen Allgemeine Java-Themen 8
M Warum gibt es Unterschiedliche Kommentar Zeichen Allgemeine Java-Themen 15
Y Java Methoden unterschiedliche Zahlenreihen Allgemeine Java-Themen 2
P Berechnungen: unterschiedliche Rundungsfehler bei Long? Allgemeine Java-Themen 3
M Zwei unterschiedliche JAR Dateien mit ANT erstellen Allgemeine Java-Themen 8
J unterschiedliche Dateiformate verarbeiten Allgemeine Java-Themen 7
J unterschiedliche Objekte, selbe getter und setter Allgemeine Java-Themen 15
G Methoden Unterschiedliche viele Parameter Allgemeine Java-Themen 17
A TXT File einlesen unterschiedliche Zeilenlänge Allgemeine Java-Themen 9
P Unterschiedliche Clone- Methoden Allgemeine Java-Themen 5
GianaSisters Klassen Unterschiedliche Zeiten bei DATE Allgemeine Java-Themen 6
G Input/Output URLDecoder.decode - Unterschiedliche Ergebnisse Windows / Linux Allgemeine Java-Themen 2
A md5 liefert unterschiedliche Testsummen? Allgemeine Java-Themen 4
M Unterschiedliche Java-Versionen Allgemeine Java-Themen 5
B hashtable für unterschiedliche Typen - mit Generics Allgemeine Java-Themen 8
S Zugriff auf unterschiedliche JREs Allgemeine Java-Themen 7
G Abstrakte Fabrik für unterschiedliche Signaturen? Allgemeine Java-Themen 7
L unterschiedliche Größe beim serialisieren eines Objektes! Allgemeine Java-Themen 6
W Unvollständige und unterschiedliche CharSets Allgemeine Java-Themen 3
L Unterschiedliche mails (Daten aus JTable) schicken Allgemeine Java-Themen 14
U Transparent Buttons - unterschiedliche Java-Versionen Allgemeine Java-Themen 8
M unterschiedliche Betriebssysteme abfangen Allgemeine Java-Themen 3
O Werte einer Generic LinkedList zusammenrechenen Allgemeine Java-Themen 14
C In DefaultTableModel nachträglich Werte einfügen Allgemeine Java-Themen 2
berserkerdq2 Kann man in IJVM maximal 3 Werte im Stack haben? Allgemeine Java-Themen 3
OnDemand RegEx /compilebekomme nicht die erwarteten Werte Allgemeine Java-Themen 9
MiMa Werte in liste speichern? Allgemeine Java-Themen 3
Drachenbauer Wie kann ich einer existierenden Enum von außerhalb veränderte Werte zuweisen? Allgemeine Java-Themen 5
Arif Math.cos liefert komische Werte Allgemeine Java-Themen 8
X Größten Werte in meinem Array löschen? Allgemeine Java-Themen 16
D Erste Schritte Im Array Werte tauschen Allgemeine Java-Themen 5
J int Werte in einer anderen Klasse in Arrays speichern Allgemeine Java-Themen 3
B Übernommene Variablen(werte) aus der Main-Klasse ändern? Allgemeine Java-Themen 9
Henrithebegiinerofjava Erste Schritte Werte in Eingabefelder einlesen und wiederholen lassen. Allgemeine Java-Themen 3
I Java: public final Werte: Gute oder schlechte Praxis? Allgemeine Java-Themen 6
S Algorithmus welcher True-Werte in einem Array findet und auswertet. Allgemeine Java-Themen 5
J Swing UIManager Werte Allgemeine Java-Themen 6
4 Java 2 ArrayListen Werte herauslesen/übernehmen Allgemeine Java-Themen 4
F Enum-werte als Methoden-Parameter übergeben Allgemeine Java-Themen 6
KeVoZ_ int Werte in einen String fassen Allgemeine Java-Themen 4
N Werte aus Hashmap auslesen und übertragen Allgemeine Java-Themen 8
2 mehrere Json Werte Parsen Allgemeine Java-Themen 3
R jTable, nur Werte zwischen 2 Double values ausgeben Allgemeine Java-Themen 3
B Übergebene Werte in Gerätedatei schreiben Allgemeine Java-Themen 2
M Exceltabelle in Java erstellen und Werte einlesen Allgemeine Java-Themen 32
N Werte aus Arrays auslesen funktioniert nicht Allgemeine Java-Themen 5
R Int werte vergleichen und Anzahl Paare ausgeben Allgemeine Java-Themen 4
O Klassen Programm in Klassen unterteilt, werte werden nicht mehr übernommen Allgemeine Java-Themen 3
R kann man irgendwie mit Arrays mit Eingabefenstern und Schleifen Werte abklappern? Allgemeine Java-Themen 2
L Windows CMD werte Parsen. Allgemeine Java-Themen 2
M Werte aus DB in Liste speichern ohne mehrfach speicherung Allgemeine Java-Themen 18
K Methoden Arrays auf true Werte prüfen Allgemeine Java-Themen 4
R Variablen per HSSF geheime Werte von JAVA an EXCEL Allgemeine Java-Themen 2
ARadauer Checksumme über BigDecimal Werte Allgemeine Java-Themen 11
C Datentypen Enum-Werte Bestanteil von anderem Enum Allgemeine Java-Themen 8
Q GregorianCalendar Methode add liefert komische Werte Allgemeine Java-Themen 3
BRoll Image RGB Werte auslesen und vergleichen Allgemeine Java-Themen 8
Madlip Variablen 3 Werte aus ArrayList und weiter ... Allgemeine Java-Themen 4
M Aus Excel Tabelle lesen und Werte in Array speichern Allgemeine Java-Themen 15
A String Array Werte in neues String Array übernehmen Allgemeine Java-Themen 5
S OOP Objekte als Return-Werte: Einen Klon zurückgeben oder Instanz auf das Feld? Allgemeine Java-Themen 10
R Zusammenhängende Werte in 2-dim. Array finden und zählen Allgemeine Java-Themen 3
S Sinnvolles skalieren von Werte-Set? Allgemeine Java-Themen 2
S Keytool: mögliche Werte für Parameter Allgemeine Java-Themen 4
P Werte in Array zählen und Summe der einzelnen Teile ausgeben Allgemeine Java-Themen 10
L Veränderbare Werte zusammenfassen Allgemeine Java-Themen 18
P Variablen Werte der Objektvariablen mit getFields() abfragen Allgemeine Java-Themen 2
O Variablen System.getenv: Sinnlose Werte, Arrays?! Allgemeine Java-Themen 6
J JSONObject Reihenfolge der Werte? Allgemeine Java-Themen 4
T java.uil.Random liefert negative Werte Allgemeine Java-Themen 2
c_sidi90 Werte an bestimmten Position aus PDF in DB sichern Allgemeine Java-Themen 2
C Vergleich von Enums gibt inkorrekte Werte Allgemeine Java-Themen 6
T Array Sortieren (null Werte ans Ende) Allgemeine Java-Themen 2
S Werte aus 2 eindimensionale boolean arrays mithilfe von logischen operatoren berechnen Allgemeine Java-Themen 6
C aus einem String einzelne Hex Werte lesen Allgemeine Java-Themen 7
P JFormattedTextField für durch Semikolon getrennte Integer-Werte gesucht / Regulärer Ausdruck Allgemeine Java-Themen 3
M rxtx OutputStream sendet falsche werte Allgemeine Java-Themen 3
J Hex Werte in Bitmap Raster darstellen Allgemeine Java-Themen 16
E Werte übergabe Allgemeine Java-Themen 2
E Werte in andere Klasse übernehmen Allgemeine Java-Themen 8
S Bytes oder Hex-Werte zu Assembler Code? Allgemeine Java-Themen 6
D Mehrere String-Werte in eine Tabellen-Zelle schreiben Allgemeine Java-Themen 8
P Methoden und Werte Allgemeine Java-Themen 17
M Kugelschnittberechnung liefert falsche Werte Allgemeine Java-Themen 4
N unzählige Werte am besten speichern(?) Allgemeine Java-Themen 2
D Spielerwechsel über boolsche Werte läuft inkorrekt Allgemeine Java-Themen 6
MonsterBit 2 Werte aus 2 Array vergleichen Allgemeine Java-Themen 10
T Apache POI Export EXCEL - [Zahlen-Werte] Allgemeine Java-Themen 1
S Doppelte Werte in Listen,Vectoren etc suchen Allgemeine Java-Themen 2
Airwolf89 Zugriff auf Werte in ArrayList<ArrayList> Allgemeine Java-Themen 4
H Prüfen, ob doppete Werte in int-Array vorhanden sind Allgemeine Java-Themen 16
K Datenhaltungsklasse für wenige Werte? Allgemeine Java-Themen 4
T JProgressbar ändert werte nicht Allgemeine Java-Themen 28
K need help ; Werte aus einer Datei auslesen Allgemeine Java-Themen 4
C Eingegebene Werte werden nicht gezeichnet Allgemeine Java-Themen 2
chik 2 return werte für Greedy-Algorithmus (gelöst) Allgemeine Java-Themen 3
hdi dynamische return-Werte Allgemeine Java-Themen 15
R Double Werte aus byte[] auslesen Allgemeine Java-Themen 5
T Wurfweitenberechnung: X-Werte bei extremen Werten falsch. Allgemeine Java-Themen 15

Ähnliche Java Themen

Neue Themen


Oben