应该也是我们班的，比我学的好多了啊！！！
 
32位系统sizeof（int）=4，也就是有32位二进制数，内存中是以32位二进制补码的形式存放这个数的，int为有符号数，最前面一个数字是符号位，0表示正数，1表示负数。
也就是31位存储这个数的大小。
正数的补码就是他的原码本身，也就是num%2  ，余数倒叙排列，不够32位的前面补0，
例如，
00000000 00000000 00000000 00000001   表示1，
00000000 00000000 00000011 00000000   表示的是2的9次方+2的8次方=768。
最大int 
01111111 11111111 11111111 11111111   表示2的31次方-1=2147483647
负数的补码是他对应正数的原码的反码，再+1得到的。
如-1，对应的1的原码 
00000000 00000000 00000000 00000001
1的反码 
   
11111111 11111111 11111111 11111110
反码加1为           
11111111 11111111 11111111 11111111   这也就是内存中-1的存储方式。
int表示的最大正整数2147483647对应的负数-2147483647的二进制为
2147483647原码        
01111111 11111111 11111111 11111111
 反码    
10000000 00000000 00000000 00000000
反码+1       
10000000 00000000 00000000 00000001
那么int表示的最小的负数也就是 
10000000 00000000 00000000 00000000  也就是 -2147483648
知道原理了如何打印一个数的32位二进制码呢？
1，先用原始的取余倒序排列，设要打印的数位num，
对于正数，num%2的值也就是第32位，（num/2）%2取余也就是第31位，（(num/2)/2）%2也就是第30位……
定义一个有32个元素的数组a[32]来存放余数,用一个for循环来将余数赋给数组，
for (i=0;i<32;i++ )
{
a[i]=num%2;
num/=2;
}
a[0]存放第32位，a[1]存放第31位 ，  a[2]存放第30位……   打印只要用下面语句倒序打印数组a，就可以了。a[31]a[30].......a[1]a[0]
for (j=31;j>=0;j--)
printf ( "%d",a[j] );
对于负数，他的存储方式也可以看做是，对应正数减去1之后的反码，如-1对应的正数1 减去1也就是0，
0的原码 
00000000 00000000 00000000 00000000
   反码    
11111111 11111111 11111111 11111111  也就是-1的存储方式
if（num<0）
{
num = -num-1;

for (i=31;i>=0;i-- )
{
a[i]=num%2;
num/=2;
}
}
这里我改变了一下赋值顺序，先将正整数第32位赋给a[31]……也就是a[0]存放第一位，打印的时候顺序打印数组就可以了（对于正数）。我们最终是要打印负数的二进制表示，所以还要取反，可以用下面的语句。
for (j=0;j<32;j++)
b[i] = (a[i]+1)%2;
那么，顺序打印数组b就可以了。
以下是这种方法的实验图：






2 用位操作打印。
用位的左移右移，我们可以将其他位都置0，
如  10100000 00001100 00000000 00000000我们左移2位再右移31位，就可以直接得到
      00000000 00000000 00000000 00000001       也就是上面的第2个1移到了最后一位，可以得到第30位的值
每一位都如此操作，我们就可以得到每一位的值0或1，依次打印即可。
 但是对于一个有符号的数，位的操作会使符号一起移动，但是如果符号位为1，你右移之后，符号位会自动补1，
如10000000 00001111 11110000 00001111  ，我们为了得到第1位的1，直接右移31位，我们预想的结果是
    00000000 00000000 00000000 00000001 ，但实际上，由于符号位为1，每次右移符号位都会自动补1，右移1位
    11000000 00000000 00000000 00000000，右移31位之后会变成
    11111111 11111111 11111111 11111111。
为了得到想要的结果，我们可以把int赋值给一个unsigned int，这样，就可以用这个方法了。




可以看到，我用了3种位操作的方法来打印，第3种是我上面讲的，
第2种也是转换为无符号数，进行了一次位操作；
第1种是在不转换为无符号数的情况下，进行位操作打印。结果都是正确的。

将两个多位十进制数相减，要求被减数，减数均以 ASCII码形式按顺序存放在以DATA1和DATA2为首的5个内存单元中(低位在前)，结果送回DATA1处。

1.这个程序就是实现两个多位数相减功能，经过查阅资料分析得到，有两种方法有一位位相减和合成一个整体后再相减。一位位相减要利用sbb带借位的减法实现功能，这样计算得到的结果就是正确的了。其次这种方法，要进行分类讨论，比较被减数和减数的大小才能得到正确的结果。如果减数比被减数大的话要先显示一个负号，再输出结果。

2.合成一个整体麻烦的难点在于要合成一个数，利用汇编语言合成一个数的思路其实是很类似的，只要学会一个其余都问题不大了。

我写了三种，第一种最简单，无符号数，不输入。
DATAS SEGMENT
    ;此处输入数据段代码 
    A db 4 dup(?)
    length_A equ $-A
    B db 4 dup(?)
    buf1 db '-','$'
    buf2 db '=','$'
    buf3 db 'Please input two number:',0dh,0ah,'$'
    buf4 db 'A=','$'
    buf5 db 'B=','$'
DATAS ENDS

STACKS SEGMENT
    ;此处输入堆栈段代码
    dw 50 dup(?)
    top label byte
STACKS ENDS

CODES SEGMENT
    ASSUME CS:CODES,DS:DATAS,SS:STACKS
START:
	mov ax,stacks
	mov ss,ax
	mov sp,offset top
    MOV AX,DATAS
    MOV DS,AX
    ;此处输入代码段代码
    ;A部分
	;显示A中的数据
	lea dx,buf4
	mov ah,09h
	int 21h
	mov cx,length_A
	lea si,A
	call input
	call hui_che
	lea dx,buf5
	mov ah,09h
	int 21h
	mov cx,length_A
	
	lea si,B
	call input
	call hui_che
	mov cx,length_A
	lea di,A
	
Loop_show_A:
	mov al,[di]
	call show_ascii
	inc di
	loop Loop_show_A
	lea dx,buf1
	mov ah,09h
	int 21h
	;B部分
	;显示B中的数据
	mov cx,length_A
	lea di,B
	
Loop_show_B:
	mov al,[di]
	call show_ascii
	inc di
	loop Loop_show_B
	lea dx,buf2
	mov ah,09h
	int 21h
	
	;减法运算部分
	mov si,offset A
	mov di,offset B	
	mov cx,length_A
compare:;比较a和b哪一个数据更大
	mov al,[si]
	cmp al,[di]
	ja a_b;大于的话直接比较
	jb b_a;小于的话b-a
	je keep_compare;继续比较下一位
keep_compare:
	dec cx
	inc si
	inc di
	jmp compare
b_a:
	mov dl,'-';显示负号
	mov ah,02h
	int 21h
	;应该是b-a
	call sub_B_A
	mov si,offset A
	mov cx,length_A
	jmp Loop_show_result
a_b:
	call sub_A_B
	mov si,offset A
	mov cx,length_A	
	
Loop_show_result:
	mov al,[si]
	call show_ascii
	inc si
	loop Loop_show_result
	;结束部分
	jmp end_pro
	
input proc near
input_loop:
	mov ah,01h
	int 21h
	mov [si],al
	inc si
	loop input_loop
exit:
	ret
input endp
	
show_ascii proc near;显示ascii码
	mov dl,al
	mov ah,02h
	int 21h
	ret
show_ascii endp	

sub_A_B proc near
	mov bx,length_A
su1:
	sub byte ptr[si+bx-1],30h;最后一位数据，转换为十进制
	sub byte ptr[di+bx-1],30h
	dec bx
	jnz su1
	mov si,offset A
	add si,length_A-1
	mov di,offset B	
	add di,length_A-1
	mov cx,length_A;包括进位一共有位数
	clc
su2:
	mov al,[si]
	mov bl,[di]
	sbb al,bl;带借位相减
	aas;非压缩BCD码格式的调整
	mov [si],al;结果被送到di作为被减数被减数区域
	dec si
	dec di;指向下一位
	loop su2;循环
	mov bx,length_A
	mov si,offset A
	mov di,offset B	
su3:
	add byte ptr [si+bx-1],30h
	;add byte ptr [di+bx-1],30h
	dec bx
	jnz su3
	ret
sub_A_B endp

sub_B_A proc near
	mov bx,length_A
su1:
	sub byte ptr[si+bx-1],30h;最后一位数据，转换为十进制
	sub byte ptr[di+bx-1],30h
	dec bx
	jnz su1
	mov si,offset B
	add si,length_A-1
	mov di,offset A	
	add di,length_A-1
	mov cx,length_A;包括进位一共有位数
	clc
su2:
	mov al,[si]
	mov bl,[di]
	sbb al,bl;带借位相减
	aas;非压缩BCD码格式的调整
	mov [di],al;结果被送到被减数区域
	dec si
	dec di;指向下一位
	loop su2;循环
	mov bx,length_A
	mov si,offset B
	mov di,offset A	
su3:
	add byte ptr [di+bx-1],30h
	;add byte ptr [di+bx-1],30h
	dec bx
	jnz su3
	ret
sub_B_A endp

hui_che proc near
	mov dl,0ah
	mov ah,02h
	int 21h
	ret
hui_che endp

end_pro:
    MOV AH,4CH
    INT 21H
CODES ENDS
    END START



第二种和第一种唯一的区别是加入了输入：
DATAS SEGMENT
    ;此处输入数据段代码 
    A db 33h,38h,39h,36h;3896
    length_A equ $-A
    B db 31h,32h,33h,35h;1235
    buf1 db '-','$'
    buf2 db '=','$'
DATAS ENDS

STACKS SEGMENT
    ;此处输入堆栈段代码
    dw 50 dup(?)
    top label byte
STACKS ENDS

CODES SEGMENT
    ASSUME CS:CODES,DS:DATAS,SS:STACKS
START:
	mov ax,stacks
	mov ss,ax
	mov sp,offset top
    MOV AX,DATAS
    MOV DS,AX
    ;此处输入代码段代码
    ;A部分
	;显示A中的数据
	mov cx,length_A
	lea di,A
	
Loop_show_A:
	mov al,[di]
	call show_ascii
	inc di
	loop Loop_show_A
	lea dx,buf1
	mov ah,09h
	int 21h
	;B部分
	;显示B中的数据
	mov cx,length_A
	lea di,B
	
Loop_show_B:
	mov al,[di]
	call show_ascii
	inc di
	loop Loop_show_B
	lea dx,buf2
	mov ah,09h
	int 21h
	
	;减法运算部分
	mov si,offset A
	mov di,offset B	
	mov cx,length_A
compare:;比较a和b哪一个数据更大
	mov al,[si]
	cmp al,[di]
	jg a_b;大于的话直接比较
	jb b_a;小于的话b-a
	je keep_compare;继续比较下一位
keep_compare:
	dec cx
	inc si
	inc di
	jmp compare
b_a:
	mov dl,'-';显示负号
	mov ah,02h
	int 21h
	;应该是b-a
	call sub_B_A
	mov si,offset A
	mov cx,length_A
	jmp Loop_show_result
a_b:
	call sub_A_B
	mov si,offset A
	mov cx,length_A	
	
Loop_show_result:
	mov al,[si]
	call show_ascii
	inc si
	loop Loop_show_result
	;结束部分
	jmp end_pro
	
show_ascii proc near;显示ascii码
	mov dl,al
	mov ah,02h
	int 21h
	ret
show_ascii endp	

sub_A_B proc near
	mov bx,length_A
su1:
	sub byte ptr[si+bx-1],30h;最后一位数据，转换为十进制
	sub byte ptr[di+bx-1],30h
	dec bx
	jnz su1
	mov si,offset A
	add si,length_A-1
	mov di,offset B	
	add di,length_A-1
	mov cx,length_A;包括进位一共有位数
	clc
su2:
	mov al,[si]
	mov bl,[di]
	sbb al,bl;带借位相减
	aas;非压缩BCD码格式的调整
	mov [si],al;结果被送到di作为被减数被减数区域
	dec si
	dec di;指向下一位
	loop su2;循环
	mov bx,length_A
	mov si,offset A
	mov di,offset B	
su3:
	add byte ptr [si+bx-1],30h
	;add byte ptr [di+bx-1],30h
	dec bx
	jnz su3
	ret
sub_A_B endp

sub_B_A proc near
	mov bx,length_A
su1:
	sub byte ptr[si+bx-1],30h;最后一位数据，转换为十进制
	sub byte ptr[di+bx-1],30h
	dec bx
	jnz su1
	mov si,offset B
	add si,length_A-1
	mov di,offset A	
	add di,length_A-1
	mov cx,length_A;包括进位一共有位数
	clc
su2:
	mov al,[si]
	mov bl,[di]
	sbb al,bl;带借位相减
	aas;非压缩BCD码格式的调整
	mov [di],al;结果被送到被减数区域
	dec si
	dec di;指向下一位
	loop su2;循环
	mov bx,length_A
	mov si,offset B
	mov di,offset A	
su3:
	add byte ptr [di+bx-1],30h
	;add byte ptr [di+bx-1],30h
	dec bx
	jnz su3
	ret
sub_B_A endp


end_pro:
    MOV AH,4CH
    INT 21H
CODES ENDS
    END START



最后一种是加入了对于有符号数的处理，可以输入并且输出有符号数，直接将减数和被减数相减即可。
DATAS SEGMENT
    ;此处输入数据段代码 
   	buf dw 2 dup(?)
   	tmp db 10 dup(?)
    buf1 db '-','$'
    buf2 db '=','$'
    buf3 db 'Please input two number:',0dh,0ah,'$'
    buf4 db 'A=','$'
    buf5 db 'B=','$'
    buf6 db 0ah,'The character is out of range, Try again:',0dh,0ah,'$'
DATAS ENDS

STACKS SEGMENT
    ;此处输入堆栈段代码
    dw 50 dup(?)
    top label byte
STACKS ENDS

CODES SEGMENT
    ASSUME CS:CODES,DS:DATAS,SS:STACKS
START:
	mov ax,stacks
	mov ss,ax
	mov sp,offset top
    MOV AX,DATAS
    MOV DS,AX
    ;此处输入代码段代码
    ;A部分
	;显示A中的数据
	lea dx,buf4
	mov ah,09h
	int 21h
	mov si,0;si作为下标
    call prepare_input
	call input
	add si,02h
	lea dx,buf5
	mov ah,09h
	int 21h
	call prepare_input
	call input
	;显示计算数据
	mov si,0
	mov ax,buf[si]
	add si,02h
	call show_ascii
	mov dl,'-'
	mov ah,02h
	int 21h
	mov ax,buf[si]
	call show_ascii
	mov dl,'='
	mov ah,02h
	int 21h
	;减法运算部分
	mov si,0
	mov ax,buf[si]
	add si,02h
	mov dx,buf[si]
	sub ax,dx
	call show_ascii
	jmp end_pro
	
prepare_input proc near
	mov bx,10
	mov bp,0
	mov dx,0
	ret
prepare_input endp

input proc near
	push cx
get_char:
	mov ah,01h
	int 21h
	cmp al,'-';判断是否为负数
	jz nagetive
	cmp al,0dh;判断是否为回车
	jz process_1
	cmp al,' ';判断是否为空格
	jz process_1
	cmp al,30h
	jl mistake
	cmp al,39h;大于9
	ja judge1
	jmp process_2
judge1:
	cmp al,41h;表示在39<x<41的数
	jb mistake
	cmp al,80h;表示>46即超过F的数
	ja mistake
	jmp process_2
mistake:
	mov dx,offset buf6
    mov ah,9h
    int 21h 
    jmp get_char
nagetive:
	mov bp,1;bp作为符号位
	jmp get_char
process_2:
	push ax;
	mov ax,dx
	mul bx;乘以10,以十进制存储
	mov dx,ax;数据保存在dx中
	pop ax
	sub al,30h
	mov ah,0
	add dx,ax
	jmp get_char
process_1:
	cmp bp,1
	jnz save
	neg dx;取负命令0-原数据
save:
	mov buf[si],dx;将处理好的数据存入num中去
	mov bp,0;bp位清零	
	mov dl,0dh;回车换行重新输入
	mov ah,2
	int 21h
	mov dl,0ah
	int 21h
exit:
	pop cx
	ret
input endp

show_ascii proc near
	test ax,1000h;与命令
	jz pre_show;不是负数
	push ax
	mov dl,'-';是负数的情况，先显示负号
	mov ah,02h
	int 21h
	pop ax
	neg ax
pre_show:
	mov di,0
	mov dx,0
	mov bx,10
mid_show:
	div bx;十六进制转十进制
	add dl,30h;余数部分作为结果
	mov tmp[di],dl
	inc di
	cmp ax,0;判断商是否为0，是则表示转换完成
	jz last_show
	mov dx,0;余数部分清零
	jmp mid_show
last_show:
	mov dl,tmp[di-1];dl为待输出字符的ascii码
	mov ah,2
	int 21h
	dec di
	jnz last_show
	ret
show_ascii endp

end_pro:
    MOV AH,4CH
    INT 21H
CODES ENDS
    END START



用汇编实现一个简单的多位数相减起始挺复杂的，第一种方法的缺点在于，首先减数和被减数的位数要相同，优点在于不用受位数的限制可以输入任意多位而不会发生溢出。方法二的缺点在于输入位数不能超过有符号数的范围，优点相减结果不需要讨论，可以直接输出结果。这个程序也是在一步步的改进中更加完善，起始功能是很简单的，后来增加了输入输出，后面发现没有对有符号数的处理，同样后面也改进了。我默认是输入4位数，后续可以改进的功能是输入任意多位数，以及输入保护。

世界真的很大 

一下午就耗在这个数位DP上了 

全怪原来讲的时候没有认真听。。 

然后稍微研究了一下，比起上一道水题稍微有一点进阶了吧？ 

大概，，， 

这道题涉及的是关乎于记忆化数组状态的设计，为了方便储存答案

看题先：



description：



题目给了个f(x)的定义：F(x) = An * 2n-1 + An-1 * 2n-2 + ... + A2 * 2 + A1 * 1，Ai是十进制数位，然后给出a,b求区间[0,b]内满足f(i)<=f(a)的i的个数。



input：



The first line has a number T (T <= 10000) , indicating the number of test cases. 
For each test case, there are two numbers A and B (0 <= A,B < 10 9)



output：



For every case,you should output " Case #t: " at first, without quotes. The t is the case number starting from 1. Then output the answer.

这道题算是略微的进阶了一点吧 

f(a)是给出的，需要计算的就是小于b的满足f(i)小于等于f(a)的数的个数 

由于基于f数组的定义就和数位有关，我们就考虑用数位dp来搜索答案 

那么由于数位DP是从高位DP到低位的，而到了最后一位判断满不满足条件的关键就是通过按位搜索得到的f值小不小于f(a) 

那么DFS需要保存的状态就是当前数位，有无限制，和前几位的f值

本来是没问题的，但是如果我们想要优化的话，就是考虑把memset放在多组数据的外面的话，就要求dp数组保存的一定是数自己的性质，而保存前几位的tot值，这显然根据每组数据b值的不同的答案是不同的

考虑想要把状态映射在数自己身上 

那么如果当前的数位是pos，前几位的f值是sum。的时候，不管a值如何变化，怎样才能表示出后继状态呢？ 

DFS的本质是从前往后找，当记忆化之后，如果当前状态已经找过就直接返回，就是说，记忆化记录的其实是后几位的状态 

而这道题是因为f值是从前几位推得的，所以没法作为”后几位“的状态来记忆化保存

考虑怎么把前几位的答案映射到后几位上去，当然就是保存后几位能得到的答案，就是后几位能凑出的数

f[i][j] 表示当前数位第i位，后i位凑出j的方案数 

这就是后几位的答案，也就是数本身的答案了

可以memset外放优化

完整代码：



#include<stdio.h>
#include<cstring>
using namespace std;

int T,tot,a[20],f[20][5050];

int dfs(int pos,int ste,int lim)
{
    int ans=0;
    if(pos==-1) return ste<=tot;
    if(ste>tot) return 0; 
    if(!lim && f[pos][tot-ste]!=-1) return f[pos][tot-ste];
    int up= lim ? a[pos] : 9;
    for(int i=0;i<=up;i++)
        ans+=dfs(pos-1,ste+i*(1<<pos),lim && i==a[pos]);
    if(!lim) f[pos][tot-ste]=ans;
    return ans;
}

int F(int n)
{
    int cnt=0,bns=0,cns=1;
    while(n)
    {
        bns+=cns*(n%10);
        n/=10;
        cns*=2;
    }
    return bns;
}

int solve(int n)
{
    int cnt=0;
    memset(a,0,sizeof(a));
    while(n)
    {
        a[cnt++]=n%10;
        n/=10;
    }
    return dfs(cnt-1,0,1);
}

int main()
{
    scanf("%d",&T);
    memset(f,-1,sizeof(f));
    for(int e=1;e<=T;e++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        tot=F(a);
        printf("Case #%d: %d\n",e,solve(b));
    }
    return 0;
}
/*
Whoso pulleth out this sword from this stone and anvil is duly born King of all England
*/

嗯，就是这样

要讲java一些奇奇怪怪的运算符号之前，必须先了解二进制，因为这些看不懂的运算符都是基于二进制运算的
计算机里二进制的运算，往往比十进制运算来的快。

首先了解下转换规则（相互转换）：

转码之前，有一些名词概念：
1、原码
一个正数，按照绝对值大小转换成二进制数，称为原码
2、反码
将二进制数按位取反，所得的新二进制数称为原二进制数的反码
其实就是把原码中的0变为1,1变为0
例如：0000 0101 和1111 1010就是互为反码
3、补码
在反码的基础上加1称为补码，一般在算负数的时候会用到

十进制转二进制：
1、正整数转换二进制


2、负整数转换二进制


3、小数转换二进制


重点掌握前面两个：
1、正整数转换二进制
除二取余，然后倒序排列，高位补零。

如下图：三步操作（字丑勿喷）



2、负整数转换二进制
  先将对应的正整数转换成二进制
  对二进制取反，这边有个不一样的地方，原来那个正数的补位都是0，但是你取反了，那就证明负数补位的时候，要补1
  然后对结果再加1(这里的1，是十进制的1，但是十进制的1对应的二进制就是00000001)

  如下图：



3、小数转化二进制
  先对小数部分*2，乘到小数部分为0
  然后再对整数部分计算
  最后合起来
  如下图：

  
二进制转十进制：
这里会有两种情况，有符号数，和无符号数
1、无符号数的话就是直接转换成正整数

如下图：



2、有符号数的话，就把第一个数字看成符号，1就是负数，0就是正数
  1）如果是正数，那就是第一位不用做计算，把后面的7位拿起来计算，
  比如0111 1111 结果就是127
  2）如果是负数，那算法就是先对结果（这个结果是补码）减1获得反码，然后取反（获得原码），然后计算，跟负十进制的数转换成二进制的数的操作是相反的
  比如1111 1111，结果就是-1
  转换过程：1111 1111 -1 = 1111 1110
取反：1111 1110 =》 0000 0001

转换：1*2的0次方=1，那因为我们一开始就定义它为负数，所以就是-1


======================================华丽的分割线============================================
明白了上面的相互转换之后

就开始来理解java中一些奇特的符号：
1、&(按位与)


2、|(按位或)


3、^(按位异或)


4、~ (按位取反)


5、>> (右移运算符)


6、<< (左移运算符)


这些就是java中对二进制数字的计算，别的语言应该还有些其他的符号

本人水平有限所以。。。。


1、& 与
规则：先将两个数字转换为二进制，然后每一位进行匹配
     只有当两个位置上都是1的时候，才会返回1

例子：9&12
9：1001
12:1100
所以结果应该是：1000=》转换为十进制：8

这个符号也有个例子，在Hadoop的MapReduce中默认实现的HashPartitioner类中的分区方法

public int getPartition(K2 key, V2 value, int numReduceTasks) {  

return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;  

} 
就是使用这个符号。



2、| 或
规则：先将两个数字转换为二进制，然后每一位进行匹配
 两个位只要有一个为1，那么结果就是1，否则就为0。

例子：9|12
9：1001
12:1100
所以结果应该是：1101=》转换为十进制：13




3、^ 异或
规则：先将两个数字转换为二进制，然后每一位进行匹配
两个操作数的位，相同则结果为0，不同则结果为1。
0 ^ 1 =1，1 ^ 1 = 0，0 ^ 0 = 0，1 ^ 0 = 1

例子：9^12
9：1001
12:1100
所以结果应该是：0101=》转换为十进制：5




4、~ 取反
规则：这个是对一个数字的操作

 先将这个数字转换为二进制
 然后每个位上的数字，0变成1,1变成0


例子：~9
9:1001
~9:0110
所以结果应该是0110=》转换为十进制：6
呵呵，你自己试试，答案是错的。。不是6，答案是-10
为什么？
先说一个概念int类型是4字节，1字节是8位，所以int类型有32位
然后，9的值是1001，其实你全部写出来应该是0000 0000 000...(前面有28个0)然后1001
所以对9取反，不能简单的写成0110,因为0110代表的是0000 0000 000...(前面有28个0)然后0110
~9:1111 1111 1111 1111 1111 1111 1111 0110
接着你可以在代码中试试：
String i = Integer.toBinaryString(-10);
System.out.println(i);
System.out.println(i.length());
打印出来的就是：
11111111111111111111111111110110
32

结论：所以这里就要说到，在上文中提到的二进制的有符号数和无符号数
再重新阐述一次：简单来说，例如byte长度是8位，无符号数的情况下，1111 1111 =》255
有符号数的情况下，因为最高位1代表负号，0代表正号，所以 0111 1111 =》127，所以1000 0000 =》-128
所以你还记得byte类型能表示的长度是-128---127吗，就是这个原因
那么在java中几乎所有的正数取反，会得到负数，负数取反会得到正数！
比如1000 0001 这个二进制的有符号数，他代表的值就是-127
所以这是取反操作的一个坑，也是不少网络给出的什么二进制转换器输入1000 0000得到的值为128的原因（因为他识别成无符号二进制数字）
如果你还不太懂，而且又想继续了解的话：http://www.cnblogs.com/ASPNET2008/archive/2009/04/29/1446471.html

这篇别人的文章，应该可以帮到你，作者我也不知道是谁（因为他也是转载的），如对原作者有所冒犯，实在抱歉，请给我留言，我标注作者！！


5、>> (右移运算符)和<< (左移运算符)
这两个东西，放在一起记录，是因为这两个操作是一样的，就是一个位移操作
1、举例1、12>>2

操作：
先将12转换为二进制 ==》1100
然后把整体向右移动两位 ==》0011
最后转换为十进制 ==》 1*2的0次方+1*2的1次方=3
所以答案：3
2、举例2、12<<2
操作：

先将12转换为二进制 ==》1100
然后把整体向左移动两位 ==》110000
最后转换为十进制 ==》 1*2的4次方+1*2的5次方=48
所以答案：3
结论：所以也能简单的理解为>>3就是原来的数字除以2的3次方，<<3就是乘以2的3次方

好的，本人菜鸟一只，整理就到这里，如果还有什么疑问，可以给我留言，如果有说的不对的地方，请各路大神指出！！