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

Последнее обновление: 23.05.2021

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

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
    
Помощь сайту
WebMoney
  • P378451176208
  • Z280152397659
ЮMoney/Яндекс-Деньги
  • 410011174743222
PayPal
  • metanit22@mail.ru
Перевод на карту
  • Номер карты: 4048415020898850