Integer Verknüpfung

[Otto]

Hallo,
ich wollte mal wieder etwas Java üben. Dazu habe ich mir vorgenommen ein kleinen Terminplaner zu schreiben.
Ich stehe jetzt vor dem Problem das ich die Termine nach dem Datum sotieren möchte.

In meiner Klasse Termine habe ich unter anderem die drei Variablen
int tag;
int monat;
int jahr;

Jetzt würde ich die gern so verknüpfen:

int termin = jahr monat tag;

Ich weiß jedoch nicht wie ich das hinbekommen soll.
Wie kann ich diese Verknüpfung machen?

MfG
Otto

[Jörg Peschke]

Moin,

int termin = jahr monat tag;

Ich weiß jedoch nicht wie ich das hinbekommen soll.
Wie kann ich diese Verknüpfung machen?

Hmm, wenn ich Dich richtig verstehe, brauchst Du den UNIX-Timestamp Deines Datums, oder? Also eine Integer-Zahl, die einen Zeitpunkt eindeutig charakterisiert, oder?

Ich bion selber kein Java-Gott, aber vielleicht kann die Calendar- oder Date-Klasse das was du brauchst?

[Cruz]

Yotto,

Oder alternativ kriegst du es selbst recht einfach mit Multiplikation und Addition ist. Multiplizierst du z.B. das Jahr mit 100 und addierst dann den Monat dazu, hast du schon mal den Anfang.

Ist eher quick and dirty aber zum Üben reicht es. :)

Gruß,
Cruz

[lina-]

moin Otto :)

Jetzt würde ich die gern so verknüpfen:

int termin = jahr monat tag;

Diese Aussage lässt zwei Vermutungen offen:
du möchtest einen netten "Output" in der Art von "02 03 2006" oder du möchtest einen timestamp der das Datum eindeutig wiedergibt.

Wie kann ich diese Verknüpfung machen?

Das hängt davon ab, welche von meinen Vermutungen zutrifft.

liebe Grüße aus Berlin
lina-

[Otto]

Hi lina-,
also ich wollte folgendes haben:

Termin = 20060526

Wobei eine Lösung mit dem Timestamp sicherlich sauberer wäre.

Ich habe mir jetzt etwas mit ein paar if abfragen gebastelt und es funktioniert :-)

MfG
Otto

[lina-]

moin Otto :)

Ich habe mir jetzt etwas mit ein paar if abfragen gebastelt und es funktioniert :-)

if-Abfragen? Ich hätte das wahrscheinlich eher über casting gelöst...

StringBuffer buf=new StringBuffer();
buf.append(year);buf.append(month);buf.append(day);+
try{
int result= (new Integer(new String(buf))).intValue();
}catch(NumberFormatException e){
//Dinge tun, falls casting nicht funktioniert
}
liebe Grüße aus Berlin
lina-

[Otto]

Hi lina-,

DANKE!

MfG
Otto

[Slyh]

Hallo,

StringBuffer buf=new StringBuffer();
buf.append(year);buf.append(month);buf.append(day);+

Zum Ersten könnte man das kürzen in:

StringBuffer buf=new StringBuffer(8);  // 8 -> Anfangskapazität = maximal mögliche Länge des Konstrukts.
  buf.append(year).append(month).append(day);

Zum Zweiten ist der Code vollständig identischt zu:

"" + year + month + day

try{
int result= (new Integer(new String(buf))).intValue();
}catch(NumberFormatException e){
//Dinge tun, falls casting nicht funktioniert
}

Zum Dritten ist der folgende Code um Welten performanter, speicherschonender und kürzer:

int result = year * 10000 + month * 100 + day * 1;

:-)

Gruß
Slyh

[lina-]

moin Slyh :)

Zum Zweiten ist der Code vollständig identischt zu:

"" + year + month + day

Du redest von Speicherschonung und bietest ein solches Ungetüm an?

Ansonsten gebe ich dir gerne recht...

liebe Grüße aus Berlin
lina-

[Slyh]

Hallo,

Zum Zweiten ist der Code vollständig identischt zu:

"" + year + month + day

Du redest von Speicherschonung und bietest ein solches Ungetüm an?

Wie ich schon sagte, ist der Code identisch zu dem, was du vorgeschlagen
hast. Guck dir ruhig mal ein Dekompilat an, z.B. mit javap.exe, das sich
im bin-Verzeichnis deines JDK befindet. (javap -c JavaKlasse)

Der einzige Nachteil ist, daß man so den vom Compiler verwendeten StringBuilder
nicht auf 8 Zeichen vorinitialisieren kann...

Gruß
Slyh

[lina-]

moin Slyh :)

Du redest von Speicherschonung und bietest ein solches Ungetüm an?

Wie ich schon sagte, ist der Code identisch zu dem, was du vorgeschlagen
hast. Guck dir ruhig mal ein Dekompilat an, z.B. mit javap.exe, das sich
im bin-Verzeichnis deines JDK befindet. (javap -c JavaKlasse)

hmm... also ich habe vor nicht all zu geraumer Zeit mal gelernt, dass bei einer solchen Verkettung mehrere (unnötige) String-Objekte angelegt werden- und zwar für jedes "+" ein zusätzliches (nicht StringBuffer wie du es beschreibst).
Aber ich werd mir das bei Gelegenheit mal ansehen.

liebe Grüße aus Berlin
lina-

[Richard]

Hallo,

Welche Vorteile bringen in diesem konkreten Fall StringBuffers gegenüber normalen Strings?

Viele Grüße

[Slyh]

Hallo,

Hallo,

Welche Vorteile bringen in diesem konkreten Fall StringBuffers gegenüber normalen Strings?

Im konkreten Fall gar nichts, weil der Compiler die String-Verkettung über
einen StringBuilder/StringBuffer realisiert.

Wenn man aber z.B. in einer Schleife immer weitere Strings an den String
anhängen möchte, sollte man tunlichst einen StringBuffer verwenden.

Für jede String-Verkettung erzeugt der Compiler nämlich einen neuen
StringBuffer.

Original:
  String a = "abc";
  String a = a + "def";

Kompilat:
  String a = "abc";
  StringBuffer buffer = new StringBuffer(a);
  buffer.append("def");
  a = buffer.toString();

Wie man sieht, wird ein neuer StringBuffer erzeugt. Dieser wird mit den
Daten in 'a' initialisiert. Dann wird "def" angehängt. Danach wird aus
dem StringBuffer wieder ein String erzeugt.

Hier werden also massig unnötige Objekte erzeugt. Steht das ganze in
einer Schleife, wird es noch schlimmer:

Original:
  String a = "x";
  for (int i = 0; i < 1000; i++) {
    a = a + "x";
  }

Kompilat:
  String a = "x";
  for (int i = 0; i < 1000; i++) {
    StringBuffer buffer = new StringBuffer(a);
    buffer.append("x");
    a = buffer.toString();
  }

Hier werden also 1000 unnötige StringBuffer-Objekte (und eigentlich auch
1000 unnötige String-Objekte) erzeugt.

Man sollte also bei einer solchen Schleife gleich wie folgt implementieren:

StringBuffer buffer = new StringBufer("x");
  for (int i = 0; i < 1000; i++) {
    buffer.append("x");
  }
  String a = buffer.toString();

Oder, weil wir ja wissen, daß genau 1001 'x' in den Buffer geschrieben
werden sollen, können wir die Größe des internen char-Arrays von StringBuffer
gleich auf 1001 initialisieren, damit nicht unnötigerweise während den
appends jeweils neue, größere interne char-Arrays angelegt werden müssen,
in die jeweils der Inhalt des vorherigen char-Arrays umkopiert werden muß.
Also:

StringBuffer buffer = new StringBufer(1001);
  buffer.append("x");
  for (int i = 0; i < 1000; i++) {
    buffer.append("x");
  }
  String a = buffer.toString();

(Das doppelte 'append' hätte man natürlich durch das Erhöhen des
Schleifenzählers um 1 vermeiden können. Das soll jetzt aber nur zur
Veranschaulichung dienen...)

Wenn man mehrere String-Verkettungen direkt hintereinander macht, ist der
Compiler übrigens "schlau" genug, hier nur einen StringBuffer zu verwenden.

Original:
  String a = "abc" + "def" + "ghi";

Kompilat:
  StringBuffer buffer = new StringBuffer("abc");
  buffer.append("def");
  buffer.append("ghi");
  String a = buffer.toString();

Aber das macht der Compiler halt wirklich nur in diesem speziellen Fall,
in dem die String-Verkettungen direkt (und fest) hintereinander erfolgen...

Gruß
Slyh