java中运算符的优先级

题目

写出下列表达式的值，设：x=3,y=17,yn=true。
（1）x + y * x-- = 54
（2）-x * y + y = -34
（3）x < y && yn = true
（4）x > y || !yn = false
（5）y != ++x ? x : y = 4
（6）y++ / --x = 8

最近看到这样的一道题目，初看之下考的运算符的优先级，但仔细一看发现还有点别的东西在里边。

测试代码

package test;


/**
 *
 * 
 写出下列表达式的值，设：x=3,y=17,yn=true。
（1）x + y * x-- = 54
（2）-x * y + y = -34
（3）x < y && yn = true
（4）x > y || !yn = false
（5）y != ++x ? x : y = 4
（6）y++ / --x = 8
 *
 */
public class Test {
    public static void main(String[] args) {
        test1(3,17);
        test2(3,17);
        test3(3,17,true);
        test4(3,17,true);
        test5(3,17);
        test6(3,17);
    }
    
    public static void test1(int x,int y) {
        System.out.println("x + y * x-- 计算结果"+(x + y * x--));
    }
    public static void test2(int x,int y) {
        System.out.println("-x * y + y 计算结果"+(-x * y + y));
    }
    public static void test3(int x,int y , boolean yn) {
        System.out.println("x < y && yn 计算结果"+(x < y && yn));
    }
    public static void test4(int x,int y , boolean yn) {
        System.out.println("x > y || !yn 计算结果"+(x > y || !yn));
    }
    public static void test5(int x,int y) {
        System.out.println("y != ++x ? x : y 计算结果"+(y != ++x ? x : y));
    }
    public static void test6(int x,int y) {
        System.out.println("y++ / --x 计算结果"+(y++ / --x));
    }
}

输出结果

x + y * x-- 计算结果54
-x * y + y 计算结果-34
x < y && yn 计算结果true
x > y || !yn 计算结果false
y != ++x ? x : y 计算结果4
y++ / --x 计算结果8

解析

运算符的优先级

既然结果已经出来了，我们当然是要看一下为什么会是这样的结果。下图是百度百科中的一张运算符优先级图。

image

• 优先级1级为最高优先级
• 结合性是指运算符结合的顺序，通常都是从左到右。

没有自身元素操作的运算

对比优先级就可以解释这些没有对自身元素进行操作的比较结果了

-x * y + y 计算结果-34
x < y && yn 计算结果true
x > y || !yn 计算结果falsey++ / --x 计算结果8

带有自身操作的简单运算

而对于这样的一个y++ / --x 计算结果8表达，我们要知道两点

• ++ -- 的运算优先级大于/
• ++ -- 出现在前面，自身先自增1在计算，在后边则反之。

所以实际计算的是int型的17/2（int类型计算的精确度）

带有自身运算的多次取值问题

最后就是这两个计算了，也是比较迷惑性的计算

y != ++x ? x : y 计算结果4

x + y * x-- 计算结果54

对于三目运算符，我们可以理解成if else语句就好了，为真返回第一个，为假返回第二个值。

当++ -- 操作自身元素时，计算表达式是什么时候将内存中的值取出来计算的。

这也是为什么造成y != ++x ? x : y 计算后，取到的值为4，而x + y * x--计算时第一个x为3，不为2的原因。

我们写这样的一个测试

    public static void main(String[] args) {
        int x = 3;
        System.out.println("x + x++ = "+ (x + x++));
        x = 3;
        System.out.println("x++ + x = " + (x++ + x));
    }

结果

x + x++ = 6
x++ + x = 7

从结果来看，等于6是因为第一个x取到的值是3，第二个取到的值仍然是3（++在后先取出x值，x再自增1）.而等于7的是x++取到值后，x自增1重新复制给x，所以第二次取到的就是4，答案就是7了，由此就可以解释x + y * x-- 计算结果54的结果为什么是54了。

最后

当

x = 3;
y = 17;

y != ++x ? x : y 和y != x++ ? x : y 的计算结果会一样吗？

    public static void main(String[] args) {
        int x = 3;
        int y = 17;
        System.out.println("y != ++x ? x : y = "+ (y != ++x ? x : y));
        x = 3;
        y = 17;
        System.out.println("y != x++ ? x : y =" + (y != x++ ? x : y));
    }

先自己算一下结。

答案是：

y != ++x ? x : y = 4
y != x++ ? x : y =4