Làm thế nào để bithifting hoạt động trong Java?

Question

Tôi có tuyên bố này:

Giả sử giá trị bit byte x là 00101011. kết quả của x>>2 là gì?

Làm cách nào để tôi có thể lập trình và ai đó có thể giải thích tôi đang làm gì?

Answer 1

Thứ nhất, bạn có thể không thay đổi một byte trong java, bạn có thể chỉ chuyển một int hay long. Vì vậy, byte sẽ được xúc tiến trước tiên, ví dụ:

00101011 ->00000000000000000000000000101011

hoặc

11010100 ->11111111111111111111111111010100

Bây giờ, x >> N phương tiện (nếu bạn xem nó như là một chuỗi các số nhị phân):

• Các bìa phải N bit bị hủy
• Bit ngoài cùng bên trái được nhân rộng nhiều lần cần thiết để đưa kết quả đến kích thước ban đầu (32 hoặc 64 bit), ví dụ:

00000000000000000000000000101011 >> 2 ->00000000000000000000000000001010

11111111111111111111111111010100 >> 2 ->11111111111111111111111111110101

Answer 2

Khi bạn dịch chuyển sang phải 2 bit, bạn thả 2 bit quan trọng nhất. Vì vậy:

x = 00101011 

x >> 2 

// now (notice the 2 new 0's on the left of the byte) 
x = 00001010 

Điều này về bản chất cũng giống như chia int cho 2, 2 lần.

Trong Java

byte b = (byte) 16; 
b = b >> 2; 
// prints 4 
System.out.println(b); 

Answer 3

Bạn không thể viết chữ nhị phân như 00101011 trong Java, do đó bạn có thể viết nó trong hệ thập lục phân thay vì:

byte x = 0x2b; 

Để tính toán kết quả của x >> 2 bạn có thể sau đó chỉ cần viết chính xác và in kết quả.

System.out.println(x >> 2); 

Answer 4

>> là toán tử Shift số học. Tất cả các bit trong toán hạng đầu tiên được dịch chuyển số vị trí được chỉ định bởi toán hạng thứ hai. Các bit ngoài cùng bên trái trong kết quả được đặt thành cùng một giá trị như bit ngoài cùng bên trái trong số ban đầu. (Điều này là để số âm vẫn còn tiêu cực.)

Đây là trường hợp cụ thể của bạn:

00101011 
    001010 <-- Shifted twice to the right (rightmost bits dropped) 
00001010 <-- Leftmost bits filled with 0s (to match leftmost bit in original number) 

Answer 5

byte x = 51; //00101011 
byte y = (byte) (x >> 2); //00001010 aka Base(10) 10 

Answer 6

public class Shift { 
public static void main(String[] args) { 
    Byte b = Byte.parseByte("00101011",2); 
    System.out.println(b); 
    byte val = b.byteValue(); 
    Byte shifted = new Byte((byte) (val >> 2)); 
    System.out.println(shifted); 

    // often overloked are the methods of Integer 

    int i = Integer.parseInt("00101011",2); 
    System.out.println(Integer.toBinaryString(i)); 
    i >>= 2; 
    System.out.println(Integer.toBinaryString(i)); 
} 
} 

Output:

43 
10 
101011 
1010 

Answer 7

Bạn có thể sử dụng ví dụ API này nếu bạn muốn xem bản trình bày bitString của các số của bạn. Uncommons Math

Ví dụ (trong JRuby)

bitString = org.uncommons.maths.binary.BitString.new(java.math.BigInteger.new("12").toString(2)) 
bitString.setBit(1, true) 
bitString.toNumber => 14 

chỉnh sửa: Thay đổi api liên kết và thêm một chút ví dụ

Answer 8

Các nhị phân 32 bit cho 00101011 là

00000000 00000000 00000000 00101011, và kết quả là:

00000000 00000000 00000000 00101011 >> 2(times) 
\\         \\ 
    00000000 00000000 00000000 00001010 

Chuyển các bit từ 43 sang trái theo khoảng cách 2; điền với bit (ký hiệu) cao nhất ở phía bên trái.

Kết quả là 00001010 với giá trị thập phân 10.

00001010 
    8+2 = 10 

Answer 9

Những ví dụ bao gồm ba loại thay đổi áp dụng cho cả tích cực và một số âm:

// Signed left shift on 626348975 
00100101010101010101001110101111 is 626348975 
01001010101010101010011101011110 is 1252697950 after << 1 
10010101010101010100111010111100 is -1789571396 after << 2 
00101010101010101001110101111000 is 715824504 after << 3 

// Signed left shift on -552270512 
11011111000101010000010101010000 is -552270512 
10111110001010100000101010100000 is -1104541024 after << 1 
01111100010101000001010101000000 is 2085885248 after << 2 
11111000101010000010101010000000 is -123196800 after << 3 


// Signed right shift on 626348975 
00100101010101010101001110101111 is 626348975 
00010010101010101010100111010111 is 313174487 after >> 1 
00001001010101010101010011101011 is 156587243 after >> 2 
00000100101010101010101001110101 is 78293621 after >> 3 

// Signed right shift on -552270512 
11011111000101010000010101010000 is -552270512 
11101111100010101000001010101000 is -276135256 after >> 1 
11110111110001010100000101010100 is -138067628 after >> 2 
11111011111000101010000010101010 is -69033814 after >> 3 


// Unsigned right shift on 626348975 
00100101010101010101001110101111 is 626348975 
00010010101010101010100111010111 is 313174487 after >>> 1 
00001001010101010101010011101011 is 156587243 after >>> 2 
00000100101010101010101001110101 is 78293621 after >>> 3 

// Unsigned right shift on -552270512 
11011111000101010000010101010000 is -552270512 
01101111100010101000001010101000 is 1871348392 after >>> 1 
00110111110001010100000101010100 is 935674196 after >>> 2 
00011011111000101010000010101010 is 467837098 after >>> 3 

Answer 10

00101011 = 43 trong số thập phân

class test {  
    public static void main(String[] args){ 
     int a= 43;  
     String b= Integer.toBinaryString(a >> 2);   
     System.out.println(b); 
    } 
} 

Đầu ra:

101011 trở thành 1010