BruteForce Ansatz implementieren

PetBe

Mitglied
Hi Leute,

ich habe elektrische Lastprofile (Zeitreihen) von 10 verschiedenen Haushalten. Zu jedem Haushalt gibt es 5 verschiedene Profile. Ich würde jetzt gerne all diese Profile miteinander kombinieren (d.h. die Werte für jeden Zeitpunkt von allen Profilen addieren), sodass ich insgesammt 5^10 verschiedene zusammengesetzte Profile habe, die ich dann bewerten will.

Meine Frage ist jetzt, wie man soetwas "elegant" programmiern kann. Man könnte natürlich 10 verschachtelte for-Schleifen benutzten. Jedoch wollte ich mal fragen, ob das auch etwas schöner geht. Hat jemand von euch eine Idee? Ich würde mich über eine Antwort sehr freuen.
 

Tarrew

Top Contributor
Ich komm grad erst von der Arbeit und bin noch nicht wieder ganz aufnahmefähig ;), aber willst du ein kartesisches Produkt der Profile habe? Das würde mit Guava ziemlich leicht gehen:

Java:
Set<String> s1 = Set.of("a", "b", "c");
Set<String> s2 = Set.of("d", "e", "f");
Set<String> s3 = Set.of("g", "h", "i");

Set<List<String>> combinations = Sets.cartesianProduct(s1, s2, s3);
System.out.println(combinations);
 

PetBe

Mitglied
Danke Tarrew für deine Antwort. Wie kann ich denn Guava integrieren? Ich habe auf https://github.com/google/guava eine Zip-Datei heruntergeladen. Ich benötige doch ein .jar Datei, wenn ich externe Bibliotheken einbinden will (Sorry für die Frage, aber ich kenne mich mit dem Einbinden von externen Bibliotheken nicht aus).
 

White_Fox

Top Contributor
Wie muß man sich denn so ein Profil vorstellen?

Und du hast nicht 5^10 Profile, sondern 5*10. Das ist ein kleiner, feiner Unterschied. Und du brauchst nicht 10 verschachtelte For-Schleifen, sondern nur zwei. Drei, wenn du nochmal in einer Schleife über ein Profil iterieren willst.

Was die elefanteste Methode ist...das kommt auf deine restliche Implementierung an, drei for-Schleifen finde ich jetzt aber auch nicht verwerflich.
 

Tarrew

Top Contributor
Danke Tarrew für deine Antwort. Wie kann ich denn Guava integrieren? Ich habe auf https://github.com/google/guava eine Zip-Datei heruntergeladen. Ich benötige doch ein .jar Datei, wenn ich externe Bibliotheken einbinden will (Sorry für die Frage, aber ich kenne mich mit dem Einbinden von externen Bibliotheken nicht aus).

Wenn du du bspw. ein Maven-Projekt hast, kannst du die Dependency einfach zur pom.xml hinzufügen:
<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>28.0-jre</version>
</dependency>

Ansonsten kannst du hier auch die .jar runterladen, die kannst du dann manuell zum Build-Path hinzufügen. Das sollte mit jeder IDE relativ leicht möglich sein.
 

mihe7

Top Contributor
Java:
import java.util.Arrays;
import java.util.Random;

public class Test {

    public static void main(String[] args) {
        Random rand = new Random(1L);
        int haushalte = 10;
        int profile = 5;
        int werte = 24;

        int[][][] zeitreihen = new int[haushalte][profile][werte];
        
        // fiktive Ausgangsdaten generieren
        for (int h = 0; h < haushalte; h++) {
            System.out.println("Haushalt " + h);
            for (int p = 0; p < profile; p++) {
                for (int w = 0; w < werte; w++) { 
                    zeitreihen[h][p][w] = rand.nextInt(20);
                }
                System.out.println("    Profil " + p + ": " + Arrays.toString(zeitreihen[h][p]));
            }
        }

        int[][] aggregation = new int[haushalte][werte];
        for (int h = 0; h < haushalte; h++) {
            System.out.println("Haushalt " + h);
            for (int p = 0; p < profile; p++) {
                for (int w = 0; w < werte; w++) { 
                    aggregation[h][w] += zeitreihen[h][p][w];
                }
            }
            System.out.println("    Werte (aggregiert) " + Arrays.toString(aggregation[h]));
        }
    }
}
 
X

Xyz1

Gast
Noch keine Ahnung, was du vor hast... aber
<dependency>
<groupId>com.github.dpaukov</groupId>
<artifactId>combinatoricslib3</artifactId>
<version>3.3.0</version>
</dependency>
Java:
	public static void main(String[] args) {
		int[] haushalte = new int[10];
		int[] profile = new int[5];
		int[] werte = new int[24];
		for (int i = 0; i < haushalte.length; i++) {
			haushalte[i] = (i + 1) * 10;
		}
		for (int i = 0; i < profile.length; i++) {
			profile[i] = (i + 1) * 2;
		}
		for (int i = 0; i < werte.length; i++) {
			werte[i] = (i + 1);
		}
		ArrayList<Integer> la = new ArrayList<Integer>();
		ArrayList<Integer> lb = new ArrayList<Integer>();
		ArrayList<Integer> lc = new ArrayList<Integer>();
		for (int i : haushalte) {
			la.add(i);
		}
		for (int i : profile) {
			lb.add(i);
		}
		for (int i : werte) {
			lc.add(i);
		}
		Generator.cartesianProduct(la, lb, lc).stream().forEach(System.out::println);
		System.out.println( Generator.cartesianProduct(la, lb, lc).stream().count());
	}


Und es sind nur 10*5*24 = 1200 kombinationen/kartesische Produkte!
 

mrBrown

Super-Moderator
Mitarbeiter
Hi Leute,

ich habe elektrische Lastprofile (Zeitreihen) von 10 verschiedenen Haushalten. Zu jedem Haushalt gibt es 5 verschiedene Profile. Ich würde jetzt gerne all diese Profile miteinander kombinieren (d.h. die Werte für jeden Zeitpunkt von allen Profilen addieren), sodass ich insgesammt 5^10 verschiedene zusammengesetzte Profile habe, die ich dann bewerten will.
Was meinst du mit kombinieren? Da scheint ja ein gewisses Unverständnis zu herrschen:
Und es sind nur 10*5*24 = 1200 kombinationen/kartesische Produkte!
Und du hast nicht 5^10 Profile, sondern 5*10. Das ist ein kleiner, feiner Unterschied.

So wie ich das verstehe, geht es dir um die Kombination der 5 Profile je Haushalt für alle 10 Haushalte.
Für zwei Haushalte wäre das sowas wie {(P_1_1, P_2_1), (P_1_1, P_2_2), (P_1_1, P_2_3), (P_1_1, P_2_4), (P_1_1, P_2_5), (P_1_2, P_2_1), ...}, was am Ende wirklich auf 5^10 hinauslaufen würde
 

White_Fox

Top Contributor
Du kommst doch aus der Ecke - was macht man mit solchen Lastprofilen?
Z.B. den Energiebedarf im vorraus abschätzen und Kraftwerke entsprechend regeln. Wenn du weißt das zur Mittagszeit alle ihre Mikrowelle/Herd/Wasserkocher/... anwerfen um sich was zu Futtern zu machen, dann kannst du schon Stunden vorher ordentlich Kohle in den Ofen schaufeln, damit pünktlich genug Dampf auf dem Kessel ist.
Wenn du das nicht weißt gibt es Ärger: Nicht genug Dampf -> nicht genug Drehmoment am Turbogeneratorsatz -> Generator dreht langsamer -> Netzfrequenz sinkt -> Kraftwerk wird notabgeschaltet -> in Deutschland wirds dunkel. (Stark verkürzzt geschrieben.)

Das errechnet man aber aus den Lastprofilen ganzer Regionen, die Daten kommen dann nicht von den einzelnen Haushalten, sondern zentral vom Umspannwerk oder so.

Mit den Lastprofilen einzelner Haushalte kann man andere Dinge machen, z.B. auf bestimmte Lebensumstände oder Gewohnheiten schließen:
-Wieviele Persone leben etwa im Haushalt
-Wieviele Personen davon gehen arbeiten
-Waren die Bewohner im Urlaub
-Ein oder mehrere Bewohner sehen gerade Film XYZ. (Kein Witz: https://www.heise.de/security/meldung/Smart-Meter-verraten-Fernsehprogramm-1346166.html )

Aber was PetBe damit anfangen will, würde mich auch mal sehr interessieren. :)


Aber auch für die Summe bräuchte man doch erstmal alle Möglichkeiten von Profilen zum Zeitpunkt X?

Ich hab im ersten Moment an etwas Arrayartiges gedacht, und diese addieren will, so etwa:
Code:
 a[0] a[1] a[2] ...
+b[0] b[1] b[2] ...
-------------------
 c[0] c[1] c[2] ...

Aber wie gesagt - nur geraten.
 

White_Fox

Top Contributor
Licht ist ja nicht daß Einzige im Haushalt, was elektrische Energie verkonsumiert. Wenn z.B. den ganzen Tag der Fernseher oder Rechner läuft ergibt sich schon ein anderes Bild, als wenn tatsächlich niemand da ist. Auch eine Waschmaschine läßt sich von solchen Geräten ganz gut unterscheiden.
 

PetBe

Mitglied
Hi zusammen und vielen Dank für die vielen Antworten,
also es geht tatsächlich darum alle möglichen Profile von den haushalten miteinander zu kombinieren, was 5^10 Kombinationen sind. Jeder Haushalt hat 5 verschiedene mögliche Profile, je nachdem wann bestimmte elektrische Vebraucher benutzt werden. Ich würde jetzt gerne alle möglichen Kombinationen bilden und dann für jeder Kombination die gesamte Last der 10 Haushalte berechnen (das meinte ich mit addieren). Die Lastprofile sind Zeitreichen mit einer Auflösung von 5 minuten. Pro Tag gibt es somit 288 Einträge. Für jeden dieser 288 Einträge sollen die Lastwerte der einzelnen Haushalte addiert werden, je nachdem welches Profil verwendet wird. Am Ende habe ich tatsächlich 5^10 verschiedene Gesamtlastprofile und will analysieren, wann die maximale Last am kleinsten ist.
 

PetBe

Mitglied
Ich habe sie von einer CSV Datei eingelesen und in einem 3-dim Array gespeichert:
Code:
double [][][] loadProfiles = new double [numberOfBuildings] [numberOfDiverseProfiles] [numberOfTimeSlots];
 

White_Fox

Top Contributor
Das sind alle Daten, ich meinte aber nur die reinen Leistungsprofile. Also wie sieht ein Profil eines einzigen Haushaltes aus. Ist es ein Array von Doubles? Ein zweidimensionales Array von Doubles (Wert + Zeitstempel)? Oder ganz anders?
 

PetBe

Mitglied
Sind 288 double Werte einfach. die in dem 3-dim Array gespeichert sind. Bespielsweise von Gebäude 1, Profil 1 der 1. Wert (entspricht Uhrzeit 00:00Uhr):
loadProfiles [0][0][0]
und der letzte Wert entspricht (23:55 Uhr):
loadProfiles [0][0][287]

Also die Zeitstempel sind implizit durch den Index des Arrays gegeben
 

White_Fox

Top Contributor
So, ich hab mal was gebaut (aber nicht getestet!):

Java:
package components.library.tableset;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class PowerProfile {

    private ArrayList<Double> profile;
    private String name;
   
    public ArrayList<Double> getProfile() {
        return profile;
    }

    public void setProfile(ArrayList<Double> profile) {
        this.profile = profile;
    }
   
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Building {

    private ArrayList<PowerProfile> profiles;
    private String name;
    private int counter;
   
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
   
    public ArrayList<PowerProfile> getProfiles() {
        return profiles;
    }

    public void setProfiles(ArrayList<PowerProfile> profiles) {
        this.profiles = profiles;
    }
   
    public boolean passCounterOverflow(boolean trigger){
        if(trigger){counter++;}
        if(counter == profiles.size()){
            counter = 0;
            return true;
        }
        return false;
    }

    public int counter() {
        return counter;
    }
}

public class Leistungsprofile {
   
    static PowerProfile combineProfiles(PowerProfile... profiles) {
        ArrayList<Double> combined;
        String name;
        PowerProfile profile;
       
        combined = new ArrayList<>();
        name = "Combined Profiles from: ";
       
        for (int i = 0; i < profiles[0].getProfile().size(); i++) {
            combined.add((double) 0);
        }
       
        for (PowerProfile p : profiles) {
            name = name + p.getName() + ";";
            for (int i = 0; i < p.getProfile().size(); i++) {
                combined.add(i, combined.remove(i) + p.getProfile().get(i));
            }
        }
        profile = new PowerProfile();
        profile.setName(name);
        profile.setProfile(combined);
        return profile;
    }
   
    public static void main(String[] args) {
       
        int numberOfBuildings = 0;
        int numberOfDiverseProfiles = 0;
        int numberOfTimeSlots = 0;
       
        ArrayList<Building> buildings;
        ArrayList<PowerProfile> combined;
        ArrayList<PowerProfile> tmpProfiles;
        Building building;
        PowerProfile profile, tmpProfile;

        //...krieg Daten irgendwo her und fülle die ints mit Werten
       
        double[][][] loadProfiles = new double[numberOfBuildings][numberOfDiverseProfiles][numberOfTimeSlots];
       
        //Daten in Building- und PowerProfile-Objekte überführen
        buildings = new ArrayList<>();
        for (int buildingCounter = 0; buildingCounter < numberOfBuildings; buildingCounter++) {
            numberOfDiverseProfiles = 0;
            building = new Building();
            for (int profileCounter = 0; profileCounter < numberOfDiverseProfiles; profileCounter++) {
                profile = new PowerProfile();
                profile.setName("Gebäude " + buildingCounter + ", Profil " + profileCounter);
               
                double d[] = loadProfiles[buildingCounter][profileCounter];
                List l = Arrays.asList(d);
                profile.setProfile(new ArrayList<>(l));
                building.getProfiles().add(profile);
            }
            buildings.add(building);
        }

        //Alle Profile miteinander kombinieren. Jedes Building hat einen
        //Counter, der inkrementiert wird und überläuft, wenn er die Anzahl der
        //Profile des Buildings übersteigt. Wenn der Counter des letzten
        //Buildings überläuft, sind alle Kombinationen durch.
        combined = new ArrayList<>();
        boolean passOverflow = true;
        do{
            tmpProfiles = new ArrayList<>();
            passOverflow = true;
            for(Building b : buildings){
                tmpProfile = b.getProfiles().get(b.counter());
                tmpProfiles.add(tmpProfile);
                passOverflow = b.passCounterOverflow(passOverflow);
            }
            combined.add(combineProfiles((PowerProfile[])tmpProfiles.toArray()));
        }while (!passOverflow);
       
        //Mach was mit den vielen Profilen...
    }
}

Das sieht jetzt erstmal wild aus, sieht aber schlimmer aus als es ist. Im Prinzip passiert folgendes:
  1. Eine Klasse PowerProfil wird deklariert. Die beinhaltet die Nutzdaten eines Profils, und einen Namen um diese später wieder auseinanderzuhalten. Die Klasse verfügt nur über einfache getter- und setter-Methoden und keine weitere Intelligenz.
  2. Eine Klasse Building wird deklariert. Diese dient dazu, einige ProwerProfil-Objekte einem bestimmten Gebäude zuzuordnen. Die Klasse kann zurückmelden, wenn einmal alle Profile durchgezählt wurden.
  3. In der main-Methode müssen zunächst einmal die Daten geholt werden (siehe Kommentarzeile), das ist der Teil in der du bisher deine Daten einliest. Danach werden die Daten in Building- und PowerProfil-Objekte überführt, um die Zuordnung zusammenzubauen.
  4. Das eigentliche Profilekombinieren passiert in der letzten Do-While-Schleife. Dort wird jetzt von jedem Building-Objekt ein Profil genommen, und von diesen Profilen für alle Werte an einer Positon jeweils die Summe gebildet. Das passiert folgendermaßen:
    Jedes Building-Objekt verfügt über einen Counter und eine Methode, um diesen zu inkrementieren (also 1 zu addieren). Es wird nur dann inkrementiert, wenn man dieser Methode außerdem ein True übergibt. Außerdem meldett die Methode zurück, wenn der Counter die Anzahl der Profile erreicht hat und setzt den Counter dann zurück.

    Jetzt wird bei jedem for-each-Durchlauf die passCounter-Methode des ersten Building-Elements mit True aufgerufen und dessen Counter damit inkrementiert. Das Ergebnis der Methode zeigt an, ob ein Überlauf stattgefunden hat, in diesem Fall wird auch der Counter des folgenden Buildings inkrementiert. Und wenn dieser überläuft, dann wird der des darauf folgenden Building-Elements inkrementiert, usw.
    Während dessen wird der Counter genutzt, um ein PowerProfil des jeweiligen Building-Objekts zum Kombinieren auszuwählen. Das Ergebnis der Kombination wird in combined gespeichert.
  5. Die for-each-Schleife wird immer wieder neu durchlaufen, solange die do-while-Schleife durchlaufen wird. Irgendwann läuft der Counter des letzten Building-Elements über, dann liefert die Methode true zurück. In diesem Moment wird die Abbruchbedingung erfüllt und die do-while-Schleife wird verlassen.
Algorithmentechnisch jetzt vielleicht nicht sooo elegant, aber auch gar nicht so schlecht. Finde ich jedenfalls.

Wichtig: Ich hab das Programm nicht getestet. Daher: Probiere das Ganze erstmal mit wenigen Daten aus, so daß du das Ergebnis selber kontrollieren kannst und schaue mal, ob es das ist was du erwartet hättest.
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Wenn man die Kombinationen haben will: man nehme eine 10-stellige Zahl zur Basis 5, dann muss man nur einmal komplett durchzählen und erhält so jede mögliche Kombination.
Code:
0000000000
|      |||
|      ||+- Profil Haushalt 1
|      |+-- Profil Haushalt 2
|      +--- ...
+---------- Profil Haushalt 10
 

White_Fox

Top Contributor
Ich bin gespannt wie du das in Javacode formulierst, :)

Aber LOL...ausgerechnet das, wo ich grad im Nachbarthread etwas dazu geschrieben habe wozu man mal Mathe gebrauchen könnte. :D
 

mihe7

Top Contributor
Ich bin gespannt wie du das in Javacode formulierst

Ach, das ist ganz einfach:
Java:
public class Test {
    public static void main(String[] args) {
        System.out.println("0000000000");
        System.out.println("|      |||");
        System.out.println("|      ||+- Profil Haushalt 1");
        System.out.println("|      |+-- Profil Haushalt 2");
        System.out.println("|      +--- ...");
        System.out.println("+---------- Profil Haushalt 10");
    }
}

Wobei die Ausgabe der Kombinationen kürzer gewesen wäre:
Java:
public class Test {
    public static void main(String[] args) {
// wer es extrem will:
//        int n = Math.pow(5, 10);
// sonst
        int n = 30;
        for (int i = 0; i < n; i++) {
            char[] h = String.format("%010d", Integer.valueOf(Integer.toString(i, 5))).toCharArray();
            System.out.println(Arrays.toString(h));
        }
    }
}
 

httpdigest

Top Contributor
Hab mal was gebastelt. Es ist auch flexibel genug, um unterschiedlich viele Profile pro Haushalt zu definieren. Als Beispiel 10 Haushalte mit à 5 Profilen:
Java:
import static java.util.stream.Collectors.toList;
import java.util.List;
import java.util.function.*;
import java.util.stream.*;
public class Combinations {
  private static int[] cvt(long v, int[] bases, int[] number, int i) {
    if (v <= 0)
      return number;
    number[i] = (int) (v % bases[i]);
    return cvt(v / bases[i], bases, number, i + 1);
  }
  public static <T> Stream<List<T>> combinations(
      BiFunction<Integer, Integer, T> haushalt2profil, int[] profilePerHaushalt) {
    int[] number = new int[profilePerHaushalt.length];
    long n = IntStream
        .range(0, profilePerHaushalt.length)
        .map(i -> profilePerHaushalt[i])
        .asLongStream()
        .reduce(1L, (i, j) -> i * j);
    return LongStream
        .range(0, n)
        .mapToObj(i -> cvt(i, profilePerHaushalt, number, 0))
        .map(arr -> IntStream
            .range(0, arr.length)
            .mapToObj(i -> haushalt2profil.apply(i, number[i]))
            .collect(toList()));
  }
  public static void main(String[] args) {
    combinations((haushalt, profil) -> haushalt + "(" + profil + ")",
        new int[] {5, 5, 5, 5, 5, 5, 5, 5, 5, 5})
    .forEach(System.out::println);
  }
}
Dieser Methode muss man also eine (Bi-)Funktion geben, die zu einem Haushalt- + Profil-Index das entsprechende Profil dieses Haushaltes liefert (generisch als <T>) und ein Array dessen Länge die Gesamtanzahl der Haushalte bedeutet und deren Elemente die Anzahl der Profile pro Haushalt liefert. Als Ergebnis bekommt man einen Stream von Listen, wobei jede Liste eine Kombination aus <T>s (was sich aus Haushalt-+Profil-Index ergibt) ist.
 

httpdigest

Top Contributor
Es ist zwar das kartesische Produkt, aber nicht so, wie du es aufzeigst.
Korrekt wäre das Produkt aus 10 Mengen. Die 10 Mengen sind die jeweils 5 Profile der 10 Haushalte.
Und die Kardinalität dieser Produkt-Menge wäre 5^10 = 9.765.625.
 
X

Xyz1

Gast
Ich verstehe euch nicht ohne eine Formale Definition (von mir aus aufzählende oder beschreibende Schreibweise)....
Gegeben seien die Mengen A, B, C.
Was soll jetzt wie berechnet werden? Vereinigungsmenge, Schnittmenge, Mengenprodukt, Potenz... definiert das erst mal anständig! Dann können wir uns weiter unterhalten.
 

mrBrown

Super-Moderator
Mitarbeiter
Ich verstehe euch nicht ohne eine Formale Definition (von mir aus aufzählende oder beschreibende Schreibweise)....
Gegeben seien die Mengen A, B, C.
Was soll jetzt wie berechnet werden? Vereinigungsmenge, Schnittmenge, Mengenprodukt, Potenz... definiert das erst mal anständig! Dann können wir uns weiter unterhalten.
Gegeben sind die Mengen Haushalt1, Haushalt2, ... Haushalt10, wobei jede Menge jeweils 5 Elemente enthält. Davon das kartesische Produkt.
 

PetBe

Mitglied
Vielen Dank für die vielen Antworten und die Beispielcodes. Ich werde das nächste Woche ausprobieren (hab gerade kein Zugang zu den Profilen)
 
X

Xyz1

Gast
Sprich (h1_1 u h1_2 u ... u h1_5) x (h2_1 u h2_2 u ... u h2_5) x ... x (h10_1 u h10_2 u ... u h10_5) ?

Dann müssen h1 bis h10 eben noch "entfaltet" werden...

Die Mächtigkeit wäre hier 5^10.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
M Salesman Problem - Bruteforce Algorithmus Allgemeine Java-Themen 23
R Bruteforce hashes mit multithreading. Funktioniert das so? Allgemeine Java-Themen 0
K Caesar Chiffre Bruteforce Allgemeine Java-Themen 8
N chess ansatz Allgemeine Java-Themen 12
M ORM scheitert gefühlt im Ansatz Allgemeine Java-Themen 27
A 2D-Grafik Einfachster Ansatz, um sich wiederholende Figur in einem 2D-Image zu erkennen Allgemeine Java-Themen 1
M Keine weitere Eingabe in der Main möglich. Eventueller Ansatz über while. Allgemeine Java-Themen 8
MoxxiManagarm Ich brauche einen smarten Ansatz Allgemeine Java-Themen 23
S Erste Schritte Fehlender Gedanken-Ansatz bei Interpretation von Daten Allgemeine Java-Themen 1
N Ansatz Simulation Javascript Allgemeine Java-Themen 2
J Drei Bedingungen -> 9 Fällen, welcher Ansatz besser Allgemeine Java-Themen 4
A Ansatz Objektorientierung, Methoden Vererbung Allgemeine Java-Themen 2
P Ansatz?: EncoderWrapper Klasse bauen? Allgemeine Java-Themen 5
R Objektorientierter Ansatz fehlt Allgemeine Java-Themen 11
L Buchungssystem implementieren Allgemeine Java-Themen 2
M Kann man Annotationen auf Klassen einschränken die ein Interface implementieren? Allgemeine Java-Themen 1
MiMa Was sollte man ins JavaDoc implementieren?? Allgemeine Java-Themen 17
L Generator für einen Parser implementieren Allgemeine Java-Themen 13
L Template Engine entwerfen und implementieren Allgemeine Java-Themen 4
D OOP Gemeinsamen ID-Raum für zwei Klassen implementieren Allgemeine Java-Themen 7
A Breitensuche mit Hop-Distanzen in Java - Wie implementieren? Allgemeine Java-Themen 4
M Maven Deutsche Post API implementieren Allgemeine Java-Themen 2
S Eclipse Probleme beim Implementieren / Ausführen von jUnit 5-Test Suites Allgemeine Java-Themen 14
N Best Practice Allgemeines Verhalten für ein Interface implementieren? Allgemeine Java-Themen 7
K Geschätze Zeit implementieren Allgemeine Java-Themen 14
B Live Search implementieren Allgemeine Java-Themen 4
S Threads Kann mir jemand helfen eine parallele Hilfsklasse zu implementieren..? Allgemeine Java-Themen 3
T Generisch implementieren Allgemeine Java-Themen 31
J Wie implementieren, Frge an die Erfahrenen... Allgemeine Java-Themen 7
M Interface einer Library implementieren Allgemeine Java-Themen 3
F Schlüsselworte RSA Verschlüsselung implementieren Allgemeine Java-Themen 5
H Copy Paste implementieren ausserhalb des Programms? Allgemeine Java-Themen 2
D Aufgabe: Schnittstelle und Proxy implementieren Allgemeine Java-Themen 2
B Best Practice HTML Output Optimal implementieren Allgemeine Java-Themen 3
I Mehrfaches Implementieren eines generischen Interface Allgemeine Java-Themen 9
DStrohma In abstrakter Klasse Konstruktor von Instanz implementieren Allgemeine Java-Themen 11
X Modalität von JDialog nachträglich in JFrame implementieren? Allgemeine Java-Themen 8
O Plugin perfomrant implementieren Allgemeine Java-Themen 12
P InterfaceMethoden nicht implementieren Allgemeine Java-Themen 5
C Hilfe bei Adressbuch-Programmierung, wie am Besten mit JList implementieren Allgemeine Java-Themen 2
A RandomAccessFile - "insert" implementieren? Allgemeine Java-Themen 4
nrg Wie würdet ihr eine "Dauerschnittstelle" implementieren? Allgemeine Java-Themen 5
T Von JComponent erben und Set implementieren Allgemeine Java-Themen 2
D Wozu runnable implementieren? Allgemeine Java-Themen 3
D PriorityQueue selbst implementieren Allgemeine Java-Themen 15
E Wie Assoziationen implementieren in Java Allgemeine Java-Themen 22
B mathematische Formeln, umformungen nicht einzeln implementieren Allgemeine Java-Themen 6
J Undo auf eine ArrayList implementieren Allgemeine Java-Themen 3
deetee ListIterator implementieren Allgemeine Java-Themen 3
A feststellen, welche Klassen ein Interface implementieren Allgemeine Java-Themen 3
B Generisches Singleton implementieren Allgemeine Java-Themen 12
T Interface "on-the-fly" implementieren? Allgemeine Java-Themen 3
G Interface - Klassen implementieren das - Reflection ok? Allgemeine Java-Themen 4
G Interface mehrfach implementieren Allgemeine Java-Themen 5
@ zur Laufzeit Interface aus jar implementieren? Allgemeine Java-Themen 5
MQue Vector implementieren Allgemeine Java-Themen 2
MQue Interface implementieren Allgemeine Java-Themen 7
P Liste von Klassen die ein Interface implementieren speichern Allgemeine Java-Themen 12
MQue Methode aus run() aufrufen bzw. implementieren Allgemeine Java-Themen 5
G Collections als Array implementieren Allgemeine Java-Themen 2
P Page Rank Algorithmus implementieren Allgemeine Java-Themen 7
R Interface mittels Reflection implementieren Allgemeine Java-Themen 8
N 2 Interfaces mit Methoden selber Signatur implementieren Allgemeine Java-Themen 5
C Implementieren einer Schnittstelle (Interface), Ausnahmen Allgemeine Java-Themen 7

Ähnliche Java Themen

Neue Themen


Oben