透析java本质的36个话题-第二章运算符与表达式

9、莫衷一是---  i+++j该如何计算

9.1、三个加号 

public class Test{
    public static void main(String[] args) {
        int i =2,j=9;
        System.out.println(i+++j);  //11
         i =2;j=9;
        System.out.println((i++)+j);//11
        i =2;j=9;
        System.out.println(i+(++j)); //12
        /**
         * 可见i+++j  运算顺序为 (i++)+j
         */
    }
}
           

 9.2、贪心规则

 9.3、为何贪心

public class Test{
    public static void main(String[] args) {
//程序输出若干个8进制转义字符
        String s = "\17";
        System.out.println(s+"  的长度为"+s.length());
        s = "\171";
        System.out.println(s+"  的长度为"+s.length());
        s = "\1717";
        System.out.println(s+"  的长度为"+s.length());
        s = "\43";
        System.out.println(s+"  的长度为"+s.length());
        s = "\431";
        System.out.println(s+"  的长度为"+s.length());

    }
}
           

运行

 10、千差万别++i与i++仅仅是先加与后加的区别吗

10.1、前置++与后置++

先看一段代码

public class Test{
    public static void main(String[] args) {
        int i =1;
        i++;
        System.out.println(i);//这个会输出2
        i=1;
        i=i++;
        System.out.println(i);//这个会输出1
        /**
         * 上面的程序可见  i++;  i=i++;是不一样的
         */

        i=1;
        int j=i++;
        System.out.println(j); //这个会输出1
        System.out.println(i);//这个会输出2
        /**
         * 又可以知道i=i++和 j=i++ ，i的变化也是不一样的
         */
    }
}
           

i=1

i=i++

按照通俗的见解，虽然后置++是先参与运算，然后再将值加1，

但是执行对自身的赋值运算后，值也该加1，变成2才是啊。

况且，当后置++对其他变量j赋值后，i自身也加1了，并且运算结果也打印出了2.

为什么对自己赋值后结果就不一样了

10.2、后置++的自白

int i=1;
i=i++;
//等同于
int temp=i;//将i赋值给一个临时变量temp ，temp为1
i+=1;      //i加1为2
i=temp;    //使用临时变量temp为i赋值，i又变成i，
           

11、大相径庭-相除与求余在java中的具体表现 

11.1、特殊的浮点值

11.2、除法运算汇总 

 11.3、求余运算汇总

 浮点的求余和除法运算1、2点相同

11.4、+0与-0的差异

 12、移形换位-移位运算的真实剖析

12.1、超过自身位数的移位 

12.2、移位运算符与乘除运算 

12.3、永远的-1

public class Test {
    public static void main(String[] args) {
        int k =-1;
        System.out.println("int类型的移位结果：");
        for (int i =1;i<=Integer.SIZE;i++){
            k >>>= 1;
            System.out.printf("%-15d",k);

            if(i%3==0){
                System.out.println();
            }
        }
        System.out.println();
        System.out.println("byte类型的人移位结果：");
        byte b=-1;
        for(int i =1;i<=Byte.SIZE;i++){
            b>>>=1;
            System.out.printf("%-15d",b);

            if(i%3==0){
                System.out.println();
            }
        }
    }
}
           

 13、鞭辟近里-条件运算符(? :)的类型深入

13.1、？： 运算符的介绍 

13.2、？：条件表达式的类型 

//表达式2与表达式3具有相同类型
int i =1;
int j =2;
int k=i>j?i:j;//int

//表达式2与表达式3一个为boolean，另一个为Boolean
boolean b1= true;
Boolean b2 = new Boolean(false);
boolean b3 = i>j?b1:b2;//boolean
           

14、井然有序-运算顺序的详细挖掘 

14.1、从左向右的计算顺序 

public static void main(String[] args) {
    int a = 3;
    int b =a + (++a) + (a=1) + a;
    System.out.println(b);//9
}
           

 14.2、复合运算符

public class Test {
    public static void main(String[] args) {
        int a = 10;
        a += ++a;
        System.out.println("a="+a);

        int[] array = new int[]{8,9,10};
        int b =1;
        array[b] *= b = 2;
        System.out.println("b="+b);
        System.out.println(Arrays.toString(array));
    }
}
           

 15、异曲同工-交换变量的三种方式

15.1、通过第三个变量交换

public class Test {
    public static void main(String[] args) {
        int x = 5;
        int y = 10;
        swap(x,y);

        Value v = new Value(5, 10);
        swap(v);
    }
    
    //无效的转换
    /**
     * 基本类型做形参，形参的改变是无法反作用与实参的
     * @param x
     * @param y
     */
    private static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
    }
    /**
     * 有效的交换，引用类型做形参，可以改变其值
     * @param value
     */
    private static void swap(Value value) {
        int temp = value.x;
        value.x = value.y;
        value.y = temp;
    }
}
class Value{
    int x;
    int y;
    public Value(int x,int y) {
        this.x = x;
        this.y = y;
    }
}
           

 15.2、通过相加的方式

 private static void swap(Value value) {

        value.x = value.x + value.y;//将x与y的和存储在x中

        value.y = value.x - value.y;//x-y就是以前x的值,赋值给y

        value.x = value.x - value.y;//x-y就是以前y的值,赋值给x

    }

但当两个值很大或很小时会有溢出风险。

15.3、 通过异或的方式

 private static void swap(Value value) {

        value.x = value.x ^ value.y;//x=x^y

        value.y = value.x ^ value.y;//x^y就是以前x的值,赋值给y,

        value.x = value.x ^ value.y;//相当于x=x^y^x=y,以前y的值,赋值给x,

    }

没有溢出风险

16、择木而栖-开关选择表达式switch的类型内幕