通过位运算完成加减乘除

以服

原码 ：最高位是符号位，0代表正数，1代表负数，非符号位为该数字绝对值的二进制。

反码：正数的反码与原码一致，负数的反码是对原码按位取反，只是最高位（符号位）不变。 

补码：正数的补码与原码一致，负数的补码是对原码按位取反加1，符号位不变。

补码变成原码的方式是：正数的补码与原码一致，负数的补码按位取反加1，符号位不变

反码变成原码的方式是：正数的反码与原码一致，负数的补码按位取反，符号位不变

以3为例子                                                   以-3为例子 

源码： 11                                                   10000000000000000000000000000011

反码：11                                                    11111111111111111111111111111100     

补码：11                                                   11111111111111111111111111111101

保留最后一个1  n&~(n-1)

     11 & ~(11 -1）-> 11&~（10）-> 11 & (1111111..01)->1

     

   110 & ~(110 -1）-> 110&~（101）-> 11 & (1111111..010)->10

     

去掉最后一个1   n &(n-1)

     11 & (11 -1）-> 11&（10）-> 10

     

   110 & ~(110 -1）-> 110&（101）-> 100

获取相反数   数据取反后加1

-1 的相反数是1

11111111111111111111111111111111 取反  0....0       加1    0...1  

​​​​​​​import java.util.HashMap;

public class calculate {
    public static void main(String[] args) {
        System.out.println(Integer.toBinaryString(~2));
        System.out.println(Integer.toBinaryString(3));
        System.out.println(add(-1,1));
        System.out.println(sub(-1,1));
        System.out.println(muti(-1,-2));
        System.out.println(devidebyadd(2,1));
        System.out.println(devicebyMuti(2,1));
    }


    public static int devicebyMuti(int a ,int b){
        if(b ==0){
            throw  new RuntimeException("除数不能0");
        }
        if(a == 0){
            return 0;
        }
        boolean neg = a>0 && b> 0;
        if(a< 0){
            a = add(~a,1);
        }
        if(b < 0){
            b = add(~b,-1);
        }
        int result = 0;
        while (muti(result,b) <= a){
            result =add(result,1);
        }
        result = sub(result,1);
        return neg? result: add(~result,1);
    }
    public static int devidebyadd(int a ,int b){
        if(b ==0){
            throw  new RuntimeException("除数不能0");
        }
        if(a == 0){
            return 0;
        }
        boolean neg = a>0 && b> 0;
        if(a< 0){
            a = add(~a,1);
        }
        if(b < 0){
            b = add(~b,-1);
        }
        int result = 0;
        while (a >= b){
          a=  sub(a,b);
          result = add(result,1);
        }

        return neg ? result: add(~result,1);
    }


    public static int muti(int a,int b){
        if(a==0 || b==0){
            return 0;
        }
        boolean neg = a>0 && b >0;
        if(a<0){
            a = add(~a,1);
        }
        if(b<0){
            b = add(~b,1);
        }
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < 32; i++) {
            map.put(1<<i,i);
        }
        int result = 0;
        while (b != 0){
           int positon = b&~(b-1);//保留最后一个1
           result += a << map.get(positon);
           //去掉最后一个1
            b= b & (b-1);
        }
        return neg ? result : add(~result,1);
    }


    public static int add(int a ,int b){
        int sum = 0;
        while (b !=0){
            sum = a^ b;
            b = (a&b)<<1;
            a =sum;
        }
        return sum;
    }
    public static  int sub(int a ,int b){
        return add(a,add(~b,1));
    }
}