Mal wieder vergleichen von Strings.[Leider noch ein Problem]

[Yezariael]

Hallo allerseits,

auf die Gefahr hin das mich jetzt ganz viele Leute aus dem Forum scheuchen mal folgende Frage.

Ich habe zwei Objekte.

Zum einen einen String welcher aus einem UDP DatagramPacket ausgelesen wird.

Das erfolgt folgendermaßen:

buffer = _packet.getData();
		length = buffer.length;
		message = new String(buffer, 0, length);

Der Inhalt dieses Strings ist "LOGIN" (ohne "").

Diesen String vergleiche ich mit einem Objekt meiner eigenen Query Klasse. Darin wird das Objekt folgendermaßen initialisiert.

public static String LOGIN   = "LOGIN";

Die Abfrage sieht folgendermaßen aus:

if (Query.LOGIN.equalsIgnoreCase(message));
{ usw. usw. }

Das Problem ist, das selbst wenn der String aus dem DatagramPacket nicht LOGIN sondern LOGOUT lautet
wird die oben genannte If-Abfrage ausgeführt. Ich habe mir beide Strings in der Konsole ausgeben lassen und bekomme für den einen folgerichtig LOGIN und für den anderen LOGOUT zurück. Trotzdem werden sie von Java als "gleich" angesehen.

Ich weiß langsam nicht mehr weiter.

Vielen Dank schonmal

Gruß

Yezariael

 

[The_S]

Der Strichpunkt hinter deiner if-Abfrage muss weg.

 

[Yezariael]

Oh... :roll: :roll:

Schande über mich. Da sitzt man davor und grübelt und grübelt und sieht den kleinsten Fehler nicht.

Vielen vielen Dank.

Besten Gruß

Yezariael

EDIT :

Okay jetzt sind wir wohl beim eigentlichen Problem angekommen.
Jetzt wird die Abfrage garnicht mehr getriggered. Ergo. Die beiden Strings werden, obwohl laut Konsole und von der Logik her vollkommen identisch, nicht als equals angesehen.

Was mich weiter irritiert. Ich nutze eine aktuelle Eclipse Version und wenn ich die beiden in der Konsole ausgeben werden von Eclipse unterschiedliche Schriftarten verwendet...Sollte mir das etwas sagen?

Danke und Gruß

 

[FArt]

Schau mal nach Whitespaces...

 

[ARadauer]

von Eclipse unterschiedliche Schriftarten verwendet

kannst du von dem bitte einen screenshot posten? das würde ich gerne sehen

 

[ARadauer]

bzw lass dir mal die werte der einzelnen chars ausgeben..

      String test = "test";      
      for(int i = 0; i <test.length(); i++){
         System.out.println((int)test.charAt(i));
      }

da ist sicher wo was drin, was du nicht siehst...

 

[Yezariael]

Schau mal nach Whitespaces...

Whitespaces sind keine drin. Das hab ich schon 3x gegen gechecked ^^

Screenshot sieht folgendermaßen aus:

 

[Yezariael]

bzw lass dir mal die werte der einzelnen chars ausgeben..

da ist sicher wo was drin, was du nicht siehst...

Hmm Okay
da kommt wirklich was seltsames bei rum.

Das ist der aus dem Query.LOGIN Objekt entnommene String
76
79
71
73
78
0
0
0
0
--- > ab hier könnt ihr euch noch um die 100-200 Nullen denken

Ende des Tests für DatagramPacket String

76
79
71
73
78
Ende des Tests für Query.LOGIN Objekt

Ergo. Das Datagram wird richtig ausgelesen.

Das Query Objekt erzeugt einen Haufen Müll.

Ich kanns mir nur einfach nicht erklären.
Das Objekt wird wie oben schonmal gesagt so initialisiert:

public class Query
{
public static String LOGIN   = "LOGIN";
[....] }

und dann über Query.LOGIN aufgerufen.
Woher also die ganzen nullen?

Prinzipiell sollten Sie identisch sein, da das DatagramPacket auch seinen Inhalt aus dem Query Objekt bezieht.
Nämlich über

buffer = Query.LOGIN.getBytes();
		length = buffer.length;
		
		packet = new DatagramPacket(buffer, length, address, requestPort);

Das wird dann verschickt und auf der anderen Seite wieder ausgepackt. Und dabei kommt ja, oben gesehen, Char-technisch was vernünftiges raus.

 

[The_S]

Wenn du keine Whitespaces hast und die beiden Strings ansonsten komplett identisch sind, hast du nen sehr merkwürdigen Fehler ...

 

[The_S]

Sicher, dass die Ausgabe mit den vielen 0en nicht doch das vom Datagramm ist? Das wär zumindest erklärbarer

 

[Yezariael]

Sicher, dass die Ausgabe mit den vielen 0en nicht doch das vom Datagramm ist? Das wär zumindest erklärbarer icon_wink.gif

Stimmt. steht ja oben in der Auswertung auch so.
Ich komm schon ganz durcheinander :autsch:

Erklären kann (ich zumindest) es mir leider doch nicht.

Vielleicht habt ihr ja noch eine Idee wo die ganzen Nullen herkommen und was man dagegen tun kann.

Danke schonmal für die viele Hilfe, ich verzweifel langsam

 

[The_S]

Dann poste doch mal (ohne durcheinander zu kommen) genau wie du die Daten versendest und wie du sie versendest. Und welcher Wert der String unmittelbar vor, und welchen Wert unmittelbar nach dem versenden hat.

 

[Yezariael]

Ganzen aufbereiteten Code wieder rausgelöscht:

Okay, ich glaube ich habe den Fehler gefunden.

Zum Empfang von Paketen initialisere ich ein DatagramPacket folgendermaßen:

byte[] ReadBuffer;
ReadBuffer = new byte[500];
ReadPacket = new DatagramPacket(ReadBuffer, ReadBuffer.length);

Daher die fixe Größe von 500.

Wenn ich eine empfangene Nachricht dann in einen String verpacke...

buffer = _packet.getData();
length = buffer.length;
message = new String(buffer, 0, length);

und dann folgendes auslese:

System.out.println(message.length());

Bekomme ich als Ausgabe : 500.

Gefahr erkannt, Gefahr gebannt?

Wie kann ich das denn anderweitig lösen?

Ziel ist es den Nachrichten eine maximale Länge von 500 bytes aufzuzwingen.
Wie schaffe ich es das er mir dennoch die Strings nicht endlos auffüllt?

 

[FArt]

Vergleiche mal die byte[] der Strings...

 

[tuxedo]

>> Wie kann ich das denn anderweitig lösen?

In das Paket VOR dem String reinschreiben, wie lang der String ist .. Kannst du z.B. sicher sein, dass der String nie >256 Zeichen lang ist, kannst du das erste Byte des Paketes hierfür missbrauchen. Ansonsten halt ein short (2byte) oder integer (4byte) nehmen.

- Alex

 

[Yezariael]

In das Paket VOR dem String reinschreiben, wie lang der String ist .. Kannst du z.B. sicher sein, dass der String nie >256 Zeichen lang ist, kannst du das erste Byte des Paketes hierfür missbrauchen. Ansonsten halt ein short (2byte) oder integer (4byte) nehmen.

Hey,

könntest du mir das vielleicht ein klein wenig erklären?

Das Problem ist, zum einen weiß ich nicht im vorraus wie lang der String sein wird.
Zum anderen _muss_ ich vorher das byte Array mit irgendeiner Größe initialisieren um überhaupt ein datagramPacket empfangen zu können.

Stecke also gewissermaßen in einer Zwickmühle.

Danke und Gruß

Yezariael

 

[tuxedo]

Na in dem moment wo du den String in das Paket reinsteckst weißt du doch wie lang er ist?!

int length = myString.lenght();

Dann machst du aus dem String bytes:

bytes[] myStringAsBytes = myString.getBytes();

Und dann kommt das ganze in das Paket:

byte[] dataPacket = new byte[500];
dataPacket [0] = (byte) ((length >>> 24) & 0xFF);
dataPacket [1] = (byte) ((length >>> 16) & 0xFF);
dataPacket [2] = (byte) ((length >>> 08) & 0xFF);
dataPacket [3] = (byte) ((length >>> 00) & 0xFF);
System.arrayCopy(myStringAsBytes, 0, dataPacket, 4, length);

Fertig.

Rückwärts machst du das mit dem Integer dann in der anderen Richtung:

int ch1 = dataPacket[0];
int ch2 = dataPacket[1];
int ch3 = dataPacket[2];
int ch4 = dataPacket[3];
int length = ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
byte[] stringAsBytes = new byte[length];
System.arrayCopy(dataPacket, 4, stringAsBytes, 0, length);
String myString = new String(stringAsBytes);

Fertig..

Natürlich sollte man auch noch das entsprechende Encoding des Strings beachten.. Aber die geposteten Codezeilen sollten dich jedenfalls mal weiter bringen.

btw: Schau doch mal in den Source von DataInputStream und DataOutputStream... Da kannst du abgucken wie man aus primitiven Datentypen bytes macht und umgekehrt.

- Alex

 

[Yezariael]

Na in dem moment wo du den String in das Paket reinsteckst weißt du doch wie lang er ist?!

Ja das schon.
Aber die Grundproblematik sieht anders aus.

Beim Sender wird der String in ein DatagramPacket gesteckt. Das ist richtig.

Das erfolgt über

byteArray = String xy.getBytes();

und die länge wird über

byteArray.length();

ermittelt.

Das Problem das ich habe ist, das ich auf Empfänger Seite dem ByteArray
des DatagramPackets eine Größe geben muss um überhaupt in der Lage zu sein ein Paket zu empfangen.

Und _bevor_ ich das Paket auf der Empfänger Seite empfange weiß die Empfänger Seite leider auch nicht
wie lang der String ist.



Das ist die Zwickmühle die ich meinte.

Daher ist die eigentliche Problemstellung, wie ich es schaffe aus einem "zu großen" Byte Array nur den eigentlich darin
enthaltenen String auszulesen um diesen dann mit einem anderen zu vergleichen.

Gruß

Yezariael

 

[tuxedo]

Na wenn du beim Senden das Array mit der größe 500 erstellst, solltest du auch beim Empfangen mit 500 arbeiten ...

Wenn die zu versendenden Daten eben über 500 byte groß sind, musst du dir ein Protokoll einfallen lassen, dass die Daten in max 500 byte große Pakete zerteilt. Und der empfänger muss dann gemäß Protokoll die Pakete wieder zusammensetzen.

Dass DAS nicht trivial ist, sieht man ganz gut an den Streaming-Protokollen welche auf UDP basieren ...

- Alex