Полное руководство по Kotlin: часть 6 (работа с операторами)

Если вы новичок в этой серии, начните с здесь.

Предыдущее сообщение, Часть 5, находится здесь

Теперь давайте продолжим наше путешествие, разобравшись, что такое операторы, и используя их в нашем коде Kotlin.

Операторы — это специальные символы, предназначенные для выполнения специальных вычислений, сравнений и логических операций. А переменные, над которыми выполняются эти операции, называются Операнды. Например, в x + y; x и y — операнды, а + (плюс) — оператор.

Это типы операторов, доступных в Kotlin-

• Арифметические операторы
• Операторы присваивания
• Операторы сравнения/сравнения
• Логические операторы
• Унарные операторы
• Побитовые операторы

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

Эти операторы способны выполнять основные операции.

• плюс (+) → Добавление
• дефис (-) → Вычитание
• звездочка (*) → Умножение
• косая черта (/) → Раздел
• процент (%) → Модуль (получение остатка после деления)

Для Action-Jackson см. рисунок ниже.

Вот код-

fun main(){
    val x = 9; val y = 2

    println(x + y)
    println(x - y)
    println(x * y)
    println(x / y)
    print(x % y)

}

Начиная со строки 2, я создал две переменные x и yв одной строке с помощью символа разделения { точка с запятой (;)}. Затем я напечатал все возможные операции с арифметическими операторами. Вы также можете попробовать смешать эти операторы в выражениях. Затем Kotlin будет выполняться в соответствии с Правилом BODMAS (Скобка деления, умножения, сложения, вычитания). Всякий раз, когда вы хотите изменить порядок выполнения, просто поместите выражение, которое вы хотите вычислить первым, в круглые скобки.

Операторы присваивания

Эти операторы позволяют нам присваивать значения нашим переменным.

• равно (=)
• плюс равно (+=)
• минус равно (-=)
• умножить равно (*=)
• разделить равно (/=)
• остаток равен (%=)

Пример: x += 3 равно x = x+ 3 (означает, что 3 добавляется к предыдущему значению x и сохраняется как новое значение x после выполнения).

fun main(){
    var x = 2
    println(x)
    x += 3
    println(x)
    x -= 3
    println(x)
    x *= 3
    println(x)
    x /= 3
    println(x)
    x %= 3
    print(x)
}

Вывод приведенного выше кода:

Объяснять не надо, вы сами это понимаете. Если нет, прокомментируйте ниже.

Реляционные операторы или операторы сравнения

Эти операторы полезны, когда мы сравниваем два значения. Просто подумайте в целом, если вы спросите, вес моего тела больше, чем у моего друга? Тогда вы получите ответ «Да» или «Нет». Точно так же результат, который вы получите после сравнения двух значений, будет либо true, либо false.

• == → равно (произносится как равное равное)
• != → не равно (произносится как не равно)
• › → больше, чем
• ‹ → меньше чем
• ›= → больше или равно (произносится как больше равно)
• ‹= → меньше или равно (произносится как меньшее равное)

fun main(){
    val x = 4
    val y = 5

    println(x == y)
    println(x != y)
    println(x > y)
    println(x < y)
    println(x >= y)
    print(x <= y)

}

Вывод приведенного выше кода:

Опять же, не нужно пояснений, вы сами это понимаете. Если нет, прокомментируйте ниже.

Логические операторы

Если вы когда-либо изучали таблицу истинности в математике или логические элементы в цифровых схемах, криптографии или где-либо еще, вы должны были знать некоторые логические операции. Эти операции помогают нам выполнять логику между двумя переменными или значениями.

• && → логическое И
• || → логическое ИЛИ
• ! → логическое НЕ

Пример 1

fun main(){
    val x = 2
    val y = 5

    val bool1 = (x < y) && (x > 1)
    val bool2 = (x < y) && (x > 2)

    val bool3 = (x > y) || (x > 1)
    val bool4 = (x > y) || (x < 2)

    val bool5 = !(x > y)
    val bool6 = !(x < y)

    println(bool1)
    println(bool2)
    println(bool3)
    println(bool4)
    println(bool5)
    println(bool6)
}

Вывод приведенного выше кода:

Чтобы понять приведенный выше код, просто поместите его в свой мозг:

• && возвращает true, если оба операнда true, иначе false
• || возвращает true, если любой из операндов true (означает, что любой из них true), в противном случае ложь
• ! возвращает true, если операнд false, и наоборот. Это также отрицает выражение. Если выражение оценивается как false, оно возвращает true при применении оператора not и наоборот.

Пример 2

fun main(){

    val x = true
    val y = false
    val z = true

    println(x.and(y))
    println(y.or(z))
    println(z.not())
}

В приведенном выше коде показано использование функций и(), или() и не().

Унарные операторы

Это специальные операторы, для работы которых требуется только один операнд.

• унарный плюс (+)
• унарный минус (-)
• ++ → увеличить на 1 (можно до или после)
• -- → уменьшить на 1 (можно до или после)
• унарная инверсия (!)→ инвертирует логическое значение

fun main(){
    var x = +3 //unary plus
    val y = -3 //unary minus
    val z = true

    println(x)
    println(y)
    println(!z) //unary inversion


    val a = x++ //post increment
    val b = ++x //pre increment
    val c = x-- //post decrement
    val d = --x //pre decrement

    println(a)
    println(b)
    println(c)
    println(d)
}

Позвольте мне объяснить вам построчно… Обратите внимание🔥

var x = +3 //унарный плюс

Здесь мы знаем, что просто написать 3 было бы нормально. Но унарный оператор плюс также используется для явного указания, что 3 на самом деле является положительной 3.

val y = -3 //унарный минус

Просто, просто введите значение как отрицательное 3, используя унарный оператор минус.

знач z = правда

Объявил логическую переменную z и установил для нее значение true.

println(x)

Напечатано значение, хранящееся внутри x, равное 3.

println(г)

Напечатано значение, хранящееся внутри y, равное -3.

println(!z) //унарная инверсия

Напечатал инвертированное значение z с помощью унарного оператора инверсии, в нашем случае это false (изначально установлено true). сильный>).

val a = x++ //приращение записи

Оператор приращения помещается после переменной x, что означает, что это оператор после приращения. В этом случае значение x сохраняется в a, а затем x Значение увеличивается на 1. Значение x изначально было равно 3 и хранилось в a. Итак, a = 3. Теперь x увеличивается на 1, т. е. x = 4.

val b = ++x //предварительное увеличение

Оператор приращения помещается перед переменной x, что означает, что это оператор перед приращением. В этом случае сначала значение x увеличивается на 1, а новое значение x равно хранится в b. Значение x раньше было 4, а теперь оно увеличивается на 1. Таким образом, x = 5. Теперь , это новое значение x, т. е. 5, сохраняется в b. Итак, b = 5.

val c = x-- //уменьшение значения

Оператор декремента помещается после переменной x, что означает, что это оператор постдекремента. В этом случае значение x сохраняется в c, а затем x Значение уменьшается на 1. Значение x сохраняется в c, а затем значение x уменьшается на 1. Значение xранее было равно 5 и было хранится в c. Итак, c = 5. Теперь x уменьшается на 1, т. е. x = 4.

val d = --x //предварительное уменьшение

Оператор декремента помещается перед переменной x, что означает, что это оператор предварительного декремента. В этом случае сначала значение x уменьшается на 1, а новое значение x равно хранится в d. Значение x раньше было равно 4, а теперь оно уменьшено на 1. Таким образом, x = 3. Теперь , это новое значение x, т. е. 3, сохраняется в d. Итак, d= 3.

В целом значения a, b, c и d равны 3, 5, 5 и 3 соответственно. Теперь проверьте это в выводе приведенного выше кода:

Игнорируйте первые два оператора печати, которые очевидны🙄. Теперь мы видим 3, 5, 5 и 3. Последний оператор вывода привел к false из-за операции унарной инверсии над переменной z.

Ура!… Мы все поняли. Но ждать! Я пропустил еще один тип оператора в Котлине?😢

Побитовые операторы

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

• Двоичная система счисления
• Преобразование числа в десятичной системе в соответствующий двоичный эквивалент
• Преобразование двоичного числа в соответствующий десятичный эквивалент

Двоичная система счисления

В десятичной системе счисления есть 10 чисел, а именно 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Но в двоичной системе счисления мы имеем дело с двумя числами, 0 и 1. Вот почему мы говорим, что десятичная система счисления — это система с основанием 10, а двоичная система счисления — это система с основанием 2.

Компьютеры не понимают буквы, символы и т. д. Они преобразуют все в последовательность 0 и 1, чтобы хранить данные любого типа. Это причина работы с двоичными числами в информатике.

Преобразование числа в десятичной системе в соответствующий двоичный эквивалент

Допустим, вы хотите преобразовать 45 в соответствующий двоичный эквивалент.

Что вы делаете, так это делите 45 на 2 последовательно. Каждый раз, когда вы делите, просто игнорируйте остатки и записывайте числа, которые вы получаете на каждом последующем шаге, справа налево, начиная с 45. Это выглядит так:

Я получаю последовательность чисел 45, 22, 11, 5, 2 и 1. Следующий шаг — поставить 1 под нечетными числами и 0 под четные числа. Соберите все цифры и объедините их так, чтобы получилось 101101, написанное слева.

ПРИМЕЧАНИЕ:- Вы расположили его справа после последовательного деления, но, наконец, объединили слева.

Таким образом, 45 в десятичной системе → 101101 в двоичной системе.

Преобразование двоичного числа в соответствующий десятичный эквивалент

А теперь поступим наоборот. Допустим, я беру двоичное число 101101.

Каждая цифра в двоичном числе расположена в местах (также называемых весами) степеней двойки следующим образом:

Я написал степени 2 as- 1, 2, 4, 8, 16, 32 справа. Затем я помещаю двоичное число, то есть 101101, под ним. Теперь я сложил все числа, в которых соответствующее двоичное значение равно 1. И, наконец, я получил десятичный эквивалент 45.

Итак, 101101 в двоичном формате → 45 в десятичном.

Теперь, когда мы поняли все эти три вещи, касающиеся двоичных чисел, мы готовы понять побитовые операторы.

ПРИМЕЧАНИЕ.Всегда делайте двоичное число 8-битным, добавляя сначала нули.

В двоичном числе каждая цифра называется битом. Итак, мы собираемся выполнить вычисления относительно этих битов, используя вспомогательные функции Kotlin:

или (побитовое ИЛИ)

Он сравнивает соответствующие биты двух значений двух отдельных переменных. Если любой из битов равен 1, он дает 1. Если нет, то выдается 0.

Вот код-

fun main(){

    val a = 10
    val b = 20

    val bitwiseOr = a or b

    print(bitwiseOr)
}

И a, и b преобразуются в двоичную форму. Затем их соответствующие биты сравниваются, как показано ниже:

и (побитовое И)

Он сравнивает соответствующие биты двух значений двух отдельных переменных. Если оба бита равны 1, это дает 1. Если любой из битов равен 0, он дает 0.

Вот код-

fun main(){

    val a = 10
    val b = 25

    val bitwiseAnd = a and b

    print(bitwiseAnd)
}

xor (побитовое исключающее ИЛИ)

Он сравнивает соответствующие биты двух значений двух отдельных переменных. Если оба бита совпадают, это дает 0, а если оба бита разные, это дает 1.

Вот код-

fun main(){

    val a = 10
    val b = 25

    val bitwiseXor = a xor b

    print(bitwiseXor)
}

inv() (функция побитовой инверсии)

Он преобразует битовую комбинацию любого числа в противоположную. Это означает, что он инвертирует битовый шаблон. Другими словами, он преобразует 0 в 1 и 1 в 0 в определенном битовом шаблоне.

Вот код-

fun main(){

    val a = 20

    val bitwiseInverse = a.inv()

    print(bitwiseInverse)
}

После применения побитовой обратной функции к 20 (эквивалентно 00010100 в двоичном формате), мы получим 11101011 в качестве двоичного, что равно 235 в десятичном эквиваленте. Но на выходе ясно видно, что это -21. Странно… Почему?

Это произошло из-за концепции под названием дополнение до 2. Вы просто заменяете 11101011 отрицательным дополнением до 2 числа 11101011.

Чтобы найти дополнение до двойки двоичного числа: начните справа, запишите все биты как есть, пока не получите первую 1. Как только вы достигли 1, после этого просто инвертируйте каждый бит.

Например, допустим, мне нужно найти дополнение 2 до 10100. Итак, начиная справа, мы пишем как 0, 0, 1. Мы достигли первой 1. Теперь инвертируем все остальные биты. Итак, получается 1, 0. Итак, ответ будет слева направо- 01100.

Итак, теперь давайте возьмем исходный случай — 11101011 (это то, что мы получили ранее после применения функции inv()).

Теперь, начиная справа, мы получаем 1 напрямую. Итак, мы достигли первой 1. Теперь давайте инвертируем каждый последующий бит — 0, 1, 0, 1, 0, 0, 0. Наконец, получается — 00010101. Десятичный эквивалент этого двоичного числа равен 21. Затем поместите отрицательное знак к нему (по определению дополнения до 2). Таким образом, это становится -21, что является нашим выходом на рисунке выше.

ПРИМЕЧАНИЕ:- Мы хорошо знакомы с арифметическими расчетами чисел в десятичной системе. Но мой вам совет: вы должны узнать об арифметических операциях, возможных с двоичными числами.

shl (побитовый сдвиг влево)

Он сдвигает битовый шаблон влево на определенное количество заданных битов, а пробелы, которые создаются справа, заполняются нулями.

Вот код-

fun main(){

    val a = 20

    val bitwiseShiftLeft = a shl 3

    print(bitwiseShiftLeft)
}

Обратите внимание, что пробелы, созданные справа при смещении битовой комбинации влево, заполнены нулями. В приведенном выше коде я передал shl 3, что означает сдвиг битовой комбинации на 3 позиции влево.

Если передается shl 0, шаблон остается таким, какой он есть, и в выводе отображается десятичный эквивалент.

шр (побитовый сдвиг вправо)

Он сдвигает битовый шаблон вправо на определенное количество заданных битов. Битовый шаблон нарезается справа в соответствии с указанными битами, а промежутки, которые создаются слева, заполняются нулями.

Если передается shr 0, шаблон остается таким, какой он есть, а десятичный эквивалент отражается в выводе.

Вот код-

fun main(){

    val a = 20

    val bitwiseShiftRight = a shr 3

    print(bitwiseShiftRight)
}

Не надо объяснять, вы все правильно поняли!

Ладно, это слишком. Давайте закончим это здесь.😒

→ Продолжить путешествие к Часть 7

Спасибо, что прочитали…

✍️Аджит Кумар Саху