ADT Graph nach größe Abfragen

O

ocsme

Top Contributor
Guten Tag,

habe einen kleinen Graph geschrieben der eine Innere Klasse Node hat. Jetzt möchte ich sehr gerne das Node mir die Anzahl der Knoten zurück gibt mit denen der Knoten verbunden ist.
Des weiteren soll ich/möchte ich eine Methode im Graph schreiben die mir die gesamte Anzahl der Zusammenhangskomponenten des Graphen zurück gibt als ArrayList<Integer>.

Mein Programm sieht derzeit so aus:
Java:
import java.util.*;

public class Graph {
    
    static class Node {
        
        int element;
        Node() {
            
        }
        
        Node(int i) {
            element=i;
        }
        
        List<Node> adjacencylist = new ArrayList<>();
        boolean mark = false;
        
        public int size() {
            return adjacencylist.size()+1;
        }
        
        public String toString() {
            return element+"";
        }
    }
    
    private List<Node> nodes = new ArrayList<>(); //soll eigentlich ein Set genutzt werden! wollte es aber erst mal mit einer Liste versuchen
    
    public boolean insert(Node element) {
        if(nodes.add(element))
            return true;
        return false;
    }
    
    public boolean addEdge(Node a, Node b) {
        if(a.adjacencylist.add(b))
            return true;
        return false;
    }
    
    public void output() {
        for( Node n : nodes) {
            if(n.adjacencylist != null)
                System.out.println(n+"->"+n.adjacencylist);
            else System.out.println(n);
        }
    }
    
    
    public String toString() {
        return nodes.toString();
    }
    
    public static void main(String[] args) {
        
        Graph g = new Graphh();
        Graph.Node n1 = new Node(1);
        Graph.Node n2= new Node(2);
        Graph.Node n3 = new Node(3);
        Graph.Node n4 = new Node(4);
        Graph.Node n5 = new Node(5);
        Graph.Node n6 = new Node(6);

        System.out.println(g.insert(n1));
        System.out.println(g.insert(n2));
        System.out.println(g.insert(n3));
        System.out.println(g.insert(n4));
        System.out.println(g.insert(n5));
        System.out.println(g.insert(n6));
        System.out.println(g.addEdge(n1, n2));
        System.out.println(g.addEdge(n1, n3));
        System.out.println(g.addEdge(n2, n1));
        System.out.println(g.addEdge(n2, n3));
        System.out.println(g.addEdge(n3, n1));
        System.out.println(g.addEdge(n3, n2));
        System.out.println(g.addEdge(n4, n5));
        System.out.println(g.addEdge(n5, n4));
        System.out.println(g);
        g.output();
        
        int size = n1.size();
        System.out.println(size);
        
    }

}

Nun meine Frage dazu.
Ist size() korrekt? Ich bekomme ja die Anzahl eines Knotens zurück :)
Und wie bekomme ich im Graph nun eine Methode hin die erkennt das die Knoten 1,2 und 3 zusammen einen Graph ergibt, Knoten 4 und 5 einen Graph und 6 ein Knoten = 1 Graph für sich. Die Anzahl der Knoten dann als Liste also so z. B. (3,2,1) <- ein Graph mit 3 Knoten ein Graph mit 2 Knoten ein Graph mit 1 Knoten.

Ich vermute es wäre leichter wenn man den Knoten selbst wieder am Anfang speichern würde in der adjacencylist damit könnte man doch überprüfen ob für jeden Knoten die adjacencylist gleich wäre und damit weiß man das sind die selben Graphen, oder vergesse ich hier Theoretisch mal wieder etwas?
Das Thema mit den AbstraktenDatenTypen ist noch nicht so meins doch ich gebe mir MÜHE :)

Vielen Dank schon mal für die Antworten :)

Liebe Grüße
 
O

ocsme

Top Contributor
An welchen Eigenschaften kannst Du das denn festmachen?

Das ist auf dem Übungszettel so gemacht :) oder meintest du etwas anderes?


Kommt darauf an, was size() liefern soll.
Entwickeln Sie die Methode s i z e ( ) der Klasse Nod e , die ermittelt, wie viele Knoten
die Zusammenhangskomponente umfasst, zu der der aktuelle Knoten gehört.


ize() müsste auf ein Attribut oder eine rekursive Funktion zurückgreifen...
mhhh.. die Knoten sind aber doch jeweils abgespeichert im Datenelement des jeweiligen Knotens :) deswegen dachte ich mir es wäre so leicht.
Was ich nur nicht verstehe ist auch der boolean der gegeben ist :p

LG
 
X

Xyz1

Gast
Ok, von vorne anfangen... Ist dein Graph ein so genannter DAG? Weil dann wäre eine "Zusammenhangskomponente" eines Knotens eindeutig definiert. Genauer: Für jeden Knoten lässt sich seine Zusammenhangskomponente genau angeben... Außerdem gilt wahrscheinlich: n1!=n2=>zk(n1)!=zk(n2).
 
X

Xyz1

Gast
Ok, von vorne anfangen... Ist dein Graph ein so genannter DAG? Weil dann wäre eine "Zusammenhangskomponente" eines Knotens eindeutig definiert. Genauer: Für jeden Knoten lässt sich seine Zusammenhangskomponente genau angeben... Außerdem gilt wahrscheinlich: n1!=n2=>zk(n1)!=zk(n2).
Ach Quatsch, alles wieder streichen! Diese Eigenschaft würd (nur) für einen bin tree gelten...

Bearbeitung: Was ich gerad seltsam finde, ist, dass der Begriff der Zusammenhangskomponente eigentlich nur mit ungerichteten Graphen auftaucht...
 
Zuletzt bearbeitet von einem Moderator:
O

ocsme

Top Contributor
Ja sry mein Fehler denn auf dem Bild sieht man einen ungerichteten Graph.
Naja dann habe ich echt Null Plan denn dann ist mein insert auch Käse!
mhhh...

LG
 
O

ocsme

Top Contributor
12129
 
O

ocsme

Top Contributor
Ein ungerichteter Graph G heißt zusammenhängend, wenn es von jedem Knoten u zu jedem anderen Knoten v mindestens einen Weg gibt.
Ein maximaler zusammenhängender Teilgraph eines ungerichteten Graphen G heißt Zusammenhangskomponente von G.


Muss ich dort Tiefensuche anwenden und den boolean meine Markierung dann auf True setzen wenn der Knoten bearbeitet wurde?
Dann hätte ich das ganze wieder total falsch verstanden :(
LG
 
O

ocsme

Top Contributor
Zyklen! Speicherst Du zu jeder Kante auch ihre "Umkehrkante"?

Das müsste ich bei addEdge noch ändern, so dass ich bei jedem einfügen einer Kante bei beiden Knoten eben die Kante einzeichne :D hört sich komisch an :D

Das hört sich vernünftig an. Wenn die Suche beendet ist, hängen die markierten Knoten zusammen...

Ich hab mal wieder viel zu doof gedacht. bzw. wir haben ja ein stück code vorgegeben bekommen da dachte ich eben es wäre mit dem Abfragen von ArrayList.size() getan :p

Werde das ganze später mal versuchen :)
Danke fürs erste :)

LG
 
X

Xyz1

Gast
Also alle Zusammenhangskomponenten printen:
Java:
import java.util.ArrayList;
import java.util.HashSet;

public class Node {
    String s = "";
    ArrayList<Node> children = new ArrayList<>();

    Node(String s) {
        this.s = s;
    }

    Node addChild(Node n) {
        children.add(n);
        n.children.add(this);
        return this;
    }

    @Override
    public String toString() {
        return s;
    }

    void size() {
        size(this, new HashSet<>());
        System.out.println("");
    }

    static void size(Node n, HashSet<Node> s) {
        if (!s.contains(n)) {
            s.add(n);
            System.out.print(n + ", ");
            for (Node node : n.children) {
                size(node, s);
            }
        }
    }

    public static void main(String[] args) {
        Node a = new Node("a");
        Node b = new Node("b");
        Node c = new Node("c");

        Node d = new Node("d");
        Node e = new Node("e");

        Node f = new Node("f");

        a.addChild(b);
        a.addChild(c);
        b.addChild(c);

        d.addChild(e);

        f.size();
        e.size();
        d.size();
        c.size();
        b.size();
        a.size();
    }
}

Dieses HashSet ist dafür da, dass das Programm i wann anhält...
 
O

ocsme

Top Contributor
@Tobias-nrw vielen Lieben Dank erst einmal :)
Hab es mir nicht angeschaut will es selbst lösen :) wenn ich es nicht hin bekomme schau ich mal drauf und wenn mir das später dann nichts nützt frag ich nochmal nach OKAY :)

Hättest das ganze auch in Spoiler Verpacken können :) Nicht falsch verstehen :) ist echt Lieb bin dir auch sehr Dankbar :) aber da muss ich erst einmal selber durch :p

Hab später auch noch einen Iterator :p schon wieder :D Ich hab einfach oft das Problem zu erkennen was gefragt ist und lasse mich zu schnell und einfach in die Irre führen :(

LG
 
O

ocsme

Top Contributor
So hab es versucht und bekomme es nicht hin. Mir fehlt immer 1 Knoten :(
Code:
public int size() {
            return size(this,0);
        }
      
        private int size(Node n, int c) {
            for(Node a : n.adjacencylist)
                if(!a.mark) {
                    c ++;
                    a.mark = true;
                    return size(this,c);
                }
            return c;
        }

Ich glaube was mir jetzt eingefallen ist, das mir der Knoten an sich mit dem ich rein gehe fehlt! Oder?
Hab mir das ganze so gedacht:
a.size() -> suche in der adjacencliste von a und schaue ob mark auf false steht. Das wäre bei a der Knoten b. Nun wird dieser auf mark = true gesetzt und count++. Schaue in b die adjacencliste dort steht ja a und c drin. Nehmen wir nun den Knoten c also c mark = true und count++. Nun sollte er noch einmal dort rein schauen und mir bei a mark auf true setzen und den count++ somit = 3 setzen?
Wo ist der Gedankenfehler oder Codefehler??

Meine addEdge von oben habe ich auch geändert zu:
Java:
    public boolean addEdge(Node a, Node b) {
        if(a != null && b != null) {
            a.adjacencylist.add(b);
            b.adjacencylist.add(a);
            return true;
        }
        return false;
    }

Muss ein Denkfehler auch haben den System.out.println(n1.mark); gibt mir false zurück :( wenn ich n1.size() aufrufe!
 
O

ocsme

Top Contributor
Man sollte sich auch mal die Nodes ausgeben lassen :p

der return stimmt ja auch nicht :p

Java:
public int size() {
            return size(this,0);
        }
       
        private int size(Node n, int c) {
            for(Node a : n.adjacencylist)
                if(!a.mark) {
                    System.out.println(a);
                    c ++;
                    a.mark = true;
                    return size(a,c);
                }
           
            return c;
        }


Jetzt ist auch der Knoten dabei wo die adjacencliste leer ist doch ich verstehe nicht mehr wieso kann die Methode mir hier c zurück geben? Dort sollte ich doch nie hin kommen können oder?? Ufff...
Java:
        public int size() {
            return size(this,0);
        }
        
        private int size(Node n, int c) {
            if(n!=null) {
                if(!n.adjacencylist.isEmpty()) {
                    for(Node a : n.adjacencylist)
                        if(!a.mark) {
                            c ++;
                            a.mark = true;
                            return size(a,c);
                        }
                }
                else {
                    n.mark = true;
                    return 1;   
                }
            }
            else return 0;
            return c;
        }
 
Zuletzt bearbeitet:
M

Meniskusschaden

Top Contributor
@ocsme: Welche Variante davon ist denn nun dein aktueller Lösungsvorschlag?
So hab es versucht und bekomme es nicht hin. Mir fehlt immer 1 Knoten :(
Wie kommst du darauf? Bei deinem Beispielgraphen (in der ursprünglichen Einfügereihenfolge) funktioniert es. Allerdings leider nur zufällig. Wenn du z.B. eine Kante zwischen a und f einfügst, geht es schief.
a.size() -> suche in der adjacencliste von a und schaue ob mark auf false steht. Das wäre bei a der Knoten b. Nun wird dieser auf mark = true gesetzt und count++. Schaue in b die adjacencliste dort steht ja a und c drin. Nehmen wir nun den Knoten c also c mark = true und count++. Nun sollte er noch einmal dort rein schauen und mir bei a mark auf true setzen und den count++ somit = 3 setzen?
Wo ist der Gedankenfehler oder Codefehler??
Der Ablauf ist nicht so, wie du ihn beschreibst. Die rekursiven Aufrufe für a sehen so aus:
Code:
size(a, 0)
.size(b, 1)
..size(a, 2)
...size(c, 3)
 
O

ocsme

Top Contributor
wie das rekursiv geht geschweige den wie Tiefensuche oder Breitensuche Funktioniert weiß ich nicht und bekomme es auch nicht hin.
Normalerweise sollte man bei dieser Aufgabe das ganze doch so gelöst bekommen:
Ich rechne +1 am Anfang das ist der Knoten der aufgerufen wird, dann laufe ich nur durch die Liste und markiere die Knoten die ich besucht habe und zähle pro Knoten +1 dazu.

Java:
public int size() {
            return size(this,1);
        }
        
        private int size(Node n, int c) {
                if(!n.adjacencylist.isEmpty()) {
                    for(Node a : n.adjacencylist)
                        if(!a.mark) {
                            c ++;
                            a.mark = true;
                        }
                }
                else {
                    n.mark = true;
                    return 1;   
                }

            return c;
        }
 
M

Meniskusschaden

Top Contributor
wie das rekursiv geht geschweige den wie Tiefensuche oder Breitensuche Funktioniert weiß ich nicht
Deine bisherigen Ansätze waren aber rekursiv.
und markiere die Knoten die ich besucht habe
Das ist im Moment noch ziemlich nutzlos, weil du ohnehin nur die Nachbarknoten deines Startknotens aufsuchst und dann aufhörst. Da kann kein Knoten mehrfach besucht werden. Vor allem aber werden Nachbarknoten der Nachbarn des Startknotens gar nicht erreicht.
 
O

ocsme

Top Contributor
@Meniskusschaden du hast vollkommen recht!
Wie doof. Dann muss ich die Knoten aus der Adja-Liste vorher speichern.
Jetzt habe ich es so versucht doch leider immer noch nicht das gewünschte Ergebnis :(
Ich glaube ich brauch hierfür noch ein weiteres Leben bis ich das verstehe :(

(nicht wundern hab die Methode erstmal void gemacht)
Java:
        public void size() {
            int count = 0;
            java.util.Stack<Node> stack = new java.util.Stack<>();
            stack.push(this);
            while(!stack.isEmpty()) {
                Node tmp = stack.pop();
                if(!tmp.mark) {
                    System.out.println(count++);
                    tmp.mark=true;
                    for(Node n : tmp.adjacencylist)
                        stack.push(n);
                }
            }
            
        }
 
O

ocsme

Top Contributor
Das sieht vernünftig aus.

ja es geht auch :D
Hatte gestern den Fehler gemacht, das im Output die Variable ja später erneut hochgezählt werden würde.
So werden nun die Richtigen Zahlen ausgegeben.

@Meniskusschaden mein Problem ist oft das ich das ganze nicht wirklich verstehe, dann frage ich hier nach und habe eine Idee im Kopf, wie hier ja auch wieder :D bis ich verstanden habe was du bzw. die anderen meinten verging wieder viel Zeit :(
Ich muss echt die Theorie erst mal lernen :p
Aber jetzt habe ich es verstanden.

Was ich jetzt nur noch nicht verstehe ist das ist doch auch wie Tiefensuche, wo ist der Unterschied zu Tiefen und Breitensuche? Bei der Breitensuche nimmt man eine Queue dann hat man First-in First-out statt First-in Last-Out Prinzip oder so irgendwie. Ist das der einzige Unterschied?

LG
 
X

Xyz1

Gast
@ocsme Jeder musste das lernen. Das ist eigentlich nicht besonders.

Der Unterschied zwischen Tiefen- und Breitensuche macht hier keinen Unterschied. Wenn man so will, so ist DFS FILO und BFS FIFO.
 
O

ocsme

Top Contributor
@Tobias-nrw das stimmt wohl ich habe mich auch lange davor gedrückt.
Denn wenn ich es Programmiere (versuche) dann verstehe ich das besser als nur auf dem Papier. Denn auf dem Papier hätte ich hier z. B. so weiter gemacht und gesagt klappt doch mit der Variante nur durch die Liste zu laufen!!!

Aber nun geht es ja und ich hab wieder was hinzu gelernt :)

Danke das Ihr alle so NETT seit :) "Daumenhoch"

LG
 
M

Meniskusschaden

Top Contributor
Was ich jetzt nur noch nicht verstehe ist das ist doch auch wie Tiefensuche, wo ist der Unterschied zu Tiefen und Breitensuche?
Bei der Tiefensuche wird ein Pfad immer bis hinunter zum Blatt abgearbeitet, bevor die Verzweigungen abgearbeitet werden.
Bei der Breitensuche werden die Knoten ebenenweise abgearbeitet. Dein Algorithmus ist eine Tiefensuche.
Die größte Zusammenhangskomponente in deinem Beispielgraphen ist aber zu klein, um den Unterschied zwischen Breiten- und Tiefensuche zu sehen. Das müsstest du vielleicht mal mit einem stärker verzweigten Graphen durchspielen.
Bei der Breitensuche nimmt man eine Queue dann hat man First-in First-out statt First-in Last-Out Prinzip oder so irgendwie.
Wenn du eine Queue genommen hättest, wäre es eine preorder-Tiefensuche gewesen (Wurzel-links-rechts). Mit deinem Stack ist es sozusagen eine "reverse-preorder-Tiefensuche" (sofern es den Begriff gibt) geworden (Wurzel-rechts-links). Also beides keine Breitensuche.
Die Begriffe FIFO und FILO (oder gebräuchlicher LIFO) sind für die Datenstrukturen Queue und Stack zwar passend, zur Charakterisierung des eigentlichen dfs- bzw. bfs-Algorithmus meines Erachtens aber nicht gut geeignet.
 
X

Xyz1

Gast
Die Begriffe FIFO und FILO (oder gebräuchlicher LIFO) sind für die Datenstrukturen Queue und Stack zwar passend, zur Charakterisierung des eigentlichen dfs- bzw. bfs-Algorithmus meines Erachtens aber nicht gut geeignet.
Das stimmt wohl; aber nicht eindeutig, aber im Wesentlichen werden sie dadurch charakterisiert. Pre-, Post- und In-order sind "Spezialfälle" der DFS.
Wenn man so will, so ist jede DFS LIFO- und x-order -behaftet, zusammen beschreiben diese Prädikate eine DFS "eindeutig".

Und... FILO vs. LIFO... das werde ich mir nie merken.^^ :D
 
M

Meniskusschaden

Top Contributor
Wenn man so will, so ist jede DFS LIFO- und x-order -behaftet
Hm, nehmen wir mal folgenden Baum:
Code:
                  +-------+
                  |   4   |
                  +---+---+
                      |
          +-----------+-----------+
          |                       |
      +---+---+               +---+---+
      |   2   |               |   6   |
      +---+---+               +---+---+
          |                       |
    +-----+-----+           +-----+-----+
    |           |           |           |
+---+---+   +---+---+   +---+---+   +---+---+
|   1   |   |   3   |   |   5   |   |   7   |
+-------+   +-------+   +-------+   +-------+
Die inorder-Tiefensuche liefert 1234567. Die 1 wird also als erstes Element ausgegeben. Wo wurde die denn nun als letztes Element hinein getan?;)
 
X

Xyz1

Gast
Naja er sah 4, danach 2 und als letztes 1; dasselbe gilt dann für die sonstigen Nodes auch...
 
X

Xyz1

Gast
@Meniskusschaden Das war doch jetzt eine Fangfrage/rethorische Frage von Dir oder? Also Du hattest mich bereits verstanden, aber wolltest Selbiges bei mir testen oder? So leicht bin ich aber nicht zu durchschauen. :D Aber es fragt sich, inwiefern diese Diskussion ihn/ihr hilft... Ich wollte ihm/ihr lediglich passende Suchbegriffe an die Hand geben, damit er/sie sich damit weiter auseinandersetzen kann. Deine Absicht hingegen ist mir nicht ersichtlich.
 
O

ocsme

Top Contributor
Ich danke euch nochmals und habe gleich eine Frage die jetzt zwar hier von abweicht doch ich finde auch unter google nichts.
Wenn nicht muss ich ein neues Thema aufmachen schon wieder!

Was ist die korrekte lineare Präfix-Repräsentation eines Binärbaumes? :p sry vom Thema abkommen.

PS: zum Thema oben bis zum Thema Tiefen und Breitensuche kam ich noch mit danach bin ich ausgestiegen? :eek:
da muss endlich die Theorie nachgearbeitet werden ;)

Nochmals vielen Lieben Dank an euch
 
M

Meniskusschaden

Top Contributor
@Meniskusschaden Das war doch jetzt eine Fangfrage/rethorische Frage von Dir oder?
Eigentlich war es nur als Hinweis gedacht, weil ich die LIFO/FIFO-Terminologie eher verwirrend finde, wenn man die Eigenschaften des eigentlichen Algorithmus betrachtet. Beim Stack beschreibt LIFO ja exakt was man als Benutzer eines Stacks beobacht. Bei einer Queue und FIFO ebenfalls. Bei der Traversierung durch einen Graphen sind das aber nur Implementierungsdetails der verwendeten Hilfsdatenstrukturen. Ich finde, das ist nicht die passende Abstraktionsebene und tritt aus der Perspektive des Benutzers nicht wirklich in Erscheinung.
Gegen die Aussage, dass eine LIFO-Datenstruktur bei der Implementierung einer Tiefensuche nützlich ist, hätte ich aber nichts einzuwenden.;)
Was ist die korrekte lineare Präfix-Repräsentation eines Binärbaumes?
Ich denke, damit ist das Ergebnis einer preorder-Tiefensuche gemeint. In meinem Beispielbaum aus #35 wäre das 4213657
 
O

ocsme

Top Contributor
Also die ganz normale Pre-Order Traversierung mit Wurzel, Links, Rechts.
bzw. ganz normal ist hier ja auch wieder falsch denn durch den Stack der Intern aufgebaut wird absolviert er ja eine Tiefensuche oder habe ich das falsch verstanden?
Die Anordnung wann ich den Knoten zuerst ausspucke oder etwas mit dem Knoten mache ist beliebig somit kommen wir auf Inorder, Preorder und Postorder doch das sind nur Varianten der Tiefensuche.

Wenn das jetzt auch wieder Falsch ist dann laufe ich heute gegen die Wand !!! :D

LG
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
M Untersuchen ob ein Graph nach entfernen einer Kante immer noch zusammenhängend ist Java Basics - Anfänger-Themen 70
N gerichteter Graph aus einer Datei einlesen Java Basics - Anfänger-Themen 21
Z Graph einlesen Java Basics - Anfänger-Themen 2
S Ungerichteter Graph in Java Java Basics - Anfänger-Themen 1
M int double int double Graph Java Basics - Anfänger-Themen 3
A Tiefensuche in Graph Java Basics - Anfänger-Themen 4
N gerichteten Graph abspeichern Java Basics - Anfänger-Themen 2
Luk10 Frage zu Graph Tiefensuche Java Basics - Anfänger-Themen 4
S Methoden Wegsuche in einem Graph Java Basics - Anfänger-Themen 6
F Zusammenhängend Komponente suchen(Graph) Java Basics - Anfänger-Themen 4
F Kanten in Graph Java Basics - Anfänger-Themen 3
M Wth? übernimmt nichtübergebenen Wert (Graph) Java Basics - Anfänger-Themen 4
T Wie kann ich einem Graph in nem JPanel eine fixe Größe geben? Java Basics - Anfänger-Themen 6
H gerichteter Graph Java Basics - Anfänger-Themen 9
B Graph aus 2dim-Array Java Basics - Anfänger-Themen 3
B Nach eingefügtem Code erkennt Compiler keine Instanzvar und meldet SyntaxError Java Basics - Anfänger-Themen 2
newcomerJava Nach doppelter Zahl eine Ausgabe Java Basics - Anfänger-Themen 10
M Anzahl Schleifendurchgänge nach x Sekunden anzeigen Java Basics - Anfänger-Themen 2
C Lotto 3, 4, 5, 6 Richtige nach x Ziehungen ermittelt.. Java Basics - Anfänger-Themen 7
G Primzahlen von Rekursiv nach Iterativ Java Basics - Anfänger-Themen 6
F JMenuItem Kann nicht nach einem String benannt werden... Java Basics - Anfänger-Themen 11
R JDK installieren Durcheinander nach installation von SE 14.02 Java Basics - Anfänger-Themen 6
P Sortieren von Listen nach Attributen Java Basics - Anfänger-Themen 3
B DateTimeFormatter nach LocalDateTime, wenn dd.MM.yyyy oder dd.MM.yyyy mm:hh Java Basics - Anfänger-Themen 5
1 main-Methode erweitern, Nachfrage nach wiedeholung Java Basics - Anfänger-Themen 2
G unklares Verhalten nach Instanzierung neuer Klasse Java Basics - Anfänger-Themen 3
S Wohin kommt das „abstract“? Vor oder nach „public“/ „private“ /... Java Basics - Anfänger-Themen 3
S Datenbank Befehl nach Login Java Basics - Anfänger-Themen 5
N Operatoren Schreibtischtest der Reihen-Suche nach Aufschluss in die Basics Java Basics - Anfänger-Themen 1
B Umstieg von C# nach Java Java Basics - Anfänger-Themen 18
Ellachen55 Wie nach häufigste Werte im Array suchen? Java Basics - Anfänger-Themen 2
N Wörter und Zahlen nach speziellen Wörtern ausgeben Java Basics - Anfänger-Themen 11
M Werte ändern sich nicht mehr nach Reset Java Basics - Anfänger-Themen 14
B Nach dem kompilieren werden Bilder nicht mehr gefunden Java Basics - Anfänger-Themen 10
X Nach einem Bruch testen ob es eine ganze Zahl ist Java Basics - Anfänger-Themen 6
B String nach erstem Leerzeichen trennen Java Basics - Anfänger-Themen 7
N Speichern von Werten in Variablen nach Schließen des Programms Java Basics - Anfänger-Themen 3
G String wird nach Einlesen aus Datei nicht erkannt Java Basics - Anfänger-Themen 3
UnknownInnocent Best Practice Algorithmus nach jedem Schritt zum Visualisieren pausieren Java Basics - Anfänger-Themen 3
O zwei Arrays nach Werten durchsuchen und zusammenfügen Java Basics - Anfänger-Themen 3
M Double Wert nach n abschneiden ohne zu runden Java Basics - Anfänger-Themen 1
C Erste Schritte Bilder nach Export anzeigen Java Basics - Anfänger-Themen 0
F Input/Output Files von A nach B kopieren Java Basics - Anfänger-Themen 11
B InputStream (PDF) nach Image (PNG / JPG) konvertieren? Java Basics - Anfänger-Themen 2
O compareTo nach mehreren Kriterien Java Basics - Anfänger-Themen 13
R Benutzereingaben als Array abspeichern nach Programmstart Java Basics - Anfänger-Themen 5
S Pane nach speziellen Child Objekten durchsuchen Java Basics - Anfänger-Themen 3
V Neue Ausgabe von toString nach Methodenaufruf Java Basics - Anfänger-Themen 9
L Arrayliste von hinten nach vorne ausgeben Java Basics - Anfänger-Themen 10
F Array nach Objektattribut durchsuchen Java Basics - Anfänger-Themen 6
M Rationale Zahl erkennen - Kurze Frage zum Restwert nach Division Java Basics - Anfänger-Themen 3
O String von vorne nach hinten an einem Zeichen Java Basics - Anfänger-Themen 10
Hanschyo Quicksort sortiert von groß nach klein Java Basics - Anfänger-Themen 3
S suche nach varible POSITION ... fuer das pixel-maennchen Java Basics - Anfänger-Themen 4
A Einträge aus Tupeln nach Regeln in Liste speichern Java Basics - Anfänger-Themen 8
B String nach HTML formatieren Java Basics - Anfänger-Themen 9
Zrebna Compiler-Fehler Java-Compiler wird nach 'javac' keyword-Eingabe nicht gestartet (Erste Übung) Java Basics - Anfänger-Themen 18
UnknownInnocent Klassen JPanel nach Ablauf der Spielzeit neuladen Java Basics - Anfänger-Themen 2
B Umbruch nach bestimmten Wort Java Basics - Anfänger-Themen 5
E Arrays nach best Muster füllen Java Basics - Anfänger-Themen 4
N Arbeitsspeicher nach kompilieren immer voller Java Basics - Anfänger-Themen 6
K String nach bestimmtem Muster parsen Java Basics - Anfänger-Themen 3
S Amazon Produktbeschreibung auslesen und nach Keywords suchen Java Basics - Anfänger-Themen 2
M Scanner-Eingabe nach gewissem Zeitraum überprüfen Java Basics - Anfänger-Themen 2
J variablePathPart ändern nach dem Ordner abgearbeitet worden ist Java Basics - Anfänger-Themen 1
B Wie kann ich die Buchstaben sortieren nach der Höhe der Zahlen Java Basics - Anfänger-Themen 14
J GUI wird direkt nach dem erstellen weiß übermalt Java Basics - Anfänger-Themen 3
L Programm zur Codieren nach Rotx Java Basics - Anfänger-Themen 1
S Nach dem Herüberschieben eines Arrays zwischen 2 Frames öffnet sich das Frame nicht mehr Java Basics - Anfänger-Themen 12
A ArrayList - size() nur nach bestimmtem index anzeigen lassen Java Basics - Anfänger-Themen 13
M Array nach String durchsuchen und zurückgeben Java Basics - Anfänger-Themen 16
W Wie lasse ich meine Ausgabe nach dem Lesen verschwinden ? Java Basics - Anfänger-Themen 1
F Liste nach einer Variablen sortieren Java Basics - Anfänger-Themen 6
S String trennen nach beliebigen Zeichen Java Basics - Anfänger-Themen 3
D Ich suche nach einer Möglickeit den Webseiten Inhalt per Java zu analysieren Automatisch Java Basics - Anfänger-Themen 3
B String: suche nach Wörter und in List<String> speichern Java Basics - Anfänger-Themen 3
O Array nach gleichen Zahlen prüfen und ausgeben Java Basics - Anfänger-Themen 6
K Matrixen berechnen nach Worker Master Paradigma mit Threads Java Basics - Anfänger-Themen 4
K Schlüsselworte Nach Java update findet mdb Datei nicht Java Basics - Anfänger-Themen 6
G nach 9 - stelliger Nummer suchen Java Basics - Anfänger-Themen 7
S Wie verwende ich ne aus einer Schleife nach der Schleife? Java Basics - Anfänger-Themen 9
M BufferedReader neue Zeile nach Knopfdruck Java Basics - Anfänger-Themen 9
E JAvaFX: Verschiedene Panels nach Klick auf Node des TreeView anzeigen Java Basics - Anfänger-Themen 0
D Liste nach 2 gleichen Einträgen suchen Java Basics - Anfänger-Themen 4
J Input/Output Den zweiten Output erst nach Eingabe ausgeben Java Basics - Anfänger-Themen 4
L (Integer) Liste nach aufsteigender Summe der Ziffern sortieren (mit Bedingung) Java Basics - Anfänger-Themen 8
S Dialogfeld nach 5 Sek automatisch öffnen Java Basics - Anfänger-Themen 15
F Alle Objekte einer Klasse nach Eigenschaft durchsuchen Java Basics - Anfänger-Themen 8
S OOP Button erst nach 2x klicken deaktivieren Java Basics - Anfänger-Themen 4
C Compiler-Fehler Wird eine if Bedingung nach einer for-Schleife nach jeder Iteration überprüft? Java Basics - Anfänger-Themen 1
F Koordinaten nach 360° auf 0° setzen Java Basics - Anfänger-Themen 2
N Operatoren Suchen nach einer bestimmten Eingabe (durch Scanner) Java Basics - Anfänger-Themen 7
S Sound stoppen und nach Pause wieder abspielen Java Basics - Anfänger-Themen 6
G String nach Contains/Regex Java Basics - Anfänger-Themen 2
J fehler nach windows update Java Basics - Anfänger-Themen 44
F Wort nach String ausgeben Java Basics - Anfänger-Themen 5
J doppelname nach schlüsselwort extends Java Basics - Anfänger-Themen 4
M Array nach Zehnen durchsuchen. Java Basics - Anfänger-Themen 25
F Interface Nach mehreren Kriterien sortieren Java Basics - Anfänger-Themen 2
S abbruch nach Ausführung eines ActionListeners...warum? Java Basics - Anfänger-Themen 6

Ähnliche Java Themen

Anzeige

Neue Themen


Oben