Opérateurs Scala
Un opérateur est un symbole qui indique au compilateur d'effectuer des opérations mathématiques et logiques spécifiées.
Scala dispose d'un riche ensemble d'opérateurs intégrés, notamment les types suivants :
Opérateurs arithmétiques
Opérateurs relationnels
Opérateurs logiques
Opérateurs au niveau du bit
Opérateurs d'affectation
Ensuite, nous présenterons en détail l’application des opérateurs ci-dessus.
Opérateurs arithmétiques
Le tableau suivant répertorie les opérateurs arithmétiques pris en charge par Scala.
Supposons que la variable A soit 10 et B soit 20 :
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加号 | A + B 运算结果为 30 |
| - | 减号 | A - B 运算结果为 -10 |
| * | 乘号 | A * B 运算结果为 200 |
| / | 除号 | B / A 运算结果为 2 |
| % | 取余 | B % A 运算结果为 0 |
Instance
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
var c = 25;
var d = 25;
println("a + b = " + (a + b) );
println("a - b = " + (a - b) );
println("a * b = " + (a * b) );
println("b / a = " + (b / a) );
println("b % a = " + (b % a) );
println("c % a = " + (c % a) );
}
}Exécuter le ci-dessus le code, le résultat de sortie est :
$ scalac Test.scala $ scala Test a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5
Opérateurs relationnels
Le tableau suivant répertorie les opérateurs relationnels pris en charge par Scala.
Supposons que la variable A vaut 10 et B vaut 20 :
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 | (A == B) 运算结果为 false |
| != | 不等于 | (A != B) 运算结果为 true |
| > | 大于 | (A > B) 运算结果为 false |
| < | 小于 | (A < B) 运算结果为 true |
| >= | 大于等于 | (A >= B) 运算结果为 false |
| <= | 小于等于 | (A <= B) 运算结果为 true |
Exemple
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
println("a == b = " + (a == b) );
println("a != b = " + (a != b) );
println("a > b = " + (a > b) );
println("a < b = " + (a < b) );
println("b >= a = " + (b >= a) );
println("b <= a = " + (b <= a) );
}
}Exécutez le code ci-dessus, le résultat de sortie est :
$ scalac Test.scala $ scala Test a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = false
Opérateurs logiques
Le tableau suivant répertorie les opérateurs logiques pris en charge par Scala.
Supposons que la variable A soit 1 et que B soit 0 :
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 逻辑与 | (A && B) 运算结果为 false |
| || | 逻辑或 | (A || B) 运算结果为 true |
| ! | 逻辑非 | !(A && B) 运算结果为 true |
Instance
object Test {
def main(args: Array[String]) {
var a = true;
var b = false;
println("a && b = " + (a&&b) );
println("a || b = " + (a||b) );
println("!(a && b) = " + !(a && b) );
}
}exécute le code ci-dessus et le résultat de sortie est :
$ scalac Test.scala $ scala Test a && b = false a || b = true !(a && b) = true
Opérateurs de bits
Les opérateurs de bits sont utilisés pour opérer sur des bits binaires, ~ ,&,|,^ sont respectivement des opérations de négation, ET au niveau du bit, ET au niveau du bit, ET XOR au niveau du bit, comme le montrent les exemples de tableau suivants :
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
Si A = 60 et B = 13 ; Le binaire correspondant aux deux variables est :
A = 0011 1100 B = 0000 1101 -------位运算---------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
Les règles de fonctionnement au niveau du bit dans Scala sont les suivantes :
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
| >>> | 无符号右移 | A >>>2 输出结果 15, 二进制解释: 0000 1111 |
Instance
object Test {
def main(args: Array[String]) {
var a = 60; /* 60 = 0011 1100 */
var b = 13; /* 13 = 0000 1101 */
var c = 0;
c = a & b; /* 12 = 0000 1100 */
println("a & b = " + c );
c = a | b; /* 61 = 0011 1101 */
println("a | b = " + c );
c = a ^ b; /* 49 = 0011 0001 */
println("a ^ b = " + c );
c = ~a; /* -61 = 1100 0011 */
println("~a = " + c );
c = a << 2; /* 240 = 1111 0000 */
println("a << 2 = " + c );
c = a >> 2; /* 215 = 1111 */
println("a >> 2 = " + c );
c = a >>> 2; /* 215 = 0000 1111 */
println("a >>> 2 = " + c );
}
}exécute le code ci-dessus et le résultat de sortie est :
$ scalac Test.scala $ scala Test a & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a << 2 = 240 a >> 2 = 15 a >>> 2 = 15
Opérateurs d'affectation
Ce qui suit répertorie les opérateurs d'affectation pris en charge par Scala langue :
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算，指定右边操作数赋值给左边的操作数。 | C = A + B 将 A + B 的运算结果赋值给 C |
| += | 相加后再赋值，将左右两边的操作数相加后再赋值给左边的操作数。 | C += A 相当于 C = C + A |
| -= | 相减后再赋值，将左右两边的操作数相减后再赋值给左边的操作数。 | C -= A 相当于 C = C - A |
| *= | 相乘后再赋值，将左右两边的操作数相乘后再赋值给左边的操作数。 | C *= A 相当于 C = C * A |
| /= | 相除后再赋值，将左右两边的操作数相除后再赋值给左边的操作数。 | C /= A 相当于 C = C / A |
| %= | 求余后再赋值，将左右两边的操作数求余后再赋值给左边的操作数。 | C %= A is equivalent to C = C % A |
| <<= | 按位左移后再赋值 | C <<= 2 相当于 C = C << 2 |
| >>= | 按位右移后再赋值 | C >>= 2 相当于 C = C >> 2 |
| &= | 按位与运算后赋值 | C &= 2 相当于 C = C & 2 |
| ^= | 按位异或运算符后再赋值 | C ^= 2 相当于 C = C ^ 2 |
| |= | 按位或运算后再赋值 | C |= 2 相当于 C = C | 2 |
Instance
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
var c = 0;
c = a + b;
println("c = a + b = " + c );
c += a ;
println("c += a = " + c );
c -= a ;
println("c -= a = " + c );
c *= a ;
println("c *= a = " + c );
a = 10;
c = 15;
c /= a ;
println("c /= a = " + c );
a = 10;
c = 15;
c %= a ;
println("c %= a = " + c );
c <<= 2 ;
println("c <<= 2 = " + c );
c >>= 2 ;
println("c >>= 2 = " + c );
c >>= 2 ;
println("c >>= a = " + c );
c &= a ;
println("c &= 2 = " + c );
c ^= a ;
println("c ^= a = " + c );
c |= a ;
println("c |= a = " + c );
}
}exécute le code ci-dessus et le résultat de sortie est :
$ scalac Test.scala $ scala Test c = a + b = 30 c += a = 40 c -= a = 30 c *= a = 300 c /= a = 1 c %= a = 5 c <<= 2 = 20 c >>= 2 = 5 c >>= a = 1 c &= 2 = 0 c ^= a = 10 c |= a = 10
La priorité de l'opérateur
peut contenir plusieurs différences dans une expression. Objets de données de différents types de données connectés par des opérateurs ; étant donné que les expressions ont plusieurs opérations, différents ordres d'opération peuvent produire des résultats différents ou même des erreurs d'opération incorrectes, car lorsqu'une expression contient plusieurs opérations, elles doivent être Ce n'est qu'en combinant dans un certain ordre que la rationalité de l'opération peut être obtenue. et l'exactitude et l'unicité des résultats soient assurées.
Les priorités diminuent de haut en bas, celle du haut ayant la priorité la plus élevée et l'opérateur virgule ayant la priorité la plus basse.
Au sein d'une même priorité, le calcul est basé sur l'ordre de combinaison. La plupart des opérations sont calculées de gauche à droite et seuls trois niveaux de priorité sont combinés de droite à gauche : les opérateurs unaires, les opérateurs conditionnels et les opérateurs d'affectation.
Les priorités fondamentales doivent être rappelées :
Les pointeurs sont optimaux et les opérations monoculaires sont meilleures que les opérations binoculaires. Tels que les signes plus et moins.
Multipliez et divisez d'abord (modulo), puis additionnez et soustrayez.
Opérations arithmétiques d'abord, puis opérations de décalage et enfin opérations sur bits. Veuillez prêter une attention particulière à : 1 << 3 + 2 & 7 est équivalent à (1 << (3 + 2))&7
Le calcul final du logique opération
| Type d'opérateur | Opérateur | Combinaison direction | th>||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Opération d'expression | () [] expr++ expr-- | De gauche à droite | <. /tr>< tr>Opérateurs unaires |
| De droite à gauche | |||||||||||||||||||||
| Opérateurs au niveau du bit | <🎜>&<🎜><🎜>^<🎜> <🎜 >|<🎜><🎜>&&<🎜><🎜>||<🎜> | De gauche à droite | ||||||||||||||||||||||||
| Opérateur ternaire | ? : | De droite à gauche | ||||||||||||||||||||||||
| Opérateur d'affectation | = += -= *= /= %= >>= <<= &= ^= |= | De droite à gauche | ||||||||||||||||||||||||
| , | De gauche à droite |
