java运算符优先级

Question

java中运算顺序何时从左向右，何时从右向左，有没有比较权威的说明

Answer 1

Java 中共有 54 种运算符，按优先级可以分为 14 级，详见如下（原来整理的，供为参考）：优先级   操作符   含义        关联性  用法 
----------------------------------------------------------------
1        [ ]      数组下标      左    array_name[expr] 
         .        成员选择      左    object.member 
         ( )      方法参数      左    method_name(expr_list) 
         ( )      实例构造      左    class_name(expr_list) 
         ++       后缀自增      左    lvalue++ 
         --       后缀自减      左    lvalue-- 2        ++       前缀自增      右    ++rvalue 
         --       前缀自减      右    --lvalue 
         ~        按位取反      右    ~expr 
         !        逻辑非        右    !expr 
         +        一元加        右    +expr 
         -        一元减        右    -expr 3        ( )      强制转换      右    (type)expr 
         new      对象实例化    右    new type() 
                                      new type(expr_list) 
                                      new type[expr] 4        *        乘            左    expr * expr 
         /        除            左    expr / expr 
         %        求余          左    expr % expr 5        +        加            左    expr + expr 
         -        减            左    expr - expr 
         +        字符串连接    左    strExpr + strExpr 6        >>       有符号右移    左    expr >> distance 
         >>>      无符号右移    左    expr >>> distance 7        <        小于          左    expr < expr 
         <=       小于等于      左    expr <= expr 
         >        大于          左    expr > expr 
         >=       大于等于      左    expr >= expr 
      instanceof  类型比较      左    ref instanceof refType 
         ==       等于          左    expr == expr 
         !=       不等于        左    expr != expr 8        &        整数按位与    左    integralExpr & integralExpr 
         &        布尔与        左    booleanExpr & booleanExpr 9        ^        整数按位异或  左    integralExpr ^ integralExpr 
         ^        布尔异或      左    booleanExpr ^ booleanExpr 10       |        整数按位或    左    integralExpr | integralExpr 
         |        布尔或        左    booleanExpr | booleanExpr 11       &&       逻辑与        左    booleanExpr && booleanExpr 12       ||       逻辑或        左    booleanExpr || booleanExpr 13       ? :      条件运算      右    booleanExpr ? expr : expr 14       =        赋值          右    lvalue = expr 
         *=       乘赋值        右    lvalue *= expr 
         /=       除赋值        右    lvalue /= expr 
         %=       模赋值        右    lvalue %= expr 
         +=       加赋值        右    lvalue += expr 
         +=    字符串连接赋值   右    lvalue += expr 
         -=       减赋值        右    lvalue -= expr 
         <<=      左移赋值      右    lvalue <<= expr 
         >>=   有符号右移赋值   右    lvalue >>= expr 
         >>>=  无符号右移赋值   右    lvalue >>>= expr 
         &=    整数按位与赋值   右    lvalue &= expr 
         &=       布尔与赋值    右    lvalue &= expr 
         |=    整数按位或赋值   右    lvalue |= expr 
         |=       布尔或赋值    右    lvalue |= expr 
         ^=   整数按位异或赋值  右    lvalue ^= expr 
         ^=     布尔异或赋值    右    lvalue ^= expr 
运算符不但有优先级，还有关联性。
上表中关联性为“左”表示该表达式从左边开始进行运算；关联性为“右”表示该表达式从右边开始进行运算。

Answer 2

好像火龙果大哥第7个错了，<, <=, >, >=, instanceof 与 ==, != 不是一个级别的

Answer 3

按优先级从高到低排列如下：[ ] ( ) ++ -- ! ～ instanceof * / % + - << >> >>> <> < = > \ == != &^& & || ? := op= 

Answer 4

这个应该算是最权威的了，java官方网站上的<caption id="nutsandbolts-precedence"><strong>Operator Precedence</strong></caption>
<tr>
<th id="h1">Operators</th>
<th id="h2">Precedence</th>
</tr>
<tr>
<td headers="h1">postfix</td>
<td headers="h2"><code><em>expr</em>++ <em>expr</em>--</code></td>
</tr>
<tr>
<td headers="h1">unary</td>
<td headers="h2"><code>++<em>expr</em> --<em>expr</em> +<em>expr</em> -<em>expr</em> ~ !</code></td>
</tr>
<tr>
<td headers="h1">multiplicative</td>
<td headers="h2"><code>* / %</code></td>
</tr>
<tr>
<td headers="h1">additive</td>
<td headers="h2"><code>+ -</code></td>
</tr>
<tr>
<td headers="h1">shift</td>
<td headers="h2"><code>&lt;&lt; &gt;&gt; &gt;&gt;&gt;</code></td>
</tr>
<tr>
<td headers="h1">relational</td>
<td headers="h2"><code>&lt; &gt; &lt;= &gt;= instanceof</code></td>
</tr>
<tr>
<td headers="h1">equality</td>
<td headers="h2"><code>== !=</code></td>
</tr>
<tr>
<td headers="h1">bitwise AND</td>
<td headers="h2"><code>&amp;</code></td>
</tr>
<tr>
<td headers="h1">bitwise exclusive OR</td>
<td headers="h2"><code>^</code></td>
</tr>
<tr>
<td headers="h1">bitwise inclusive OR</td>
<td headers="h2"><code>|</code></td>
</tr>
<tr>
<td headers="h1">logical AND</td>
<td headers="h2"><code>&amp;&amp;</code></td>
</tr>
<tr>
<td headers="h1">logical OR</td>
<td headers="h2"><code>||</code></td>
</tr>
<tr>
<td headers="h1">ternary</td>
<td headers="h2"><code>? :</code></td>
</tr>
<tr>
<td headers="h1">assignment</td>
<td headers="h2"><code>= += -= *= /= %= &amp;= ^= |= &lt;&lt;= &gt;&gt;= &gt;&gt;&gt;=</code></td>
</tr>
</table>

Answer 5

貼错了。。看看这个官方这个文档吧
http://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html