黑马程序员技术交流社区

标题: 【LOOK！】逻辑运算符与、或的运算优先级问题！ [打印本页]

作者: 1017161726 时间: 2014-12-25 20:05
标题: 【LOOK！】逻辑运算符与、或的运算优先级问题！
做作业时遇到了一个棘手的问题。

我反省：学过的东西还是要勤温习，不然会忘的。

我简写了：：

class Demo
{
   public static void main(String [] args)
   {
         boolean b,t=true,f=false;
         b=f && f || f && f || f && f || f && f ;
         System.out.println(b);
         //当然结果明显是FALSE，但是我很好奇这个长句是怎么运算的。于是用t替换一些f，然后看答案和我想的是否一样。可是就是不一样的啊。
         //一个多小时就搞这一题了。    大师，详细请教 f && f || f && f || f && f || f && f 的运算顺序。。
   }
}

作者: zhangyaya 时间: 2014-12-25 20:05
b=f && f || f && f || f && f || f && f ;
等价于 b=（f && f） || （f && f） ||（ f && f） ||（ f && f） ;
1. 假如编译器不优化的情况下：如上挨个计算每个&&，最后或||出答案
2.实际情况是，编译器不仅优化了，而且优化力度很大，化简为 b=f；因为四个相同的表达式或在一起，直接取一个表达式即可 b=f && f；同理，两个相同的表达式与了，结果肯定是那个表达式的值，于是b=f。
现代编译器的优化技术对这种case，相信可以轻易处理掉。另外，所谓的“短路”其实也是一种编译优化技术。

至于用t替换一些f之后的表达式求解，编译器的优化路径会发生改变，就得具体分析了，不可与原表达式直接对比。

以上是我的理解，欢迎大家讨论指正。

作者: zhaojiajun 时间: 2014-12-26 00:02
又温习了一下

作者: 郭文飞 时间: 2014-12-26 04:22
我觉得当都为F时首先不要管|| 然后第 1,3,5,7 个f 直接短路&& 其值都为f 然后3个|| 从左至右依次全部判断最终为假

作者: 郭文飞 时间: 2014-12-26 04:29
对于全部是t 先不管|| 全部判断&&左右值全为真然后判断||。第一个||左为真直接短路，则第一个||值为真，然后该值又把第二||短路，，，依次后面无论有多少|| 都会被连锁反应其值为真，，，我是这样认为的

作者: 小僧玄奘 时间: 2014-12-26 16:48
(f && f) || ( f && f) || ( f && f) ||( f && f)

作者: 15342193033 时间: 2014-12-26 21:05
优先级由高到低：小括号>负号>！>算数运算符>关系运算符>&&>||

作者: heimaheima123 时间: 2014-12-26 21:22
1、括号                 8、==!,!=
2、++，--                   9、&
3、~，！                  10、^
4、*，/，%               11、|
5、+，-                   12、&&
6、>>，<<，>>>    13、||
7、>，<，>=，<= 14、?:

作者: zhaojiajun 时间: 2014-12-27 02:26
楼上这么多，又有收获了

作者: Death、 时间: 2014-12-27 08:57
亲，首先这是短路与，短路或。
再其次短路与的运算顺序大于逻辑或的运算顺序；
f 的话：
运算是这样的：首先是短路与运算 (f && f) || ( f && f) || ( f && f) ||( f && f)，其中每个括号内 (f && f) 的与运算只会判断第一个 f 为假（短路与嘛）。然后就是短路或 ||运算，意义上就会成为 false || false || false || false依次运算短路或运算，结果为false; 总结为就是每个 && 先执行且只判断第一个f，然后再依次执行 || 运算。
t的话：
运算是这样的：首先是短路与运算(t && t) || ( t && t) || ( t && t) ||( t && t)，因为 t 为ture，所以两个 t 都会被运算，为ture；然后就是短路或 || 运算，意义上已成为 true || true || true || true，它只会判断第一个true就是结束运算（短路或嘛），运算结果为true；总结为就是先执行 && 运算，且左右两个 t 都会被判断，全总与 && 判断完后，运算 || 运算，且只判断第一个，后面都被短路。
望采纳。

作者: 李票 时间: 2014-12-27 15:34
先运算‘与’在运算‘或’同级之间从左往右运算，应该不会错的

作者: 油茶籽 时间: 2014-12-27 22:55
学习了，应该关键是看短路与&&吧

作者: cxj 时间: 2014-12-28 00:49
当f=false那样时，你可以把 b=f && f || f && f || f && f || f && f ;等价于b=f && *;因为已经有flase了，右边的不参与运算，所有结果为false。。。。同理，当用t将f换掉时，b=t && t || t && t || t && t || t && t ;等价于b=t && t || *;也等价于b = t || *,所有结果为true。

作者: zhaozigeng 时间: 2014-12-28 11:22

Death、发表于 2014-12-27 08:57
亲，首先这是短路与，短路或。
再其次短路与的运算顺序大于逻辑或的运算顺序；
f 的话：

学习了.

作者: limxing 时间: 2014-12-28 13:45
是不是这样：b=f这就是false了，后边还用看吗？

作者: zhiyi 时间: 2014-12-28 18:11
本帖最后由 zhiyi 于 2014-12-28 18:14 编辑

在Java中逻辑运算符“||”和“&&”优先级相同，结合方向为“从左至右”，你的式子相当于
b=（（（（（（（f && f） || f） && f） || f） && f） || f） && f）;
由于用的都是短路符，只运算到第一个“&&”就不运算了

作者: zhiyi 时间: 2014-12-28 18:13
本帖最后由 zhiyi 于 2014-12-28 18:16 编辑

情况是这样的，
在Java中逻辑运算符“||”和“&&”优先级相同，结合方向为“从左至右”，你的式子相当于
b=（（（（（（（f && f） || f） && f） || f） && f） || f） && f）;

作者: shicuf 时间: 2014-12-28 22:21
伟大领袖马士兵曾经说过，纠结优先级的人都是在无理取闹，根本不用管，用括号就能摆平一切！

作者: wang391141741 时间: 2014-12-29 13:50
&&和 ||是短路与和短路或，也就是说从左向右运算，只要有一个条件满足或者不满足即结束

作者: 小徐_y8nUx 时间: 2014-12-30 10:38
我觉得你应该要知道这几个问题的优先级，再去分析，&和双&是不一样的，

作者: 王德亮 时间: 2015-1-3 12:05
逻辑运算符的优先级是 ! > && > || 所以 f && f || f && f || f && f || f && f 把两个f&&f的计算是优先的也就是全部都是false,全部false的或运算自然是false。不过,个人感觉,不需要在意这种东西,毕竟代码是为了表达我们的意图的,能让人一目了然是最好的

作者: Joseph_liuxh 时间: 2015-1-3 21:28
[quote]cxj 发表于 2014-12-28 00:49
当f=false那样时，你可以把 b=f

这个答案逻辑清晰，回答的很到位
学习了。

作者: wei336699 时间: 2015-1-4 17:57
根据优先级先算&& 再算|| f && f 全部的f&&f 都是false 然后算|| 因为都是false 所以都是false，最后b是false
如果你改成 b=f && f || f && f || f && f || t && t ; 同理 f&&f是false 但是 t&&t是true 最后是false||false||false||true || 只要有一个为true就是true 所以最后b=true

作者: rxlyw 时间: 2015-1-4 19:36
&&的优先级高于||，&&两边都为真的时候，结果才为真，否则为假。||表示两边都为假的时候，结果才为假。由于&&优先级高于||，所以在程序中先运行&&，运行完之后再运行||。b=f&&f||f&&f||f&&f||f&&f，f&&f为假，所以就是b=假||假||假||假，假||假=假，所以b=假。当b=t&&t||t&&t||t&&t||t&&t，t&&t=真，b=真||真||真||真，真||真=真，所以b=真。

作者: rxlyw 时间: 2015-1-4 19:38
&&的优先级高于||，&&两边都为真的时候，结果才为真，否则为假。||表示两边都为假的时候，结果才为假。由于&&优先级高于||，所以在程序中先运行&&，运行完之后再运行||。b=f&&f||f&&f||f&&f||f&&f，f&&f为假，所以就是b=假||假||假||假，假||假=假，所以b=假。当b=t&&t||t&&t||t&&t||t&&t，t&&t=真，b=真||真||真||真，真||真=真，所以b=真。

作者: 落魄逗比 时间: 2015-1-5 14:47
这是逻辑运算符呀，都是同一级的，从左到右运算0&&0||0&&0||0&&0||0&&0=false,1&&1||1&&1||1&&1||1&&1||1&&1=1

作者: 阿奔 时间: 2015-1-13 20:37
package ab.wkq;

public class Test111 {
public static void main(String [] args)
{
      boolean b,t=true,f=false;
      b=t && (t ||f) && f || f && f || f && f ;
      System.out.println(b);

}
}
做了一个简单的测试，你可以用括号来证明，证明结果是&&先运行，然后才运行双或
根据优先级问题双与的优先级大于双或。
f && f || f && f || f && f || f && f 的运算顺序。。
先运行f&&f，然后依次运行II两旁boolean值。

作者: manitowang 时间: 2015-1-15 10:50
你应该看看视频！里面教的很详细！

作者: zhengyk 时间: 2015-1-19 17:31
本帖最后由 zhengyk 于 2015-1-19 17:38 编辑

class Test
{
public static class test
{
public static boolean test1(boolean val){
System.out.println("test1("+val+")");
return val;
}
public static boolean test2(boolean val){
System.out.println("test2("+val+")");
return val;
}
public static boolean test3(boolean val){
System.out.println("test3("+val+")");
return val;
}
}
public static void main(String[] args)
{
boolean b=test.test1(true)||test.test2(true)||test.test3(true);
System.out.println("expression is "+b);
}
}

复制代码

参数都传true时：
test1(true)
expression is true
参数都传false时:
test1(false)
test2(false)
test3(false)
expression is false参数都传第二个参数传true时:
test1(false)
test2(true)
expression is true
这里就写了三个参数相或的结果，同理四个或也是一样的。
当前面已判断出true时，后面就不再判断。

作者: shaoboguanzi 时间: 2015-1-22 20:22
很不错啊。

作者: 潇洒小哥 时间: 2015-1-28 09:24
&&的优先级大于||，所以会先运算&&

作者: VitaminesPop 时间: 2015-3-4 11:05
涨姿势了。。。。

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2