Bytes dari sebuah string di Java

Di Jawa, jika saya memiliki sebuah String x, bagaimana saya bisa menghitung jumlah byte dalam string itu?

String adalah daftar karakter (yaitu titik kode). Jumlah byte yang diambil untuk mewakili string sepenuhnya tergantung pada pengkodean yang Anda gunakan untuk mengubahnya menjadi byte .

Yang mengatakan, Anda dapat mengubah string menjadi array byte dan kemudian lihat ukurannya sebagai berikut:

// The input string for this test
final String string = "Hello World";

// Check length, in characters
System.out.println(string.length()); // prints "11"

// Check encoded sizes
final byte[] utf8Bytes = string.getBytes("UTF-8");
System.out.println(utf8Bytes.length); // prints "11"

final byte[] utf16Bytes= string.getBytes("UTF-16");
System.out.println(utf16Bytes.length); // prints "24"

final byte[] utf32Bytes = string.getBytes("UTF-32");
System.out.println(utf32Bytes.length); // prints "44"

final byte[] isoBytes = string.getBytes("ISO-8859-1");
System.out.println(isoBytes.length); // prints "11"

final byte[] winBytes = string.getBytes("CP1252");
System.out.println(winBytes.length); // prints "11"

Jadi Anda lihat, bahkan string "ASCII" yang sederhana dapat memiliki jumlah byte yang berbeda dalam representasinya, tergantung pada pengkodean mana yang digunakan. Gunakan set karakter apa pun yang Anda minati untuk kasus Anda, sebagai argumen untuk getBytes(). Dan jangan terjebak dalam anggapan bahwa UTF-8 mewakili setiap karakter sebagai satu byte, karena itu juga tidak benar:

final String interesting = "\uF93D\uF936\uF949\uF942"; // Chinese ideograms

// Check length, in characters
System.out.println(interesting.length()); // prints "4"

// Check encoded sizes
final byte[] utf8Bytes = interesting.getBytes("UTF-8");
System.out.println(utf8Bytes.length); // prints "12"

final byte[] utf16Bytes= interesting.getBytes("UTF-16");
System.out.println(utf16Bytes.length); // prints "10"

final byte[] utf32Bytes = interesting.getBytes("UTF-32");
System.out.println(utf32Bytes.length); // prints "16"

final byte[] isoBytes = interesting.getBytes("ISO-8859-1");
System.out.println(isoBytes.length); // prints "4" (probably encoded "????")

final byte[] winBytes = interesting.getBytes("CP1252");
System.out.println(winBytes.length); // prints "4" (probably encoded "????")

(Perhatikan bahwa jika Anda tidak memberikan argumen set karakter, set karakter default platform digunakan. Ini mungkin berguna dalam beberapa konteks, tetapi secara umum Anda harus menghindari bergantung pada default, dan selalu menggunakan set karakter eksplisit ketika meng-encode / diperlukan decoding.)

Jika Anda menjalankan dengan referensi 64-bit:

sizeof(string) = 
8 + // object header used by the VM
8 + // 64-bit reference to char array (value)
8 + string.length() * 2 + // character array itself (object header + 16-bit chars)
4 + // offset integer
4 + // count integer
4 + // cached hash code

Dengan kata lain:

sizeof(string) = 36 + string.length() * 2

Pada VM 32-bit atau VM 64-bit dengan OOP terkompresi (-XX: + UseCompressedOops), referensi adalah 4 byte. Jadi totalnya adalah:

sizeof(string) = 32 + string.length() * 2

Ini tidak memperhitungkan referensi ke objek string.

Jawaban yang bertele-tele (meskipun tidak selalu yang paling berguna, tergantung pada apa yang ingin Anda lakukan dengan hasilnya) adalah:

string.length() * 2

String Java secara fisik disimpan dalam UTF-16BEencoding, yang menggunakan 2 byte per unit kode, dan String.length()mengukur panjangnya dalam unit kode UTF-16, jadi ini setara dengan:

final byte[] utf16Bytes= string.getBytes("UTF-16BE");
System.out.println(utf16Bytes.length);

Dan ini akan memberi tahu Anda ukuran chararray internal , dalam byte .

Catatan: "UTF-16"akan memberikan hasil yang berbeda dari "UTF-16BE"pengkodean sebelumnya akan memasukkan BOM , menambahkan 2 byte ke panjang array.

Menurut Cara mengkonversi Strings ke dan dari array byte UTF8 di Jawa :

String s = "some text here";
byte[] b = s.getBytes("UTF-8");
System.out.println(b.length);

Sebuah Stringinstance mengalokasikan sejumlah byte dalam memori. Mungkin Anda sedang melihat sesuatu seperti sizeof("Hello World")yang akan mengembalikan jumlah byte yang dialokasikan oleh datastructure itu sendiri?

Di Jawa, biasanya tidak perlu sizeoffungsi, karena kami tidak pernah mengalokasikan memori untuk menyimpan struktur data. Kita dapat melihat String.javafile untuk perkiraan kasar, dan kita melihat beberapa 'int', beberapa referensi dan a char[]. The spesifikasi bahasa Jawa mendefinisikan, bahwa charrentang 0-65.535, jadi dua byte yang cukup untuk menjaga satu char di memori. Tetapi JVM tidak harus menyimpan satu char dalam 2 byte, hanya harus menjamin, bahwa implementasi chardapat menyimpan nilai dari range yang didefinisikan.

Jadi sizeofbenar-benar tidak masuk akal di Jawa. Tetapi, dengan asumsi bahwa kita memiliki String besar dan satu charmengalokasikan dua byte, maka jejak memori suatu Stringobjek setidaknya 2 * str.length()dalam byte.

Ada metode yang disebut getBytes () . Gunakan dengan bijak .

Coba ini :

Bytes.toBytes(x).length

Dengan asumsi Anda menyatakan dan menginisialisasi x sebelumnya

Untuk menghindari mencoba menangkap, gunakan:

String s = "some text here";
byte[] b = s.getBytes(StandardCharsets.UTF_8);
System.out.println(b.length);