Chúng ta có thể tạo byte không dấu trong Java không

Tôi đang cố gắng chuyển đổi một byte đã ký trong unsign. Vấn đề là dữ liệu tôi đang nhận không được ký và Java không hỗ trợ byte không dấu, vì vậy khi đọc dữ liệu, nó xử lý nó như đã ký.

Tôi đã thử chuyển đổi nó bằng giải pháp sau đây tôi nhận được từ Stack Overflow.

public static int unsignedToBytes(byte a)
{
    int b = a & 0xFF;
    return b;
}

Nhưng khi một lần nữa nó được chuyển đổi theo byte, tôi nhận được cùng một dữ liệu đã ký. Tôi đang cố gắng sử dụng dữ liệu này làm tham số cho một hàm của Java chỉ chấp nhận một byte làm tham số, vì vậy tôi không thể sử dụng bất kỳ loại dữ liệu nào khác. Làm thế nào tôi có thể khắc phục vấn đề này?

Tôi không chắc là tôi hiểu câu hỏi của bạn.

Tôi vừa thử cái này và với byte -12 (giá trị đã ký), nó trả về số nguyên 244 (tương đương với giá trị byte không dấu nhưng được gõ dưới dạng int):

  public static int unsignedToBytes(byte b) {
    return b & 0xFF;
  }

  public static void main(String[] args) {
    System.out.println(unsignedToBytes((byte) -12));
  }

Có phải đó là những gì bạn muốn làm?

Java không cho phép biểu thị 244 dưới dạng bytegiá trị, như C. Để thể hiện các số nguyên dương ở trên Byte.MAX_VALUE(127), bạn phải sử dụng một loại số nguyên khác, như short, inthoặc long.

Thực tế là các nguyên hàm được ký trong Java không liên quan đến cách chúng được biểu thị trong bộ nhớ / chuyển tuyến - một byte chỉ là 8 bit và bạn có hiểu đó là phạm vi đã ký hay không là tùy thuộc vào bạn. Không có cờ ma thuật nào để nói "cái này được ký" hay "cái này không dấu".

Khi các nguyên thủy được ký, trình biên dịch Java sẽ ngăn bạn gán giá trị cao hơn +127 cho một byte (hoặc thấp hơn -128). Tuy nhiên, không có gì ngăn bạn hạ thấp một int (hoặc ngắn) để đạt được điều này:

int i = 200; // 0000 0000 0000 0000 0000 0000 1100 1000 (200)
byte b = (byte) 200; // 1100 1000 (-56 by Java specification, 200 by convention)

/*
 * Will print a negative int -56 because upcasting byte to int does
 * so called "sign extension" which yields those bits:
 * 1111 1111 1111 1111 1111 1111 1100 1000 (-56)
 *
 * But you could still choose to interpret this as +200.
 */
System.out.println(b); // "-56"

/*
 * Will print a positive int 200 because bitwise AND with 0xFF will
 * zero all the 24 most significant bits that:
 * a) were added during upcasting to int which took place silently
 *    just before evaluating the bitwise AND operator.
 *    So the `b & 0xFF` is equivalent with `((int) b) & 0xFF`.
 * b) were set to 1s because of "sign extension" during the upcasting
 *
 * 1111 1111 1111 1111 1111 1111 1100 1000 (the int)
 * &
 * 0000 0000 0000 0000 0000 0000 1111 1111 (the 0xFF)
 * =======================================
 * 0000 0000 0000 0000 0000 0000 1100 1000 (200)
 */
System.out.println(b & 0xFF); // "200"

/*
 * You would typically do this *within* the method that expected an 
 * unsigned byte and the advantage is you apply `0xFF` only once
 * and than you use the `unsignedByte` variable in all your bitwise
 * operations.
 *
 * You could use any integer type longer than `byte` for the `unsignedByte` variable,
 * i.e. `short`, `int`, `long` and even `char`, but during bitwise operations
 * it would get casted to `int` anyway.
 */
void printUnsignedByte(byte b) {
    int unsignedByte = b & 0xFF;
    System.out.println(unsignedByte); // "200"
}

Ngôn ngữ Java không cung cấp bất cứ thứ gì như unsignedtừ khóa. A bytetheo đặc tả ngôn ngữ đại diện cho một giá trị trong khoảng −128 - 127. Chẳng hạn, nếu a byteđược truyền tới intJava sẽ diễn giải bit đầu tiên là phần mở rộng dấu và sử dụng dấu .

Điều đó đang được nói, không có gì ngăn cản bạn xem byteđơn giản là 8 bit và diễn giải các bit đó thành giá trị trong khoảng từ 0 đến 255. Hãy nhớ rằng bạn không thể làm gì để buộc bạn phải giải thích theo phương pháp của người khác. Nếu một phương thức chấp nhận a byte, thì phương thức đó chấp nhận một giá trị trong khoảng từ −128 đến 127 trừ khi có quy định rõ ràng khác.

Dưới đây là một số chuyển đổi / thao tác hữu ích để thuận tiện cho bạn:

Chuyển đổi sang / từ int

// From int to unsigned byte
int i = 200;                    // some value between 0 and 255
byte b = (byte) i;              // 8 bits representing that value

// From unsigned byte to int
byte b = 123;                   // 8 bits representing a value between 0 and 255
int i = b & 0xFF;               // an int representing the same value

(Hoặc, nếu bạn đang dùng Java 8+, hãy sử dụng Byte.toUnsignedInt.)

Phân tích cú pháp / định dạng

Cách tốt nhất là sử dụng các chuyển đổi trên:

// Parse an unsigned byte
byte b = (byte) Integer.parseInt("200");

// Print an unsigned byte
System.out.println("Value of my unsigned byte: " + (b & 0xFF));

Mỹ phẩm

Biểu diễn 2 phần bổ sung "chỉ hoạt động" để cộng, trừ và nhân:

// two unsigned bytes
byte b1 = (byte) 200;
byte b2 = (byte) 15;

byte sum  = (byte) (b1 + b2);  // 215
byte diff = (byte) (b1 - b2);  // 185
byte prod = (byte) (b2 * b2);  // 225

Bộ phận yêu cầu chuyển đổi thủ công các toán hạng:

byte ratio = (byte) ((b1 & 0xFF) / (b2 & 0xFF));

Không có byte không dấu nguyên thủy trong Java. Điều thông thường là chuyển nó thành loại lớn hơn:

int anUnsignedByte = (int) aSignedByte & 0xff;

Tôi nghĩ rằng các câu trả lời khác đã trình bày về bộ nhớ và cách bạn xử lý chúng phụ thuộc vào bối cảnh bạn dự định sử dụng nó như thế nào. Tôi sẽ thêm rằng Java 8 đã thêm một số hỗ trợ để xử lý các kiểu không dấu . Trong trường hợp này, bạn có thể sử dụngByte.toUnsignedInt

int unsignedInt = Byte.toUnsignedInt(myByte);

Một ghi chú bên cạnh, nếu bạn muốn in nó ra, bạn chỉ có thể nói

byte b = 255;
System.out.println((b < 0 ? 256 + b : b));

Nếu nghĩ rằng bạn đang tìm kiếm một cái gì đó như thế này.

public static char toUnsigned(byte b) {
    return (char) (b >= 0 ? b : 256 + b);
}

Adamski cung cấp câu trả lời tốt nhất, nhưng nó chưa hoàn chỉnh, vì vậy hãy đọc câu trả lời của anh ấy, vì nó giải thích chi tiết tôi không biết.

Nếu bạn có một hàm hệ thống yêu cầu một byte không dấu được truyền cho nó, bạn có thể truyền một byte đã ký vì nó sẽ tự động coi nó là một byte không dấu.

Vì vậy, nếu một hàm hệ thống yêu cầu bốn byte, ví dụ 192 168 0 1 dưới dạng các byte không dấu, bạn có thể vượt qua -64 -88 0 1 và hàm vẫn sẽ hoạt động, bởi vì hành động chuyển chúng đến hàm sẽ không ký chúng .

Tuy nhiên, bạn không có khả năng gặp vấn đề này vì các hàm hệ thống bị ẩn sau các lớp để tương thích đa nền tảng, mặc dù một số phương thức đọc java.io trả về các byte không được ghi là int.

Nếu bạn muốn thấy điều này hoạt động, hãy thử viết các byte đã ký vào một tệp và đọc lại chúng dưới dạng các byte không dấu.

Bạn cũng có thể:

public static int unsignedToBytes(byte a)
{
    return (int) ( ( a << 24) >>> 24);
}    

Giải trình:

hãy cùng nói nào a = (byte) 133;

Trong bộ nhớ, nó được lưu dưới dạng: "1000 0101" (0x85 ở dạng hex)

Vì vậy, đại diện của nó dịch unsign = 133, đã ký = -123 (dưới dạng bổ sung 2)

một << 24

Khi dịch chuyển trái được thực hiện 24 bit sang trái, kết quả bây giờ là số nguyên 4 byte được biểu diễn dưới dạng:

"10000101 00000000 00000000 00000000" (hoặc "0x85000000" ở dạng hex)

sau đó chúng tôi có

(một << 24) >>> 24

và nó dịch chuyển một lần nữa vào đúng 24 bit nhưng lấp đầy các số 0 đứng đầu. Vì vậy, nó dẫn đến:

"00000000 00000000 00000000 10000101" (hoặc "0x00000085" ở dạng hex)

và đó là biểu diễn không dấu bằng 133.

Nếu bạn đã cố gắng truyền a = (int) a; thì điều gì sẽ xảy ra là nó giữ biểu diễn phần bù 2 của byte và lưu nó dưới dạng phần bù của 2:

(int) "10000101" ---> "11111111 11111111 11111111 10000101"

Và nó được dịch là: -123

Tôi đang cố gắng sử dụng dữ liệu này làm tham số cho hàm của Java, chỉ chấp nhận một byte làm tham số

Điều này không khác biệt cơ bản với một hàm chấp nhận một số nguyên mà bạn muốn truyền một giá trị lớn hơn 2 ^ 32-1.

Nghe có vẻ như nó phụ thuộc vào cách xác định và ghi lại chức năng; Tôi có thể thấy ba khả năng:

1. Nó có thể tài liệu rõ ràng rằng hàm xử lý byte như một giá trị không dấu, trong trường hợp đó, hàm có thể sẽ làm những gì bạn mong đợi nhưng dường như được thực hiện sai. Đối với trường hợp số nguyên, hàm có thể sẽ khai báo tham số là số nguyên không dấu, nhưng điều đó là không thể đối với trường hợp byte.

2. Nó có thể chứng minh rằng giá trị cho đối số này phải lớn hơn (hoặc có thể bằng) 0, trong trường hợp đó bạn đang sử dụng sai hàm (truyền tham số ngoài phạm vi), hy vọng nó sẽ làm được nhiều hơn so với thiết kế làm Với một số mức hỗ trợ gỡ lỗi, bạn có thể mong đợi hàm sẽ đưa ra một ngoại lệ hoặc không xác nhận.

3. Tài liệu có thể không nói gì, trong trường hợp đó, một tham số âm là, một tham số âm và liệu điều đó có ý nghĩa gì hay không phụ thuộc vào chức năng của nó. Nếu điều này là vô nghĩa thì có lẽ chức năng thực sự cần được định nghĩa / ghi lại là (2). Nếu điều này có ý nghĩa theo cách không gây khó chịu (ví dụ: các giá trị không âm được sử dụng để lập chỉ mục thành một mảng và các giá trị âm được sử dụng để lập chỉ mục từ cuối mảng, do đó -1 có nghĩa là phần tử cuối cùng), tài liệu sẽ nói nó là gì có nghĩa là và tôi hy vọng rằng đó không phải là những gì bạn muốn nó làm gì.

Nếu bạn có một hàm phải được truyền một byte đã ký, bạn mong đợi nó sẽ làm gì nếu bạn truyền một byte không dấu?

Tại sao bạn không thể sử dụng bất kỳ loại dữ liệu khác?

Thông thường, bạn có thể sử dụng một byte như một byte không dấu với đơn giản hoặc không có bản dịch. Tất cả phụ thuộc vào cách nó được sử dụng. Bạn sẽ cần phải làm rõ những gì bạn muốn làm với nó.

Mặc dù có vẻ khó chịu (đến từ C) rằng Java không bao gồm byte không dấu trong ngôn ngữ nhưng thực sự nó không phải là vấn đề lớn vì một thao tác "b & 0xFF" đơn giản mang lại giá trị không dấu cho byte b (đã ký) trong (hiếm) tình huống mà nó thực sự cần thiết Các bit không thực sự thay đổi - chỉ diễn giải (điều này chỉ quan trọng khi thực hiện ví dụ một số phép toán trên các giá trị).

Không có byte không dấu trong Java, nhưng nếu bạn muốn hiển thị một byte, bạn có thể làm,

int myInt = 144;

byte myByte = (byte) myInt;

char myChar = (char) (myByte & 0xFF);

System.out.println("myChar :" + Integer.toHexString(myChar));

Đầu ra:

myChar : 90

Để biết thêm thông tin, vui lòng kiểm tra, Cách hiển thị giá trị hex / byte trong Java .

Theo giới hạn trong Java, byte không dấu gần như không thể ở định dạng kiểu dữ liệu hiện tại. Bạn có thể tìm một số thư viện khác của ngôn ngữ khác cho những gì bạn đang triển khai và sau đó bạn có thể gọi chúng bằng JNI .

Có và không. Ive đã đào xung quanh với vấn đề này. Giống như tôi hiểu điều này:

Thực tế là java đã ký interger -128 đến 127 .. Có thể trình bày một dấu không dấu trong java với:

public static int toUnsignedInt(byte x) {
    return ((int) x) & 0xff;
}

Ví dụ, nếu bạn thêm -12 số đã ký thành không dấu, bạn sẽ nhận được 244. Nhưng bạn có thể sử dụng lại số đó trong chữ ký, nó phải được chuyển trở lại thành đã ký và nó sẽ lại là -12.

Nếu bạn cố gắng thêm 244 vào byte java, bạn sẽ nhận được outOfIndexException.

Chúc mừng ..

Nếu bạn muốn các byte không dấu trong Java, chỉ cần trừ 256 từ số bạn quan tâm. Nó sẽ tạo ra hai phần bù có giá trị âm, là số mong muốn trong các byte không dấu.

Thí dụ:

int speed = 255; //Integer with the desired byte value
byte speed_unsigned = (byte)(speed-256);
//This will be represented in two's complement so its binary value will be 1111 1111
//which is the unsigned byte we desire.

Bạn cần sử dụng các bản hack bẩn như vậy khi sử dụng leJOS để lập trình gạch NXT .