Byte của một chuỗi trong Java

Trong Java, nếu tôi có Chuỗi x, làm cách nào tôi có thể tính được số byte trong chuỗi đó?

Chuỗi là danh sách các ký tự (tức là các điểm mã). Số lượng byte được lấy để thể hiện chuỗi phụ thuộc hoàn toàn vào mã hóa mà bạn sử dụng để biến nó thành byte .

Điều đó nói rằng, bạn có thể biến chuỗi thành một mảng byte và sau đó xem kích thước của nó như sau:

// 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"

Vì vậy, bạn thấy, ngay cả một chuỗi "ASCII" đơn giản cũng có thể có số byte khác nhau trong biểu diễn của nó, tùy thuộc vào mã hóa nào được sử dụng. Sử dụng bất kỳ bộ ký tự nào bạn quan tâm cho trường hợp của mình, làm đối số getBytes(). Và đừng rơi vào cái bẫy giả định rằng UTF-8 đại diện cho mỗi ký tự dưới dạng một byte, vì điều đó cũng không đúng:

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 "????")

(Lưu ý rằng nếu bạn không cung cấp đối số bộ ký tự, bộ ký tự mặc định của nền tảng sẽ được sử dụng. Điều này có thể hữu ích trong một số ngữ cảnh, nhưng nói chung, bạn nên tránh tùy thuộc vào mặc định và luôn sử dụng bộ ký tự rõ ràng khi mã hóa / cần giải mã.)

Nếu bạn đang chạy với các tham chiếu 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

Nói cách khác:

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

Trên máy ảo 32 bit hoặc máy ảo 64 bit có OOP được nén (-XX: + UseCompressionOops), các tham chiếu có 4 byte. Vì vậy, tổng số sẽ là:

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

Điều này không tính đến các tham chiếu đến đối tượng chuỗi.

Câu trả lời mang tính mô phạm (mặc dù không nhất thiết là câu trả lời hữu ích nhất, tùy thuộc vào kết quả bạn muốn làm với kết quả) là:

string.length() * 2

Các chuỗi Java được lưu trữ vật lý trong UTF-16BEmã hóa, sử dụng 2 byte cho mỗi đơn vị mã và String.length()đo độ dài tính theo đơn vị mã UTF-16, do đó, điều này tương đương với:

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

Và điều này sẽ cho bạn biết kích thước của charmảng bên trong , tính bằng byte .

Lưu ý: "UTF-16"sẽ cho kết quả khác "UTF-16BE"với mã hóa trước sẽ chèn BOM , thêm 2 byte vào chiều dài của mảng.

Theo Cách chuyển đổi Chuỗi sang và từ mảng byte UTF8 trong Java :

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

Một Stringthể hiện phân bổ một lượng byte nhất định trong bộ nhớ. Có lẽ bạn đang xem một cái gì đó giống như sizeof("Hello World")sẽ trả về số byte được phân bổ bởi chính cơ sở hạ tầng?

Trong Java, thường không cần sizeofhàm, vì chúng ta không bao giờ phân bổ bộ nhớ để lưu trữ cấu trúc dữ liệu. Chúng ta có thể xem String.javatệp để ước tính sơ bộ và chúng ta thấy một số 'int', một số tài liệu tham khảo và a char[]. Đặc tả ngôn ngữ Java định nghĩa, một charphạm vi từ 0 đến 65535, vì vậy hai byte là đủ để giữ một char trong bộ nhớ. Nhưng một JVM không phải lưu trữ một char trong 2 byte, nó chỉ phải đảm bảo rằng việc triển khai charcó thể giữ các giá trị của phạm vi xác định.

Vì vậy, sizeofthực sự không có ý nghĩa gì trong Java. Nhưng, giả sử rằng chúng ta có một Chuỗi lớn và một charphân bổ hai byte, thì dấu chân bộ nhớ của một Stringđối tượng ít nhất là 2 * str.length()bằng byte.

Có một phương thức gọi là getBytes () . Sử dụng nó một cách rộng rãi .

Thử cái này :

Bytes.toBytes(x).length

Giả sử bạn đã khai báo và khởi tạo x trước

Để tránh bị bắt, hãy sử dụng:

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