Операции с числами

Арифметические операции

Kotlin поддерживает базовые арифметические операции:

• + (сложение): возвращает сумму двух чисел.

  val x = 5
  val y = 6
  val z = x + y
  println(z)      // z = 11
  

• - (вычитание): возвращает разность двух чисел.

  val x = 5
  val y = 6
  val z = x - y  // z = -1
  

• * (умножение): возвращает произведение двух чисел.

  val x = 5
  val y = 6
  val z = x * y  // z = 30
  

• / (деление): возвращает частное двух чисел.

  val x = 60
  val y = 10
  val z = x / y  // z = 6
  

  При этом если в операции деления оба операнда представляют целые числа, то результатом тоже будет целое число, а если в процессе деления образовалась дробная часть, то она отбрасывается:

  fun main() {
  
      val x = 11
      val y = 5
      val z = x / y  // z =2
      println(z)// 2
  }
  

  Так в данном случае, хотя если согласно стандартной математике разделить 11 на 5, то получится 2.2. Однако поскольку оба операнда представляют целочисленный тип, а именно тип Int, то дробная часть - 0.2 отрабрасывается, поэтому результатом будет число 2, а переменная z будет представлять тип Int.

  Чтобы результатом было дробное число, один из операндов должен представлять число с плавающей точкой:

  fun main() {
  
      val x = 11
      val y = 5.0
      val z = x / y  	// z =2.2
      println(z)		// 2.2
  }
  

  В данном случае переменная y представляет тип Double, поэтому результатом деления будет число 2.2, а переменная z также будет представлять тип Double

• %: возвращает остаток от целочисленного деления двух чисел.

  val x = 65
  val y = 10
  val z = x % y  // z = 5
  

• ++ (инкремент): увеличивает значение на единицу.

  Префиксный инкремент возвращает увеличенное значение:

  var x = 5
  val y = ++x
  println(x)      // x = 6
  println(y)      // y = 6
  

  Постфиксный инкремент возвращает значение до увеличения на единицу:

  var x = 5
  val y = x++
  println(x)      // x = 6
  println(y)      // y = 5
  

• -- (декремент): уменьшает значение на единицу.

  Префиксный декремент возвращает уменьшенное значение:

  var x = 5
  val y = --x
  println(x)      // x = 4
  println(y)      // y = 4
  

  Постфиксный декремент возвращает значение до уменьшения на единицу:

  var x = 5
  val y = x--
  println(x)      // x = 4
  println(y)      // y = 5
  

Также есть ряд операций присвоения, которые сочетают арифметические операции и присвоение:

• +=: присваивание после сложения. Присваивает левому операнду сумму левого и правого операндов: A += B эквивалентно A = A + B

• -=: присваивание после вычитания. Присваивает левому операнду разность левого и правого операндов: A -= B эквивалентно A = A - B

• *=: присваивание после умножения. Присваивает левому операнду произведение левого и правого операндов: A *= B эквивалентно A = A * B

• /=: присваивание после деления. Присваивает левому операнду частное левого и правого операндов: A /= B эквивалентно A = A / B

• %=: присваивание после деления по модулю. Присваивает левому операнду остаток от целочисленного деления левого операнда на правый: A %= B эквивалентно A = A % B

Поразрядные операции

Ряд операций выполняется над двоичными разрядами числа. Здесь важно понимать, как выглядит двоичное представление тех или иных чисел. В частности, число 4 в двоичном виде - 100, а число 15 - 1111.

Есть следующие поразрядные операторы (они применяются только к данным типов Int и Long):

• shl: сдвиг битов числа со знаком влево

  val z = 3 shl 2     // z = 11 << 2 = 1100 
  println(z)          // z = 12
  val d = 0b11 shl 2
  println(d)          // d = 12
  

  В данном случае число сдвигается на два разряда влево, поэтому справа число в двоичном виде дополняется двумя нулями. То есть в двоичном виде 3 представляет 11. Сдвигаем на два разряда влево (дополняем справа двумя нулями) и получаем 1100, то есть в десятичной системе число 12.

• shr: сдвиг битов числа со знаком вправо

  val z = 12 shr 2     // z = 1100 >> 2 = 11
  println(z)          // z = 3
  val d = 0b1100 shr 2
  println(d)          // d = 3
  

  Число 12 сдвигается на два разряда вправо, то есть два числа справа факически отбрасываем и получаем число 11, то есть 3 в десятичой системе.

• ushr: сдвиг битов беззнакового числа вправо

  val z = 12 ushr 2     // z = 1100 >> 2 = 11
  println(z)          // z = 3
  

• and: побитовая операция AND (логическое умножение или конъюнкция). Эта операция сравнивает соответствующие разряды двух чисел и возвращает единицу, если эти разряды обоих чисел равны 1. Иначе возвращает 0.

  val x = 5   // 101
  val y = 6   // 110
  val z = x and y     // z = 101 & 110 = 100
  println(z)          // z = 4
  
  val d = 0b101 and 0b110
  println(d)          // d = 4
  

• or: побитовая операция OR (логическое сложение или дизъюнкция). Эта операция сравнивают два соответствуюших разряда обоих чисел и возвращает 1, если хотя бы один разряд равен 1. Если оба разряда равны 0, то возвращается 0.

  val x = 5   // 101
  val y = 6   // 110
  val z = x or y     // z = 101 | 110 = 111
  println(z)         // z = 7
  
  val d = 0b101 or 0b110
  println(d)          // d = 7
  

• xor: побитовая операция XOR. Сравнивает два разряда и возвращает 1, если один из разрядов равен 1, а другой равен 0. Если оба разряда равны, то возвращается 0.

  val x = 5   // 101
  val y = 6   // 110
  val z = x xor y     // z = 101 ^ 110 = 011
  println(z)         // z = 3
  
  val d = 0b101 xor 0b110
  println(d)          // d = 3
  

• inv: логическое отрицание или инверсия - инвертирует биты числа

  val b = 11  // 1011
  val c = b.inv()
  println(c)      // -12