String length nicht gleich der Ausgabe

[Fohnbit]

Hallo,

ich bekomme von einer Methode einen String: res

Prüfe ich den String mittels: res.length() erhalte ich immer 73 ... das passt.

Ich benötige aber die Bytes in einem bytebuffer:
ByteBuffer bb = ByteBuffer.wrap(res.getBytes());

Die Capacity von bb variiert aber :-(

Einmal 93, dann wieder mal 105, ...

Auch wenn ich den String in ein Byte Array lege, ist die Anzahl nicht der Länge des Strings:
byte[] b = res.getBytes();

Debuge ich, sehe ich im String aber immer eine Länge von 73.

Wo liegt mein Fehler?

Ich benötige die 73 Bytes des Strings.

Danke

 

[stg]

Du fragst den falschen Wert ab. Die Capacity bezeichnet ... ja genau, die Kapazität des Buffers, also die Anzahl an Bytes die du hineinschreiben kannst, bis er voll ist (bevor ich hier zerpflückt werde: Das ist nur die halbe Wahrheit, siehe zusätzlich noch ByteBuffer#limit)
Was du hingegen abfragen willst, ist offenbar die position. Siehe https://docs.oracle.com/javase/7/docs/api/java/nio/Buffer.html#position()

 

[Fohnbit]

Hallo,

also ich benötige die 73 Bytes vom String im Bytebuffer.

Aber auch wenn ich ein bytes Array erzeuge, ist die Größe nicht der des Strings:
String length: 73
byte[] b = res.getBytes();
b length = 95 bis 105

Warum ist das aber so?

 

[kneitzel]

Also ein Zeichen ist nicht gleich ein Byte! Diese Annahme von Dir ist von Grund auf falsch. Bei den üblichen UTF Codierungen kann ein Zeichen bis zu 4 Bytes groß sein. UTF-8 oder UTF-16 bedeutet nur, dass die kleinste "Einheit" eben 8 oder 16 Bit groß sind.

Das getBytes nutzt das default charset. Das ist meist UTF-8.

 

[stg]

Ach, jetzt versteh ich dein Problem. Du musst dir einfach im klaren darüber sein, dass zb in UTF 8 nicht alle Strings nur ein Byte groß sind, sondern tatsächlich teilweise 2,3 oder auch 4 Bytes benötigt werden, um einen einzelnen char abzuspeiuchern

Edit: Da war kneitzel schneller

 

[Xyz1]

Je nachdem, welche speziellen Zeichen da drin sind, hält ByteBuffer, String, byte[] und Dateisystem unterschiedlich viele Bytes.

Edit:

    /**
     * @author DerWissende on 03/22/2016
     * @param args
     */
    public static void main(String[] args) {
        String s = "Hallo";
        System.out.println(s + " " + enthaeltSpezChars(s));
        s = "Gemüse";
        System.out.println(s + " " + enthaeltSpezChars(s));
        s = "LeUtNaNt DeR bInNeNsChIfFfAhRt";
        System.out.println(s + " " + enthaeltSpezChars(s));
        s = "ae_oe_ue_aeu";
        System.out.println(s + " " + enthaeltSpezChars(s));
        s = "Dia'rhoe";
        System.out.println(s + " " + enthaeltSpezChars(s));
    }

    private static boolean enthaeltSpezChars(String string) {
        return string.getBytes().length != string.length();
    }

 

[Fohnbit]

Ah, ok.
Danke!

Ich bekomme von einer TCP Verbindung den String.

Mittels:
b = res.getBytes("ISO-8859-1");

erhalte ich nun die 73 Bytes.

 

[kneitzel]

Also den String bekommst Du von einer tcp Verbindung? Da wäre ich jetzt aber generell etwas vorsichtiger, denn das hört sich nun doch etwas wenig durchdacht an. Technisch gehen da halt byte-Arrays über das Netz. Die wurden dann zu einem String (mittels eines Encodings) und nun wandelst Du das (ggf. über ein anderes Encoding) wieder zurück?

Da hätte ich jetzt Bauchschmerzen mit, denn die byte-Arrays, die Du bekommst sind nicht unbedingt die byte-Arrays, die Du mal empfangen hast.

 

[Xyz1]

erhalte ich nun die 73 Bytes.

Ja, liegt dann wohl am Encoding oder?

Btw., spielt das für dich eine Rolle, wie viele Bytes übertragen werden? Dann wäre gzip vielleicht genau das richtige für dich.

 

[Fohnbit]

Hallo,

hatten es damals für ein JSON geschrieben ... daher String als Rückgabe.

Haben nun bytes[] hinzugefügt und wird nun ohne Probleme zurück gegeben.

String und Byte muss ich mir aber noch mal genauer anschauen.

Dank!

 

[Xyz1]

Du bräuchtest soetwas:

    /**
     * @author DerWissende on 03/22/2016
     * @param args
     */
    public static void main(String[] args) throws IOException {
        String s = "Hallo\nGemüse\nLeUtNaNt DeR bInNeNsChIfFfAhRt\nae_oe_ue_aeu\nDia'rhoe\n";
        System.out.println("s = " + s);
        s = compress(s);
        System.out.println("s = " + s);
        s = decompress(s);
        System.out.println("s = " + s);
    }

s = Hallo
Gemüse
LeUtNaNt DeR bInNeNsChIfFfAhRt
ae_oe_ue_aeu
Dia'rhoe

s = (Zeichensalat)

s = Hallo
Gemüse
LeUtNaNt DeR bInNeNsChIfFfAhRt
ae_oe_ue_aeu
Dia'rhoe

Zeichensalat ist dann meist kürzer als String s.

Ich bekomme von einer TCP Verbindung den String.

String oder Byte? Ich tippe auf Byte. Dann liegt alles an Encoding. Aber da bräuchten wir mehr Informationen von dir.

Die transportorientierte Netzwerkschicht macht aber nochmal etwas ganz anderes aus dem String.