Scala-Operatoren
Ein Operator ist ein Symbol, das dem Compiler mitteilt, bestimmte mathematische und logische Operationen auszuführen.
Scala ist reich an integrierten Operatoren, darunter die folgenden Typen:
Arithmetische Operatoren
Relationale Operatoren
Logische Operatoren
Bitweise Operatoren
Zuweisungsoperatoren
Als Nächstes werden wir die Anwendungen der oben genannten Operatoren im Detail vorstellen.
Arithmetische Operatoren
Die folgende Tabelle listet die von Scala unterstützten arithmetischen Operatoren auf.
Angenommen, Variable A ist 10 und B ist 20:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| + | Plus | A + B ergibt 30 |
| - | Minus | A - B ergibt -10 |
| * | Multiplikation | A * B ergibt 200 |
| / | Geteilt | B / A ergibt 2 |
| % | Modulo | B % A ergibt 0 |
Beispiel
Beispiel
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) );
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ scalac Test.scala $ scala Test a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5
Relationale Operatoren
Die folgende Tabelle listet die von Scala unterstützten relationalen Operatoren auf.
Angenommen, Variable A ist 10 und B ist 20:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| == | Gleich | (A == B) ergibt false |
| != | Ungleich | (A != B) ergibt true |
| > | Größer als | (A > B) ergibt false |
| < | Kleiner als | (A < B) ergibt true |
| >= | Größer als oder gleich | (A >= B) ergibt false |
| <= | Kleiner als oder gleich | (A <= B) ergibt true |
Beispiel
Beispiel
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) );
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ scalac Test.scala $ scala Test a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = false
Logische Operatoren
Die folgende Tabelle listet die von Scala unterstützten logischen Operatoren auf.
Angenommen, Variable A ist 1 und B ist 0:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| && | Logisches AND | (A && B) ergibt false |
| || | Logisches OR | (A || B) ergibt true |
| ! | Logisches NICHT | !(A && B) ergibt true |
Beispiel
Beispiel
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) );
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ scalac Test.scala $ scala Test a && b = false a || b = true !(a && b) = true
Bitweise Operatoren
Bitweise Operatoren werden verwendet, um mit binären Bits zu arbeiten,~,&,|,^nämlich bitweise NOT-, bitweise AND-, bitweise OR- und bitweise XOR-Operationen, wie in den Beispielen in der folgenden Tabelle gezeigt:
| 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 |
Wenn A = 60; und B = 13; dann lauten die Binärdarstellungen der beiden Variablen:
A = 0011 1100 B = 0000 1101 -------位运算---------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
Die Regeln für bitweise Operationen in Scala lauten wie folgt:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| & | Bitweiser AND-Operator | (a & b) ergibt 12, binäre Erklärung: 0000 1100 |
| | | Bitweiser OR-Operator | (a | b) ergibt 61, binäre Erklärung: 0011 1101 |
| ^ | Bitweiser XOR-Operator | (a ^ b) ergibt 49, binäre Erklärung: 0011 0001 |
| ~ | Bitweiser NOT-Operator | (~a) ergibt -61, binäre Erklärung: 1100 0011, in der Zweierkomplement-Darstellung einer vorzeichenbehafteten Binärzahl. |
| << | Linksverschiebungsoperator | a << 2 ergibt 240, binäre Erklärung: 1111 0000 |
| >> | Rechtsverschiebungsoperator | a >> 2 ergibt 15, binäre Erklärung: 0000 1111 |
| >>> | Vorzeichenlose Rechtsverschiebung | A >>> 2 ergibt 15, binäre Erklärung: 0000 1111 |
Beispiel
Beispiel
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; /* 15 = 1111 */
println("a >> 2 = " + c );
c = a >>> 2; /* 15 = 0000 1111 */
println("a >>> 2 = " + c );
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ 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
Zuweisungsoperatoren
Im Folgenden sind die von der Scala-Sprache unterstützten Zuweisungsoperatoren aufgeführt:
| Operator | Beschreibung | Beispiel |
|---|---|---|
| = | Einfache Zuweisung, weist dem linken Operanden den Wert des rechten Operanden zu. | C = A + B weist C das Ergebnis von A + B zu |
| += | Addieren und zuweisen, addiert den linken und rechten Operanden und weist dann das Ergebnis dem linken Operanden zu. | C += A ist äquivalent zu C = C + A |
| -= | Subtrahieren und zuweisen, subtrahiert den rechten Operanden vom linken Operanden und weist dann das Ergebnis dem linken Operanden zu. | C -= A ist äquivalent zu C = C - A |
| *= | Multiplizieren und zuweisen, multipliziert den linken und rechten Operanden und weist das Ergebnis dann dem linken Operanden zu. | C *= A ist äquivalent zu C = C * A |
| /= | Dividieren und zuweisen, dividiert den linken Operanden durch den rechten Operanden und weist das Ergebnis dann dem linken Operanden zu. | C /= A ist äquivalent zu C = C / A |
| %= | Modulo und zuweisen, nimmt den Rest der Division des linken Operanden durch den rechten Operanden und weist ihn dem linken Operanden zu. | C %= A ist äquivalent zu C = C % A |
| <<= | Bitweise Linksverschiebung und Zuweisung | C <<= 2 ist äquivalent zu C = C << 2 |
| >>= | Bitweise Rechtsverschiebung und Zuweisung | C >>= 2 ist äquivalent zu C = C >> 2 |
| &= | Bitweises UND mit Zuweisung | C &= 2 ist äquivalent zu C = C & 2 |
| ^= | Bitweises XOR mit Zuweisung | C ^= 2 ist äquivalent zu C = C ^ 2 |
| |= | Bitweises ODER mit Zuweisung | C |= 2 ist äquivalent zu C = C | 2 |
Beispiel
Beispiel
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 >>= a ;
println("c >>= a = " + c );
c &= a ;
println("c &= 2 = " + c );
c ^= a ;
println("c ^= a = " + c );
c |= a ;
println("c |= a = " + c );
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ 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 = 0 c &= 2 = 0 c ^= a = 10 c |= a = 10
Die Operatorrangfolge hängt von der Operatorgruppe ab, zu der der Operator gehört, und wirkt sich auf die Auswertung eines Ausdrucks aus.
Beispiel: x = 7 + 3 * 2; hier wird x zu 13 ausgewertet, nicht zu 20, weil die Multiplikation (*) eine höhere Priorität als die Addition (+) hat, sodass zuerst 3*2 berechnet und dann 7 addiert wird.
Siehe die folgende Tabelle. Die Priorität nimmt von oben nach unten ab; oben ist die höchste Priorität, und der Kommaoperator hat die niedrigste Priorität.
| Kategorie | Operator | Assoziativität |
|---|---|---|
| 1 | () [] | Von links nach rechts |
| 2 | ! ~ | Von rechts nach links |
| 3 | * / % | Von links nach rechts |
| 4 | + - | Von links nach rechts |
| 5 | >> >>> << | Von links nach rechts |
| 6 | > >= < <= | Von links nach rechts |
| 7 | == != | Von links nach rechts |
| 8 | & | Von links nach rechts |
| 9 | ^ | Von links nach rechts |
| 10 | | | Von links nach rechts |
| 11 | && | Von links nach rechts |
| 12 | || | Von links nach rechts |
| 13 | = += -= *= /= %= >>= <<= &= ^= |= | Von rechts nach links |
| 14 | , | Von links nach rechts |