Technischer Projektleiter
Java Programmierbeispiele: Erstelle eine nützliche Anwendung, um zufällige Spiele von Doppelteams zu generieren
In diesem Artikel möchte ich zeigen, wie sich reale Probleme mit der Programmiersprache Java leicht lösen lassen.
Auftrag
Gemeinsam werden wir ein Programm erstellen, das aus den N angemeldeten Personen einzigartige Paare bildet. Aus diesen Paaren werden dann nach dem Zufallsprinzip 2 Teams gebildet, die gegeneinander spielen. Das Ziel ist es, alle möglichen Varianten von Spielen zu erstellen, so dass jedes Team gegen die übrigen Teams spielt.
Vorschlag für eine Lösung
Wenn wir eine komplexere Aufgabe lösen, empfiehlt es sich, sie in kleinere Teile zu zerlegen und diese einzeln zu lösen. In diesem Fall könnte man die Aufgabe in folgende Schritte aufteilen:
- das Einlesen der angemeldeten Personen und deren Speicherung im Speicher des Programms,
- die Erstellung von Paarvariationen ohne Wiederholungen,
- die Erstellung aller möglichen Spiele von zwei Doppelpaaren,
- das zufällige Mischen der generierten Matches,
- Auflistung der Ergebnisse.
Wir werden uns nun jeden Schritt genauer ansehen.
Das Einlesen der angemeldeten Personen und deren Speicherung im Programmspeicher
In diesem Abschnitt lesen wir eine Liste von Namen der angemeldeten Personen aus einer Datei ein und speichern sie in einer Liste ludia. Jede Person wird durch die Klasse Osoba repräsentiert.
Erstellung von Paarvariationen ohne Wiederholungen
Wenn wir die Personen eingelesen haben, müssen wir alle möglichen Paare erstellen, sodass sich keine Personen wiederholen und jedes Paar einzigartig ist. Bei einem Paar ist die Reihenfolge, wer erster oder zweiter ist, unerheblich. Ein solches Paar wird durch die Klasse Dvojica repräsentiert, und die Ergebnisse werden in einer Liste unikatneDvojice gespeichert.
Erstellung aller möglichen Spiele von zwei Doppelpaaren
Wir erstellen alle möglichen Spiele aus den gebildeten Paaren, sodass jedes Team gegen jedes andere spielt. Dabei müssen wir sicherstellen, dass jedes Paar nur in einem einzigen Spiel auftritt, das heißt, ein Paar darf nicht gegen sich selbst spielen und kein Spieler darf gleichzeitig in zwei Teams spielen. Ein Spiel wird durch die Klasse Zapas repräsentiert, und diese Spiele speichern wir in einer Liste zapasy zur weiteren Verarbeitung.
Zufälliges Mischen der generierten Matches
Zur Abwechslung fügen wir ein Element der Zufälligkeit hinzu, indem wir die generierten Spiele zufällig mischen.
Auflistung der Ergebnisse
Für diese Art von Konsolenanwendung reicht es aus, die Ergebnisse auf der Konsole auszugeben.
Implementierung des Entwurfs in der Programmiersprache Java
Nachdem wir die Schlüssel-Schritte des Programms identifiziert haben, bleibt uns nichts anderes übrig, als das Programm zu programmieren. Wir werden ein Turniersystem für Spiele zwischen Gruppen von Teams (Paaren von Personen) erstellen. Um eine bessere Vorstellung davon zu bekommen, was das Programm macht, werde ich es Schritt für Schritt erklären: Osoba.java
package entities;
public class Osoba {
public String meno;
public Osoba(String meno) {
this.meno = meno;
}
}
definiert die Klasse Osoba mit einem Attribut Name, das den Namen der Person darstellt. Dvojica.java
package entities;
public class Dvojica {
public Osoba osoba1;
public Osoba osoba2;
public Dvojica(Osoba osoba1, Osoba osoba2) {
this.osoba1 = osoba1;
this.osoba2 = osoba2;
}
}
definiert die Klasse Dvojica, die zwei Personen (osoba1 und osoba2) enthält und ein Paar von Menschen darstellt. ein Team bestehend aus zwei Personen. Zapas.java
package entities;
public class Zapas {
public Dvojica tim1;
public Dvojica tim2;
public Zapas(Dvojica tim1, Dvojica tim2) {
this.tim1 = tim1;
this.tim2 = tim2;
}
}
Die Klasse Zapas stellt ein Match zwischen zwei Paaren dar, bzw. ein Teams (tim1 und tim2). Generator.java
package entities;
import entities.*;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
public class Generator {
private List<Osoba> ludia;
private List<Dvojica> unikatneDvojice;
private List<Zapas> zapasy;
public void Generator() {
ludia = null;
unikatneDvojice = null;
zapasy = null;
}
public void nacitajVstupneData() throws IOException {
ludia = new ArrayList<>();
for(String line : Files.readAllLines(Paths.get("vstupy.txt"))) {
ludia.add(new Osoba(line));
}
}
// Vytvori všetky možné dvojice z ľudí
public void vygenerujUnikatneDvojice() {
unikatneDvojice = new ArrayList<>();
for (int i = 0; i < ludia.size(); i++) {
for (int j = i + 1; j < ludia.size(); j++) {
Dvojica dvojica = new Dvojica(ludia.get(i), ludia.get(j));
unikatneDvojice.add(dvojica);
}
}
}
// Vytvori všetky možné zápasy s danými dvojicami
public void vygenerujUnikatneZapasy() {
zapasy = new ArrayList();
for (int i = 0; i < unikatneDvojice.size(); i++) {
for (int j = i + 1; j < unikatneDvojice.size(); j++) {
Dvojica tim1 = unikatneDvojice.get(i);
Dvojica tim2 = unikatneDvojice.get(j);
if(tim1.osoba1.equals(tim2.osoba1) || tim1.osoba1.equals(tim2.osoba2) || tim1.osoba2.equals(tim2.osoba1) || tim1.osoba2.equals(tim2.osoba2))
continue;
zapasy.add(new Zapas(tim1, tim2));
}
}
}
public List<Osoba> getLudia() {
return ludia;
}
public List<Dvojica> getUnikatneDvojice() {
return unikatneDvojice;
}
public List<Zapas> getZapasy() {
return zapasy;
}
}
Die Klasse Generator ist verantwortlich für das Laden, Verarbeiten von Daten und das Generieren von Ergebnissen. Verwendet drei Listen (ludia, unikatneDvojice und zapasy) zur Verwaltung von Informationen über Personen, Teams und Matches. Der Konstruktor Generator() initialisiert die Listen mit dem Wert null. Die Methode nacitajVstupneData() lädt Daten über Personen aus der Datei vstupy.txt und erstellt daraus Objekte vom Typ Osoba, die in der Liste ludia gespeichert werden. Die Methode vygenerujUnikatneDvojice() erstellt alle möglichen Paare von Personen und speichert diese in der Liste unikatneDvojice. Die Methode vygenerujUnikatneZapasy() erstellt alle möglichen Matches zwischen den Paaren und speichert diese in der Liste zapasy. Stellt sicher, dass keine zwei Personen in verschiedenen Paaren wiederholt werden. Die Zugriffsmethoden getLudia(), getUnikatneDvojice() und getZapasy() gewähren Zugriff auf die jeweiligen Listen. Main.java
import java.io.IOException;
import java.util.Collections;
import java.util.Random;
import entities.*;
public class Main {
public static void main(String[] args) throws IOException {
Generator generator = new Generator();
generator.nacitajVstupneData();
System.out.println("Prihlaseni ludia [" + generator.getLudia().size() + "]: ");
for (Osoba osoba : generator.getLudia()) {
System.out.println(osoba.meno);
}
System.out.println();
generator.vygenerujUnikatneDvojice();
System.out.println("Mozne dvojice [" + generator.getUnikatneDvojice().size() + "]: ");
for (Dvojica dvojica : generator.getUnikatneDvojice()) {
System.out.println(dvojica.osoba1.meno + " a " + dvojica.osoba2.meno);
}
System.out.println();
generator.vygenerujUnikatneZapasy();
Collections.shuffle(generator.getZapasy(), new Random());
System.out.println("Zapasy kazdy s kazdym v nahodnom poradi [" + generator.getZapasy().size() + "]: ");
for (Zapas zapas : generator.getZapasy()) {
System.out.println(zapas.tim1.osoba1.meno + " a " + zapas.tim1.osoba2.meno + " vs. " +
zapas.tim2.osoba1.meno + " a " + zapas.tim2.osoba2.meno);
}
}
}
enthält die Hauptmethode main(), die die Funktionalität des Programms demonstriert. Erstellt eine Instanz der Klasse Generator. Lädt die Eingangsdaten über Personen und gibt die angemeldeten Personen aus. Generiert alle möglichen eindeutigen Paare und listet sie auf. Erzeugt alle möglichen Matches, sortiert diese dann zufällig und gibt sie auf der Konsole aus. Das Programm funktioniert für beliebig viele Personen und kann leicht angepasst und modifiziert werden, um spezifischen Anforderungen gerecht zu werden. Programmeintrag:
Programmausgabe:
Übung 1
Erweitere die Klasse Osoba um das Attribut pohlavie (Mann, Frau). Passe die Methode vygenerujUnikatneDvojice() an, sodass alle möglichen Paare von Personen erstellt werden, wobei jedes Team aus einem Mann und einer Frau besteht. Generiere anschließend die möglichen Matches. Speichere die Ergebnisse in einer Ausgabedatei.
Übung 2 (Herausforderung)
Beim Erstellen einer Instanz des Generators gib eine Zahl an, die bestimmt, wie groß die Teams sein sollen. Passe den Beispielcode anschließend an, damit er für Teams beliebiger Größe funktioniert.
Java Code Beispiel
Wir haben die Dateien mit dem obigen Beispiel in Form von Code vorbereitet, den du direkt in Java ausführen kannst. Lade den Java-Code des Beispiels hier herunter. Wenn du keine Probleme hast, den Code gemäß der Aufgabenstellung zu erstellen, und ein erfahrener Java Programmierer bist, sieh dir unsere Mitarbeiterbenefits an und reagiere auf unsere Stellenangebote.