Strings untereinander in einer Liste vergleichen

JavaUndC-Prog

Bekanntes Mitglied
Hallo in die Runde,

ich weiß nicht ob der Titel schon aussagekräftig genug ist, aber ich habe folgendes vor:
Gegeben ist ein String Array oder eine ArrayListe (bei meiner jetzigen Implementierung nutze ich die Liste) und in dieser Liste bzw in dem String Array sind verschiedene Strings gespeichert. Das könnte nun etwa folgendermaßen aussehen:
{"A", "B", "AB", "C", "AC", "ABC"}
Ich hoffe ich kann das sprachlich richtig rüberbringen (mathematisch wäre das eher weniger das Problem, nur sprachlich ist das was ich jetzt sagen möchte vielleicht nicht so exakt). Ich möchte nun die Obermenge dieses String Arrays bzw. dieser Liste ermitteln. Jetzt könnte man ja auf die Idee kommen mit dem Contains Befehl zu Arbeiten für folgendes Beispiel würde das auch funktionieren: "A", "B", "AB", "BC", "ABC". ABC ist dann die gemeinsame Obermenge. Jetzt hatte ich das Beispiel vom Anfang extra so komisch gestellt, denn der Contains Befehl würde im ersten Fallbeispiel "A", "B", "AB", "C", "AC", "ABC", nicht korrekt arbeiten. Siehe hierzu AC und ABC, in der Mengennotation ausgedrückt {A,C}, {A,B,C}, hier erkennt man eigentlich sofort, dass ABC die Obermenge ist. Der Computer erkennt das leider nicht so gut, zumindest mit dem Contains Befehl nicht :)

Was ich nun gerne machen Möchte, ist mir die Obermenge von verschiedenen Eingaben ausgeben zu lassen, OHNE dabei komplexere Programmier-Konstrukte zu verwenden. Ich möchte das Ganze so simpel wie möglich halten. Darum verwende ich auch nur die aller notwendigsten Methoden. Ich habe hier auch schon eine erste Version auf die Beine gestellt, die mir allem Anschein nach zuurteilen auch die richtige Ausgabe liefert. Für die Array Liste habe ich mich entschieden, weil ich mir das an dieser Stelle etwas einfacher machen wollte. Ich würde das aber auch gerne mal mit einem fixen String Array versuchen, wobei ich dann mit Remove ein Problem bekomme.

Ich bin nun gewissermaßen auf der Suche nach einer Code Optimierung meines aktuellen Codes. Wichtig ist mir dabei, dass alles einfach bleibt. Was ich auf jedenfall vermeiden möchte ist, dass nun irgendeine Bibliothek vorgeschlagen wird. Ich möchte also wirklich mit den Java Basics arbeiten und dabei immer noch etwas performantes erzeugen. Ich bin also durchaus an einer Optimierung und einer entsprechenden Implementierung unter Verwendung eines String Arrays oder einer Liste interessiert (Die Listenimplementierung (siehe aktuellen Code), habe ich verwendet, da ich hier den netten remove Befehl verwenden konnte. Mit einem String Array ist das vllt. schwerer (aber es interessiert mich)).

Hier einmal meine ersten Gehversuche:

Java:
import java.util.ArrayList;

public class TestKlasse {

    public static void main(String[] args) {
        String[] str1 = {"D","B","BC","CB","C","AB","AC","ABC"};

       
        ArrayList<String> ls = new ArrayList<String>();
        for(int i = 0; i < str1.length; i++) {
            ls.add(str1[i]);
        }
       
        Tester(ls);
       
        for(int i=0; i<ls.size(); i++) {
            System.out.println(ls.get(i));
        }
       

    }

    public static void Tester(ArrayList<String> ls) {
        int vglAnzahl = 0;
        for(int i = 0; i < ls.size(); i++) {
            for(int j = 0; j < ls.size(); j++) {
                if(i != j) {
                    for(int k = 0; k < ls.get(i).length(); k++) {
                        for(int l = 0; l < ls.get(j).length(); l++) {
                            if(ls.get(i).charAt(k) == ls.get(j).charAt(l)) {
                                System.out.println("Char gleich...");
                                vglAnzahl++;
                                if(vglAnzahl == ls.get(j).length()) {
                                    System.out.println("Empfehlung : " + ls.get(j) + " löschen");
                                    ls.remove(j);
                                    vglAnzahl = 0;
                                    l = 0;
                                    k = 0;
                                    i = 0;
                                    j = 0;
                                }
                            }
                        }
                       
                    }
                }
                vglAnzahl = 0;
            }
        }
    }
}


Ich würde mich sehr über eure Meinungen und Ansätze/Verbesserungen/Optimierungen freuen und freue mich jetzt erstmal auf mögliche Antworten. Ich hoffe auch, es ist einigermaßen verständlich was ich überhaupt vorhabe, falls nicht, kann ich das auch gerne noch etwas präzisieren. Ich bedanke mich erstmal bis hierhin!
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Vielleicht doch eher mathematisch: Du hast Mengen M1, ..., Mn und Du möchtest jetzt wissen, ob und wenn ja welches i (1<=i<=n) die Vereinigung aller Mengen ist?
 

JavaUndC-Prog

Bekanntes Mitglied
Ja das Könnte es schon treffen :)

Vielleicht mit Bezug zum Beispiel:
{{D},{B},{BC},{CB},{C},{AB},{AC},{ABC}}, hierbei müsste ich dann folgende Ausgabe erwarten {D},{ABC}
 

JavaUndC-Prog

Bekanntes Mitglied
Die Menge {A,B,C,D} ist die Obermenge, das würde ich erwarten. Vielleicht sollte ich erwähnen, dass ich ABCD als einzelne Elemente in der Menge sehe also {A,B,C,D}
 

JavaUndC-Prog

Bekanntes Mitglied
Also ich versuche zu jeder Menge die in der Grundmenge enthalten ist eine Obermenge zu finden, gibt es keine Obermenge, dann gebe ich eine Teillösung aus:

Sagen wir ich habe verschiedene Mengen in X, so in etwa X={{D}, {A,B}, {A,B,C}} die Obermenge von {D} und {A,B} existiert nicht, daher belasse ich {D} und {A,B} in der Menge X. Jetzt teste ich, ob es eine Obermenge von {A,B}, {A,B,C} gibt. Ja die gibt es das ist folgende: {A,B,C}, weil es diese Obermenge zwischen {A,B} und {A,B,C} gibt, resultiert hier {A,B,C}, sodass nun in X steht: X={{D}, {A,B,C}}
 

httpdigest

Top Contributor
Kommt jetzt drauf an, wie du genau "Obermenge" definierst. Die Obermenge von {A, B} und {C, D} kann genausogut auch {A, B, C, D} sein. Was du meinst, würde ich nicht als "Obermenge" bezeichnen. Bei dir ist eine Menge eine "Obermenge", wenn die Schnittmenge der Mengen, deren Obermenge sie ist, nicht leer ist.
 

httpdigest

Top Contributor
Java:
import static java.util.stream.Collectors.toSet;
import static java.util.stream.Stream.of;
import java.util.ArrayList;
import java.util.Set;
import java.util.stream.Stream;
public class Mengen {
  public static Stream<Set<Character>> obermengen(Stream<String> mengen) {
    return mengen.collect(ArrayList<Set<Character>>::new, (r, s) -> {
      Set<Character> sc = s.chars().mapToObj(e -> (char) e).collect(toSet());
      r.stream()
       .filter(e -> e.stream().anyMatch(sc::contains))
       .findFirst()
       .map(set -> set.addAll(sc))
       .orElseGet(() -> r.add(sc));
    }, ArrayList::addAll).stream();
  }
  public static void main(String[] args) {
    obermengen(of("A", "AB", "BC", "D")).forEach(System.out::println);
    // [A, B, C]
    // [D]
  }
}
 

httpdigest

Top Contributor
Okay, dann nochmal ganz formal:
Die Obermenge `O` ist die Vereinigungsmenge jener Mengen `Ms`, so dass für je zwei Mengen `M1` und `M2` in `Ms` gilt: `M1` ist Obermenge von `M2` oder `M2` ist Obermenge von `M1`.
Das käme dann für {A}, {AB}, {BC}, {D} => {AB}, {BC, {D} hin, da weder {A} Obermenge von {BC} ist, noch ist {BC} Obermenge von {A}.

Code nach dieser Definition:
Java:
import static java.util.stream.Collectors.toSet;
import static java.util.stream.Stream.of;
import java.util.ArrayList;
import java.util.Set;
import java.util.stream.Stream;
public class Mengen {
  private static Stream<Set<Character>> obermengen(Stream<String> mengen) {
    return mengen.collect(ArrayList<Set<Character>>::new, (r, s) -> {
      Set<Character> sc = s.chars().mapToObj(e -> (char) e).collect(toSet());
      r.stream()
       .filter(e -> sc.containsAll(e) || e.containsAll(sc))
       .findFirst()
       .map(set -> set.addAll(sc))
       .orElseGet(() -> r.add(sc));
    }, ArrayList::addAll).stream();
  }
  public static void main(String[] args) {
    obermengen(of("A", "AB", "BC", "D")).forEach(System.out::println);
    // [A, B]
    // [B, C]
    // [D]
  }
}
 
Zuletzt bearbeitet:

JavaUndC-Prog

Bekanntes Mitglied
A und B seien Mengen. Ist B eine Teilmenge von A, so ist A eine Obermenge von B. Ich versuche wenn man das so sagen kann gemeinsame Obermengen zu finden. Darum wird X={{D}, {A,B}, {A,B,C}} bei mir zu X={{D}, {A,B,C}} vereinfacht, da die Menge {A,B,C} die Obermenge von {A,B} ist. {D} ist hingegen weder in {A,B} noch in {A,B,C} enthalten, sodass es hier keine (gemeinsame) Obermenge gibt.

Dein Code liefert die richtige Ausgabe! Das würde passen, zumindest nach meiner Auffassung. Nur ich würde gerne recht simpel bleiben wollen, daher habe ich in meinem Code bewusst auf sowas hier:
import static java.util.stream.Collectors.toSet;
import static java.util.stream.Stream.of;
verzichtet. Ich wollte das mit möglichst einfachen Mitteln umsetzen, wobei sich einfach auf Java Basics bezieht. Ich vergeb den Kommentaren hier als Belohnung erstmal ein "Like" für eure Mühe und hoffe natürlich auf weitere Beiträge :)

Aber ist denn meine Idee soweit erstmal verständlich(er) geworden? Auf ein paar (Code)-Anregungen wäre ich sehr gespannt :)
 
Zuletzt bearbeitet:

Blender3D

Top Contributor
Ich wollte das mit möglichst einfachen Mitteln umsetzen, wobei sich einfach auf Java Basics bezieht
Java:
public class start {
    public static void main(String[] args) {
        String sets[] = { "A", "AB", "BC", "D" };
        ArrayList<String> superSets = getSuperSets(sets);
        for (String s : superSets)
            System.out.println("[" + s + "]");
    }

    public static ArrayList<String> getSuperSets(String[] sets) {
        ArrayList<String> supersets = new ArrayList<String>();
        for (String s : sets) // all sets at start
            supersets.add(s);
        for (int i = 0; i < sets.length; i++) {
            for (int testId = 0; testId < sets.length; testId++) {
                if (isSubSet(sets[testId], sets[i])) {
                    supersets.remove(sets[testId]); // remove subset
                    continue;
                }
            }
        }
        return supersets;
    }

    private static boolean isSubSet(String subSet, String superSet) {
        if (superSet.length() <= subSet.length())
            return false;
        for (int i = 0; i < subSet.length(); i++) {
            if (!superSet.contains(subSet.charAt(i) + ""))
                return false;
        }
        return true;
    }
}
 

mihe7

Top Contributor
Java:
public class Mengen {
    private static List<String> obermengen(List<String> mengen) {
        Set<Set<Character>> sets = new HashSet<>();
        for (String s : mengen) {
            Set<Character> menge = zeichen(s);
            boolean neuesElement = true;
            for (Set<Character> set : sets) {
                if (set.containsAll(menge) || menge.containsAll(set)) {
                    set.addAll(menge);
                    neuesElement = false;
                }
            }
            if (neuesElement) {
                sets.add(menge);
            }
        }

        return stringList(sets);
    }

    private static Set<Character> zeichen(String s) {
        Set<Character> result = new HashSet<>();
        for (char ch : s.toCharArray()) {
            result.add(ch);
        }
        return result;
    }

    private static List<String> stringList(Set<Set<Character>> sets) {
        List<String> result = new ArrayList<>();
        for (Set<Character> set : sets) {
            result.add(set.toString());
        }
        return result;
    }

    public static void main(String[] args) {
        obermengen(Arrays.asList("A", "AB", "BC", "D")).forEach(System.out::println);
    }
}
 

JavaUndC-Prog

Bekanntes Mitglied
Guten Morgen,

ich habe beide Programme nochmal mit einem neuen Test Array getestet "D","B","BC","ABC","CB","C","AB","AC","AC","D"

@Blender3D dein Programm gibt hierbei folgendes aus:
[D]
[ABC]
[D]
Es sollten aber "nur" [D] und [ABC] sein, das eine [D] ist zu viel ;-) (Mir gefällt aber die Struktur deines Programms!, wenn du Lust hast könntest du ja noch eine Verbesserung vornehmen, sodass die Ausgabe dann passt)

@mihe7 dein Programm gibt hierbei folgendes aus:
[A, B, C]
[D]
Das ist absolut richtig!

Mein Programm gibt ebenfalls:
[ABC]
[D]
 

Blender3D

Top Contributor
Es sollten aber "nur" [D] und [ABC] sein, das eine [D] ist zu viel ;-) (Mir gefällt aber die Struktur deines Programms!, wenn du Lust hast könntest du ja noch eine Verbesserung vornehmen, sodass die Ausgabe dann passt)
Das hängt davon ab, da ich davon ausging, dass das arrray set keine doppelten Einträge enthält.
Das lässt sich aber sehr einfach beheben, indem du doppelte Eintrage vermeidest. Wenn man bei ArrayList bleibt durch eine Bedingung. Besser wäre statt Arraylist gleich Set zu benutzen.
Java:
public class start {
    public static void main(String[] args) {
        String sets[] = {  "D","B","BC","ABC","CB","C","AB","AC","AC","D"};
        ArrayList<String> superSets = getSuperSets(sets);
        for (String s : superSets)
            System.out.println("[" + s + "]");
    }
    public static ArrayList<String> getSuperSets(String[] sets) {
        ArrayList<String> supersets = new ArrayList<String>();
        for (String s : sets) { // all unique sets at start
            if (!supersets.contains(s))
                supersets.add(s);
        }
        for (int i = 0; i < sets.length; i++) {
            for (int testId = 0; testId < sets.length; testId++) {
                if (isSubSet(sets[testId], sets[i])) {
                    supersets.remove(sets[testId]); // remove subset
                    continue;
                }
            }
        }
        return supersets;
    }
    private static boolean isSubSet(String subSet, String superSet) {
        if (superSet.length() <= subSet.length())
            return false;
        for (int i = 0; i < subSet.length(); i++) {
            if (!superSet.contains(subSet.charAt(i) + ""))
                return false;
        }
        return true;
    }
}
 

Blender3D

Top Contributor
Besser wäre statt Arraylist gleich Set zu benutzen.
Hier die Variante mit einem Set
Java:
public class start {
    public static void main(String[] args) {
        String sets[] = { "D", "B", "BC", "ABC", "CB", "C", "AB", "AC", "AC", "D" };
        Set<String> superSets = getSuperSets(sets);
        for (String s : superSets)
            System.out.println("[" + s + "]");
    }

    public static Set<String> getSuperSets(String[] sets) {
        Set<String> supersets = new HashSet<String>(Arrays.asList(sets));
        for (String s : sets) // all sets unique at start
            supersets.add(s);
        for (int i = 0; i < sets.length; i++) {
            for (int testId = 0; testId < sets.length; testId++) {
                if (isSubSet(sets[testId], sets[i])) {
                    supersets.remove(sets[testId]); // remove subset
                    continue;
                }
            }
        }
        return supersets;
    }

    private static boolean isSubSet(String subSet, String superSet) {
        if (superSet.length() <= subSet.length())
            return false;
        for (int i = 0; i < subSet.length(); i++) {
            if (!superSet.contains(subSet.charAt(i) + ""))
                return false;
        }
        return true;
    }
}
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
R Datentypen Das Verhalten von Strings als Datentypen Java Basics - Anfänger-Themen 7
N Nachkommastellen von Strings Java Basics - Anfänger-Themen 3
T Strings unveränderlich???? Java Basics - Anfänger-Themen 22
B Alle Strings bis zu einer Maimallänge aufzählen, die Bedingung erfüllen Java Basics - Anfänger-Themen 13
S Die durchschnittliche Länge der Strings Java Basics - Anfänger-Themen 11
M Operatoren Strings mit Vergleichsoperatoren, funktioniert das? Java Basics - Anfänger-Themen 9
S Variablen Letzte Zeile eines Strings entfernen Java Basics - Anfänger-Themen 1
D Strings aus Excel-Datei einlesen Java Basics - Anfänger-Themen 2
P9cman Tipps für Rekursive Aufgaben mit Strings oder allgemein Java Basics - Anfänger-Themen 2
sserio StringBuilder und Strings Java Basics - Anfänger-Themen 8
J Größe eines Strings in Pixel Java Basics - Anfänger-Themen 18
schredder Strings und reguläre Ausdrücke - Methode mit return string.matches Java Basics - Anfänger-Themen 5
B Konkatenieren eines Strings und inkremtierenden Zahl zu einer INT Variablen Java Basics - Anfänger-Themen 7
N Strings verpflechten Java Basics - Anfänger-Themen 4
G Strings auf Gleichheit prüfen - Aufgabe vom Prof. Java Basics - Anfänger-Themen 5
A 2 Strings vergleichen in einer methode wenn man mit Globalen variablen arbeitet Java Basics - Anfänger-Themen 12
L Strings aneinanderhängen Java Basics - Anfänger-Themen 2
M Strings vergleichen Java Basics - Anfänger-Themen 10
Nerdinfekt BMI Rechner, fehler beim Zurückgeben des Strings? Java Basics - Anfänger-Themen 2
U Problem mit dem initialisieren meines Strings in einer Schleife Java Basics - Anfänger-Themen 5
S 2 Strings mit Equals vergleichen Java Basics - Anfänger-Themen 11
Q Besitzen zwei Strings identische Buchstaben, nur in anderer Reihenfolge? Java Basics - Anfänger-Themen 10
marcooooo Separator zwischen allen Zeichen eines Strings einfügen Java Basics - Anfänger-Themen 29
C Ternärer Operator mit Strings Java Basics - Anfänger-Themen 3
M Wie kann ich bei int-Variablen im exception handler auf bestimmte Strings reagieren? Java Basics - Anfänger-Themen 5
P Verketten, Aneinanderreihen von Strings Java Basics - Anfänger-Themen 2
M Strings mit gerader und ungerader Länge ausgeben Java Basics - Anfänger-Themen 10
J Alle Werte eines Strings zusammen addieren Java Basics - Anfänger-Themen 15
W Strings und das parsen Java Basics - Anfänger-Themen 8
D Frage zu Strings einer Exception Java Basics - Anfänger-Themen 4
D Vergleichen von Strings Java Basics - Anfänger-Themen 6
M Konkatenation von zwei Strings Java Basics - Anfänger-Themen 6
J Abbruchbedingung in Schleife/ Untersuchung von Strings Java Basics - Anfänger-Themen 2
S Buchstaben in Großbuchstaben (Strings) Java Basics - Anfänger-Themen 5
X Anagramm mit Strings und Methode Java Basics - Anfänger-Themen 53
P geschachtelte Schleife mit Strings Java Basics - Anfänger-Themen 2
P Strings mit der Axt zerteilen Java Basics - Anfänger-Themen 7
F Alle Zeichenkombinationen eines Strings iterativ herausfinden Java Basics - Anfänger-Themen 26
K Strings hochzählen Java Basics - Anfänger-Themen 20
B Frage zu: String... strings -> Ungleiche Anzahl an Parameter? Java Basics - Anfänger-Themen 4
F Vergleiche mit charAt funktioniert bei Strings nicht, was tun? Java Basics - Anfänger-Themen 5
T Probleme mit Strings Java Basics - Anfänger-Themen 6
J Unveränderbarkeit von Strings Java Basics - Anfänger-Themen 3
O Klammerung bei Strings Java Basics - Anfänger-Themen 10
A Liste aus drei Strings erstellen Java Basics - Anfänger-Themen 5
N Zwei Strings mit "==" vergleichen warum TRUE Java Basics - Anfänger-Themen 2
G Teil(e) eines Strings entfernen wenn spezifische Zeichen (< & >) vorkommen Java Basics - Anfänger-Themen 5
D ergebnis.matches("[1-9]?[0-9].[0-9][0-9]?") ein teil eines größeren Strings Java Basics - Anfänger-Themen 12
J Breite eines Strings bestimmen Java Basics - Anfänger-Themen 4
D Zwei Strings sind gleich bei if aber nicht true Java Basics - Anfänger-Themen 2
F JList Elemente mit Strings vergleichen Java Basics - Anfänger-Themen 12
J Strings sind gleich werden aber ungleich ausgewertet Java Basics - Anfänger-Themen 2
N Vergleich von Strings schlägt fehl.. Java Basics - Anfänger-Themen 5
B 4 Strings, Anfangsbuchstaben muss unterschiedlich sein Java Basics - Anfänger-Themen 12
P Strings in String Array schreiben Java Basics - Anfänger-Themen 13
J Input/Output Strings aneinander reihen mit while schleife Java Basics - Anfänger-Themen 25
B mir nur die Gesamtzahl von einzigartigen Strings aus Array ausgeben lassen Java Basics - Anfänger-Themen 5
R Erste Schritte Sicheres einlesen eines Strings Java Basics - Anfänger-Themen 2
F Maximale Länge eines Strings Java Basics - Anfänger-Themen 5
J Best Practice Datum Differenz aus zwei Strings ermitteln Java Basics - Anfänger-Themen 8
Jinnai4 Strings ersetzen Java Basics - Anfänger-Themen 9
R Übergeben eines Array Strings an einen Spinner Java Basics - Anfänger-Themen 4
L Rekursiv zwei Strings vergleichen Java Basics - Anfänger-Themen 3
L Prüfe, ob die im String Array enthaltenen Strings aufsteigend sind. Java Basics - Anfänger-Themen 19
J Algorithmus - Strings auf eigene Reihenfolge miteinander vergleichen Java Basics - Anfänger-Themen 4
DaCrazyJavaExpert Variablen Zahlen aus Strings auslesen Java Basics - Anfänger-Themen 4
C 2 Strings Java Basics - Anfänger-Themen 15
T befehle unterschiedlicher anzahl an strings wiedergeben Java Basics - Anfänger-Themen 2
JavaNewbie2.0 Strings in andere Klassen importieren. Java Basics - Anfänger-Themen 2
D BlueJ Java: Strings voneinander trennen Java Basics - Anfänger-Themen 11
javaerd Wie kann ich Brute Force Methode mit Strings erweitern Java Basics - Anfänger-Themen 1
R Erste Schritte Strings "einrücken" Java Basics - Anfänger-Themen 3
Yamie ArrayList<Object> als Liste von Strings ausgeben? Java Basics - Anfänger-Themen 15
B gemeinsames Vorkommen der charactere von 2 Strings als String zurückgeben Java Basics - Anfänger-Themen 5
R Teilinhalt eines Strings testen Java Basics - Anfänger-Themen 10
H Erste Schritte JTree: Instanzen einer Klasse speichern oder Namen/Strings... Java Basics - Anfänger-Themen 4
L Werte von Strings ? Java Basics - Anfänger-Themen 1
L Strings und Arrays - Expand Java Basics - Anfänger-Themen 12
I Schachbrett aus beliebigen Strings erstellen Java Basics - Anfänger-Themen 3
Syncopated Pandemonium Verketten von Strings funktioniert nicht Java Basics - Anfänger-Themen 4
F Wahrscheinlichkeit von Strings Java Basics - Anfänger-Themen 3
MiMa Splitten eines Strings Java Basics - Anfänger-Themen 5
T Hashfunktion für Strings Java Basics - Anfänger-Themen 3
C Zeilenumbruch für langes Strings Java Basics - Anfänger-Themen 2
J Variablen Strings mit Zeilenumbrüchen in neues Array Element Java Basics - Anfänger-Themen 1
T Datentypen compareTo() u. equals() bei Strings Java Basics - Anfänger-Themen 3
H Strings vergleichen & sortieren Java Basics - Anfänger-Themen 20
H Erste Schritte Längstes Wort eines Strings herausfinden Java Basics - Anfänger-Themen 7
D Problem beim umwandeln eines Strings in eine Dzezimalzahl Java Basics - Anfänger-Themen 6
G Strings mit Scanner (nextLine) einlesen Java Basics - Anfänger-Themen 7
T Strings ersetzen mit \ Java Basics - Anfänger-Themen 10
K Strings bearbeiten Java Basics - Anfänger-Themen 14
N Bestimmte Zeichen eines Strings umwandeln Java Basics - Anfänger-Themen 4
L Java Strings Buchstaben vertauschen Java Basics - Anfänger-Themen 4
L Strings in einem JOptionPane farbig Java Basics - Anfänger-Themen 2
A Wie bekomme ich zwei Strings in eine ArrayList Java Basics - Anfänger-Themen 4
C Chars eines Strings mit for schleife rückwärts auslesen Java Basics - Anfänger-Themen 8
J Buchstabe (char) an zufällige Position eines Strings einfügen Java Basics - Anfänger-Themen 1
hello_autumn Strings ersetzen... Java Basics - Anfänger-Themen 10
B Durch eine Liste von Strings laufen Java Basics - Anfänger-Themen 6

Ähnliche Java Themen

Neue Themen


Oben