เราสามารถสร้างไบต์ที่ไม่ได้ลงนามใน Java

ฉันพยายามแปลงไบต์ที่ลงนามแล้วในแบบไม่ได้ลงชื่อ ปัญหาคือข้อมูลที่ฉันได้รับไม่ได้ลงนามและ Java ไม่รองรับไบต์ที่ไม่ได้ลงนามดังนั้นเมื่อมันอ่านข้อมูลที่ถือว่าเป็นข้อมูลที่ลงนามแล้ว

ฉันพยายามแปลงมันด้วยวิธีแก้ปัญหาต่อไปนี้ที่ฉันได้รับจาก Stack Overflow

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

แต่เมื่อมันถูกแปลงเป็นไบต์อีกครั้งฉันจะได้รับข้อมูลที่เซ็นชื่อเหมือนกัน ฉันกำลังพยายามใช้ข้อมูลนี้เป็นพารามิเตอร์ของฟังก์ชันของ Java ที่ยอมรับเฉพาะไบต์เป็นพารามิเตอร์ดังนั้นฉันจึงไม่สามารถใช้ชนิดข้อมูลอื่นได้ ฉันจะแก้ไขปัญหานี้ได้อย่างไร

ฉันไม่แน่ใจว่าฉันเข้าใจคำถามของคุณ

ฉันเพิ่งลองนี้และสำหรับไบต์ -12 (ค่าลงนาม) มันคืนจำนวนเต็ม 244 (เทียบเท่ากับค่าไบต์ไม่ได้ลงนาม แต่พิมพ์เป็นint):

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

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

คุณต้องการทำอะไร

Java ไม่อนุญาตให้แสดง 244 เป็นbyteค่าตามที่จะ C. เพื่อแสดงจำนวนเต็มบวกดังกล่าวข้างต้นByte.MAX_VALUE(127) ที่คุณต้องใช้ชนิดจำนวนเต็มอื่น ๆ เช่นshort, หรือintlong

ความจริงที่ว่าดั้งเดิมถูกลงชื่อใน Java ไม่เกี่ยวข้องกับวิธีที่พวกเขาแสดงในหน่วยความจำ / การขนส่ง - byte เป็นเพียง 8 บิตและไม่ว่าคุณจะตีความว่าเป็นช่วงที่ลงนามหรือไม่ขึ้นอยู่กับคุณ ไม่มีการตั้งค่าสถานะเวทย์มนตร์ที่จะพูดว่า "นี่คือการลงนาม" หรือ "นี่คือไม่ได้ลงนาม"

เนื่องจากการลงนามแบบดั้งเดิมนั้นคอมไพเลอร์ Java จะป้องกันคุณจากการกำหนดค่าที่สูงกว่า +127 ให้เป็นไบต์ (หรือต่ำกว่า -128) อย่างไรก็ตามไม่มีสิ่งใดที่จะหยุดคุณให้ลดระดับ int (หรือ short) เพื่อให้บรรลุสิ่งนี้:

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

คู่มือฉบับสมบูรณ์สำหรับการทำงานกับไบต์ที่ไม่ได้ลงนามใน Java:

ไบต์ที่ไม่ได้ลงนามใน Java

(ที่มาสำหรับคำตอบนี้)

ภาษาจาวาไม่ได้ให้อะไรเหมือนunsignedคำสำคัญ byteตามสเปคภาษาหมายถึงค่าระหว่าง -128 - 127 ตัวอย่างเช่นถ้าbyteถูกโยนไปยังintJava จะตีความบิตแรกเป็นสัญญาณและการใช้เครื่องหมายนามสกุล

ที่ถูกกล่าวว่าไม่มีอะไรป้องกันคุณจากการดูbyteเพียง 8 บิตและตีความบิตเหล่านั้นเป็นค่าระหว่าง 0 และ 255 เพียงจำไว้ว่าไม่มีอะไรที่คุณสามารถทำได้เพื่อบังคับให้การตีความของคุณตามวิธีการของคนอื่น หากวิธีการยอมรับ a byteแล้ววิธีนั้นจะยอมรับค่าระหว่าง −128 และ 127 เว้นแต่จะระบุไว้เป็นอย่างอื่นอย่างชัดเจน

นี่คือการแปลง / กิจวัตรที่มีประโยชน์เพื่อความสะดวกของคุณ:

การแปลงเป็น / จาก 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

(หรือถ้าคุณใช้ Java 8+ ให้ใช้Byte.toUnsignedInt)

การแยก / การจัดรูปแบบ

วิธีที่ดีที่สุดคือใช้การแปลงด้านบน:

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

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

เลขคณิต

การเป็นตัวแทน 2 ส่วน "เพิ่งได้ผล" สำหรับการบวกการลบและการคูณ:

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

Division ต้องการการแปลงตัวถูกดำเนินการแบบแมนนวล:

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

ไม่มีไบต์ที่ไม่ได้ลงนามดั้งเดิมใน Java สิ่งปกติคือการโยนให้เป็นประเภทที่ใหญ่กว่า:

int anUnsignedByte = (int) aSignedByte & 0xff;

ฉันคิดว่าคำตอบอื่น ๆ ครอบคลุมถึงการเป็นตัวแทนของหน่วยความจำและวิธีที่คุณจัดการกับสิ่งเหล่านี้ขึ้นอยู่กับบริบทของวิธีการใช้งาน ฉันจะเพิ่มว่าJava 8 เพิ่มการสนับสนุนบางส่วนสำหรับการรับมือกับประเภทที่ไม่ได้ลงชื่อ ในกรณีนี้คุณสามารถใช้Byte.toUnsignedInt

int unsignedInt = Byte.toUnsignedInt(myByte);

หมายเหตุด้านข้างหากคุณต้องการพิมพ์ออกมาคุณสามารถพูดได้

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

ถ้าคิดว่าคุณกำลังมองหาอะไรแบบนี้

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

Adamski ให้คำตอบที่ดีที่สุด แต่ยังไม่สมบูรณ์ดังนั้นโปรดอ่านคำตอบของเขาเนื่องจากอธิบายรายละเอียดที่ฉันไม่ได้

หากคุณมีฟังก์ชั่นระบบที่ต้องการไบต์ที่ไม่ได้ลงชื่อเพื่อถูกส่งผ่านไปคุณสามารถส่งไบต์ที่ลงนามแล้วเพราะมันจะถือว่ามันเป็นไบต์ที่ไม่ได้ลงชื่อโดยอัตโนมัติ

ดังนั้นหากฟังก์ชันระบบต้องการสี่ไบต์ตัวอย่างเช่น 192 168 0 1 เป็นไบต์ที่ไม่ได้ลงนามคุณสามารถผ่าน -64 -88 0 1 และฟังก์ชันจะยังคงทำงานได้เนื่องจากการส่งผ่านไปยังฟังก์ชันจะเป็นการยกเลิกการลงชื่อ .

อย่างไรก็ตามคุณไม่น่าจะมีปัญหานี้เนื่องจากฟังก์ชั่นของระบบถูกซ่อนอยู่หลังคลาสเพื่อความเข้ากันได้ข้ามแพลตฟอร์มแม้ว่าบางวิธีการอ่าน java.io จะส่งกลับไบต์ที่ไม่ได้รับผลเป็น int

หากคุณต้องการเห็นการทำงานนี้ให้ลองเขียนไบต์ที่ลงนามแล้วลงในไฟล์แล้วอ่านกลับเป็นไบต์ที่ไม่ได้ลงนาม

นอกจากนี้คุณยังสามารถ:

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

คำอธิบาย:

สมมติว่า a = (byte) 133;

ในหน่วยความจำจะถูกเก็บเป็น: "1,000 0101" (0x85 เป็น hex)

ดังนั้นการเป็นตัวแทนของมันแปล ไม่ได้ลงนาม = 133, ลงนาม = -123 (เป็นส่วนประกอบ 2 ของ)

<< 24

เมื่อทำการเลื่อนด้านซ้ายไปทางซ้าย 24 บิตผลลัพธ์จะเป็นจำนวนเต็ม 4 ไบต์ซึ่งแสดงเป็น:

"10000101 00000000 00000000 00000000" (หรือ "0x85000000" เป็นเลขฐานสิบหก)

จากนั้นเรามี

(a << 24) >>> 24

และเลื่อนอีกครั้งใน 24 บิตที่ถูกต้อง แต่เติมด้วยเลขศูนย์นำหน้า ดังนั้นจึงส่งผลให้:

"00000000 00000000 00000000 10000101" (หรือ "0x00000085" เป็นเลขฐานสิบหก)

และนั่นคือการแสดงที่ไม่ได้ลงนามซึ่งเท่ากับ 133

หากคุณพยายามที่จะร่ายa = (int) a; แล้วสิ่งที่จะเกิดขึ้นคือมันช่วยให้การแทนค่าส่วนเสริมของ 2 ของไบต์และเก็บไว้เป็น int เช่นเดียวกับส่วนเติมเต็มของ 2:

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

และนั่นแปลว่า: -123

ฉันกำลังพยายามใช้ข้อมูลนี้เป็นพารามิเตอร์ของฟังก์ชันของ Java ที่ยอมรับเฉพาะไบต์เป็นพารามิเตอร์

สิ่งนี้ไม่แตกต่างจากฟังก์ชั่นที่รับจำนวนเต็มที่คุณต้องการส่งผ่านค่าที่มากกว่า 2 ^ 32-1

ฟังดูเหมือนว่าขึ้นอยู่กับวิธีการกำหนดและบันทึกฟังก์ชัน ฉันเห็นความเป็นไปได้สามประการ:

1. มันอาจบันทึกเอกสารอย่างชัดเจนว่าฟังก์ชั่นนั้นถือว่าไบต์เป็นค่าที่ไม่ได้ลงนามซึ่งในกรณีนี้ฟังก์ชั่นน่าจะทำในสิ่งที่คุณคาดหวัง แต่ดูเหมือนว่าจะนำไปใช้ผิด สำหรับกรณีจำนวนเต็มฟังก์ชั่นอาจจะประกาศพารามิเตอร์เป็นจำนวนเต็มไม่ได้ลงนาม แต่เป็นไปไม่ได้สำหรับกรณีไบต์

2. อาจเป็นเอกสารว่าค่าสำหรับอาร์กิวเมนต์นี้จะต้องมากกว่าศูนย์ (หรืออาจเท่ากับ) ซึ่งในกรณีนี้คุณกำลังใช้ฟังก์ชัน (ส่งผ่านพารามิเตอร์นอกขอบเขต) ในทางที่ผิดคาดว่าจะทำมากกว่าที่ออกแบบมา ทำ. ด้วยการสนับสนุนการดีบั๊กบางระดับคุณอาจคาดหวังว่าฟังก์ชั่นนี้จะมีข้อยกเว้นหรือไม่ยืนยัน

3. เอกสารอาจไม่พูดอะไรเลยในกรณีนี้พารามิเตอร์เชิงลบก็คือพารามิเตอร์เชิงลบและไม่ว่าจะมีความหมายใด ๆ หรือไม่นั้นขึ้นอยู่กับฟังก์ชันที่ใช้ ถ้านี่ไม่มีความหมายแล้วบางทีฟังก์ชันควรถูกกำหนด / จัดทำเป็นเอกสารเป็น (2) หากสิ่งนี้มีความหมายในลักษณะที่ไม่เป็นการรบกวน (เช่นค่าที่ไม่เป็นลบจะถูกใช้เพื่อจัดทำดัชนีในอาร์เรย์และค่าลบจะถูกใช้เพื่อทำดัชนีย้อนกลับจากจุดสิ้นสุดของอาร์เรย์ดังนั้น -1 หมายถึงองค์ประกอบสุดท้าย) เอกสารควรบอกว่าอะไร หมายความว่าและฉันคาดหวังว่ามันไม่ใช่สิ่งที่คุณต้องการให้ทำ

หากคุณมีฟังก์ชั่นที่ต้องผ่านไบต์ที่ลงนามแล้วคุณคาดหวังว่ามันจะทำอะไรถ้าคุณผ่านไบต์ที่ไม่ได้ลงนาม

ทำไมคุณไม่สามารถใช้ประเภทข้อมูลอื่นได้

โดยปกติคุณสามารถใช้ไบต์เป็นไบต์ที่ไม่ได้ลงนามด้วยการแปลที่ง่ายหรือไม่มีเลย ทุกอย่างขึ้นอยู่กับวิธีการใช้งาน คุณจะต้องชี้แจงสิ่งที่คุณทำกับมัน

แม้ว่ามันอาจดูน่ารำคาญ (มาจาก C) ที่ Java ไม่ได้รวมไบต์ที่ไม่ได้ลงนามในภาษา แต่จริงๆแล้วมันไม่ใช่เรื่องใหญ่เพราะการดำเนินการ "b & 0xFF" ง่าย ๆ ทำให้ได้ค่าที่ไม่ได้ลงนามสำหรับ (ลงนาม) byte b ใน (หายาก) สถานการณ์ที่จำเป็นจริงๆ บิตไม่ได้เปลี่ยนแปลงจริง ๆ - แค่การตีความ (ซึ่งสำคัญเมื่อทำเช่นการคำนวณทางคณิตศาสตร์กับค่า)

ไม่มีไบต์ที่ไม่ได้ลงนามใน Java แต่ถ้าคุณต้องการแสดงไบต์คุณสามารถทำได้

int myInt = 144;

byte myByte = (byte) myInt;

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

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

เอาท์พุท:

myChar : 90

สำหรับข้อมูลเพิ่มเติมกรุณาตรวจสอบวิธีการแสดงค่า hex / ไบต์ใน Java

ตามข้อ จำกัด ใน Java ไบต์ที่ไม่ได้ลงนามแทบเป็นไปไม่ได้ในรูปแบบชนิดข้อมูลปัจจุบัน คุณสามารถไปสำหรับห้องสมุดอื่น ๆ บางส่วนของภาษาสำหรับสิ่งที่คุณมีการดำเนินการอื่นแล้วคุณสามารถเรียกพวกเขาโดยใช้JNI

ใช่และไม่. ฉันขุดมาพร้อมกับปัญหานี้ เช่นฉันเข้าใจสิ่งนี้:

ความจริงก็คือว่าจาวาได้ลงนาม interger -128 ถึง 127 .. มันเป็นไปได้ที่จะนำเสนอที่ไม่ได้ลงชื่อในจาวากับ:

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

หากคุณเช่นเพิ่มหมายเลข -12 ที่ลงนามเพื่อไม่ได้ลงนามคุณจะได้รับ 244 แต่คุณสามารถใช้หมายเลขนั้นได้อีกในการลงชื่อมันจะต้องเปลี่ยนกลับไปเป็นแบบลงนามและจะเป็น -12 อีกครั้ง

หากคุณพยายามเพิ่ม 244 ไปยังจาวาไบต์คุณจะได้รับ outOfIndexException

ไชโย ..

หากคุณต้องการไบต์ที่ไม่ได้ลงนามใน Java เพียงลบ 256 จากจำนวนที่คุณสนใจมันจะสร้างส่วนเติมเต็มสองด้วยค่าลบซึ่งเป็นจำนวนที่ต้องการในไบต์ที่ไม่ได้ลงนาม

ตัวอย่าง:

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.

คุณจำเป็นต้องใช้ hacks สกปรกเช่นเมื่อใช้lejosเพื่อโปรแกรมอิฐ NXT