Операторы Scala
Оператор — это символ, который указывает компилятору выполнять заданные математические и логические операции.
Scala богата встроенными операторами, включая следующие типы:
Арифметические операторы
Операторы отношения
Логические операторы
Побитовые операторы
Операторы присваивания
Далее мы подробно рассмотрим применение вышеуказанных операторов.
Арифметические операторы
В следующей таблице перечислены арифметические операторы, поддерживаемые Scala.
Предположим, что переменная A равна 10, а B равна 20:
| Operator | Описание | Пример |
|---|---|---|
| + | Плюс | A + B вычисляется как 30 |
| - | Минус | A - B вычисляется как -10 |
| * | Умножение | A * B вычисляется как 200 |
| / | Деление | B / A вычисляется как 2 |
| % | Остаток от деления | B % A вычисляется как 0 |
Пример
Пример
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) );
}
}
Выполнение приведенного выше кода дает следующий вывод:
$ scalac Test.scala $ scala Test a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5
Операторы отношения
В следующей таблице перечислены операторы сравнения, поддерживаемые Scala.
Предположим, что переменная A равна 10, а B равна 20:
| Operator | Описание | Пример |
|---|---|---|
| == | Равно | (A == B) вычисляется как false |
| != | Не равно | (A != B) вычисляется как true |
| > | Больше | (A > B) вычисляется как false |
| < | Меньше | (A < B) вычисляется как true |
| >= | Больше или равно | (A >= B) вычисляется как false |
| <= | Меньше или равно | (A <= B) вычисляется как true |
Пример
Пример
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) );
}
}
Выполнение приведенного выше кода дает следующий вывод:
$ scalac Test.scala $ scala Test a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = false
Логические операторы
В следующей таблице перечислены логические операторы, поддерживаемые в Scala.
Предположим, переменная A равна 1, а B равна 0:
| Operator | Описание | Пример |
|---|---|---|
| && | Логическое И | (A && B) вычисляется как false |
| || | Логическое ИЛИ | (A || B) вычисляется как true |
| ! | Логическое НЕ | !(A && B) вычисляется как true |
Пример
Пример
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) );
}
}
Выполнение приведенного выше кода дает следующий вывод:
$ scalac Test.scala $ scala Test a && b = false a || b = true !(a && b) = true
Побитовые операторы
Побитовые операторы используются для работы с двоичными битами,~,&,|,^а именно побитовые операции NOT, AND, OR и XOR, как показано в примерах в следующей таблице:
| 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 |
Если A = 60; и B = 13; двоичные представления этих двух переменных таковы:
A = 0011 1100 B = 0000 1101 -------位运算---------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
Правила побитовых операций в Scala таковы:
| Operator | Описание | Пример |
|---|---|---|
| & | Побитовый оператор AND | (a & b) выводит 12, двоичное пояснение: 0000 1100 |
| | | Побитовый оператор OR | (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 |
Пример
Пример
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 );
}
}
Выполнение приведенного выше кода дает следующий вывод:
$ 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
Операторы присваивания
Ниже перечислены операторы присваивания, поддерживаемые языком Scala:
| Operator | Описание | Пример |
|---|---|---|
| = | Простое присваивание — присваивает значение правого операнда левому операнду. | 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 эквивалентно 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 |
Пример
Пример
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 );
}
}
Выполнение приведенного выше кода дает следующий вывод:
$ 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
Приоритет оператора зависит от группы операторов, к которой относится оператор, и влияет на вычисление выражения.
Пример: x = 7 + 3 * 2; здесь x вычисляется как 13, а не 20, потому что умножение (*) имеет более высокий приоритет, чем сложение (+), поэтому сначала вычисляется 3*2, а затем прибавляется 7.
См. следующую таблицу. Приоритет уменьшается сверху вниз; верхняя строка обладает наивысшим приоритетом, а оператор запятая — самым низким.
| Категория | Operator | Ассоциативность |
|---|---|---|
| 1 | () [] | Слева направо |
| 2 | ! ~ | Справа налево |
| 3 | * / % | Слева направо |
| 4 | + - | Слева направо |
| 5 | >> >>> << | Слева направо |
| 6 | > >= < <= | Слева направо |
| 7 | == != | Слева направо |
| 8 | & | Слева направо |
| 9 | ^ | Слева направо |
| 10 | | | Слева направо |
| 11 | && | Слева направо |
| 12 | || | Слева направо |
| 13 | = += -= *= /= %= >>= <<= &= ^= |= | Справа налево |
| 14 | , | Слева направо |