Gruppieren

bheinrich

Mitglied
Ich habe mit einigen Objekter einer Klasse zu tun. Nach bestimmter Kriterien lassen sich manche Objekte in Gruppen gruppieren. Ich weiss nicht wie ich die Objekte einer Gruppe so zu kennzeichen, dass als solch zu erkennen sind. Hat jemand eine Idee? wie soll ich sagen das Objekt 1 objekt 3 und Objekt 4 zur Gruppe 1; aber Objekt 2 objekt 13 und Objekt 24 zur Gruppe 2, usw. gehören
 

Gucky

Top Contributor
Du könntest es über den Speicherort tun oder du lässt alle Objekte von einer abstrakten Klasse erben, die das Feld group zur Verfügung stellt. Darin kannst du entweder ints oder Enums speichern.
 

Gucky

Top Contributor
Du hast die Objekte. Die musst du zur Laufzeit irgendwie speichern.
Entweder speicherst du die Objekte nach Gruppe sortiert in Listen. Also eine Liste group1 usw.

Oder du lässt alle Objekte von einer Superklasse, die die Variable group bereitstellt. In dieser Variable speicherst du die Gruppe. Entweder als Enum oder als int, byte usw.
 

bheinrich

Mitglied
Ich habe Ihr Tipp leider nicht verstanden, da ich ziemlich eine Anfängerin, was OOP betrifft. Ich erläutere mein Problem. Ich habe ein Klasse namens DieKnoten und sieht wie folgend aus

++++++++++++

Java:
public class DieKnoten {

// eindeutigerName
public int eindeutigerName;

// inhalt
public String inhalt;

// istMarkiert
public boolean istMarkiert;

public DieKnoten(int myEindeutigerName, String myInhalt
, boolean myIstMarkiert
) {
this.eindeutigerName = myEindeutigerName;
this.inhalt = myInhalt;
this.istMarkiert = myIstMarkiert;
}
public int getEindeutigerName() {
return eindeutigerName;
}

public String getInhalt() {
return inhalt;
}

public boolean getIstMarkiert() {
return istMarkiert;
}

}
+++++++++++

Einige Objekte habe mit ein anderer zu tun und sind über eine weitere Klasse namens Korrespondenz. In einem Feld sind alle Objekte gespeichert, die miteinander zu tun haben

Java:
public class Objekte {
static Korrespondenz [] arrayObjekte = new Korrespondenz [] {
	new Korrespondenz(new DieKnoten(1, "DTJ", true), new DieKnoten(14, "KDZ", true)),
	new Korrespondenz(new DieKnoten(1, "TXZ", false), new DieKnoten(20, "XCT", true)),
	new Korrespondenz(new DieKnoten(13, "GZR", true), new DieKnoten(15, "GFV", true)),
	new Korrespondenz(new DieKnoten(14, "QCJ", false), new DieKnoten(4, "KEV", true)),
	new Korrespondenz(new DieKnoten(18, "MHI", true), new DieKnoten(6, "XYS", false)),
	new Korrespondenz(new DieKnoten(18, "SHU", false), new DieKnoten(23, "YXT", true)),
	new Korrespondenz(new DieKnoten(19, "GPZ", true), new DieKnoten(41, "KCC", true)),
	new Korrespondenz(new DieKnoten(2, "PSX", false), new DieKnoten(21, "RTF", true)),
	new Korrespondenz(new DieKnoten(2, "RHW", true), new DieKnoten(30, "QFF", true)),
	new Korrespondenz(new DieKnoten(20, "MZX", true), new DieKnoten(27, "ADF", true)),
	new Korrespondenz(new DieKnoten(21, "IBP", false), new DieKnoten(3, "QKB", true)),
	new Korrespondenz(new DieKnoten(23, "GUP", true), new DieKnoten(7, "FKT", false)),
	new Korrespondenz(new DieKnoten(30, "YWV", false), new DieKnoten(13, "NHE", false)),
	new Korrespondenz(new DieKnoten(4, "NPX", true), new DieKnoten(5, "UPP", true)),
	new Korrespondenz(new DieKnoten(7, "BYO", true), new DieKnoten(19, "ORC", true)),
new Korrespondenz(new DieKnoten(7, "IOP", true), new DieKnoten(12, "ODB", false)),
};
}
++++++++++++

An Anfang bildet jedes Objekt eine Gruppe für sich. Falls aber zwei elemente in einem Korrespondenz stehen, dann werden deren Gruppen zusammengeführt. z.B. DieKnoten(4, "NPX", true) und DieKnoten(5, "UPP", true).

Ist nun DieKnoten a und DieKnoten b in einer Gruppe, so werden auch DieKnoten c und DieKnoten d desselbe Gruppe (und zwar die von a und b), falls es im Feld die Einträge new Korrespondenz(a,c) und new Korrespondenz(b,d) gibt. Das Spiel wird so lange geführt bis keine Gruppenveränderung festzustellen ist.
 
Zuletzt bearbeitet von einem Moderator:

Gucky

Top Contributor
Moin,
Entschuldigung, dass ich so lange nicht geschrieben habe aber jetzt bin ich wieder da ;)

Da bietet sich eine Baumartige Struktur an. Am Anfang hat jede Korrespondenz einen eigenen Knoten und die werden dann nach und Nach zusammengeführt, bis es nicht mehr weiter geht. Aber ich weiß nicht, inwieweit du so etwas selber implementieren kannst, weshalb ich dir eine andere Lösung beschreibe:

Am Anfang hast du das Array von Korrespondenzen. Dann fügst du die Knoten der ersten Korrespondenz in die erste Liste ein. Dann guckst du dir die nächste Korrespondenz an und ob sie in die erste Liste passt.


Also für die Speicherstruktur:
Java:
ArrayList<ArrayList<DieKnoten>> listenList = new ArrayList<>();
oder für ältere Javaversionen:
Java:
ArrayList<ArrayList<DieKnoten>> listenList = new ArrayList<ArrayList<DieKnoten>>();

Der Code sähe in etwa so aus:
Java:
for (Korrespondenz korr : arrayObjekte){
   ArrayList<DieKnoten>  tempList = ...
   tempList.add(elem 1 von korr);
   tempList.add(elem 2 von korr);
   listenList.add(tempList);
}

Das wäre der erste Durchlauf. Danach geht das Zusammenführen los:

Java:
boolean hasChanged = false;
while(hasChanged)
   hasChanged = false;
   for(int i = 0; i < listenList.size() - 1; i++){
      if (mindestens ein Element aus listenList.get(i) hat etwas mit listenList.get(i+1) zu tun){
         listenList.get(i).addAll(listenList.get(i+1);
         listenList.remove(i+1);
         hasChanged = true;
      }
   }
}

Diesen Vorgang nennt man auch eine Konvergenz, also eine schrittweise Annäherung an den perfekten Zustand. Ich wette es geht noch performanter aber dieser Code müsste erstmal tun, was er soll.
 
Zuletzt bearbeitet:

Gucky

Top Contributor
Objekte werden gar nicht in Javadateien gespeichert sondern zur Laufzeit angelegt. Meinst du wo du sie erstellen sollst?
Warum nicht da, wo du es jetzt tust?
 

Ähnliche Java Themen

Neue Themen


Oben