5 лаконичных синтаксисов Java, которых мне не хватает в Kotlin

С 2016 года, после того, как я начал использовать Kotlin в Android-разработке, то ни разу не скучал по Java. В целом, Kotlin дал мне большее удовлетворение от разработки, чем Java для Android.

Тем не менее, время от времени я натыкаюсь на такие вещи, которых мне очень не хватает; того, как они были реализованы в Java. Ниже представлены 5 из них.

1. Тернарный оператор

В Java для простой булевой логики вместо того, чтобы писать if-else, мы можем использовать тернарный оператор, как показано ниже.

selector ? function1() : function2();

В Kotlin нам придется прибегнуть к традиционному if-else

if (selector) function1() else function2()

Не так уж плохо. Просто он чуть более многословен, чем тернар, который мне нравится использовать в Java.

2. Статическая переменная

В Java, чтобы объявить статическую переменную в классе, достаточно использовать традиционный стиль языка C, просто поставив перед ней ключевое слово static.

class SomeClass {
    static int STATIC_INTEGER = 1
}

А в Kotlin мы должны использовать вложенный companion object.

class SomeClass {
    companion object {
        val static_integer = 1
    }   
}

Конечно, companion object в целом является более мощной функцией Kotlin в сравнении со static в Java, как утверждается в этом StackOverflow.

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

3. Побитовый оператор

В Java у нас есть лаконичный побитовый оператор. Применив его, я могу прописать более традиционный способ обработки битов, известный нам ещё со времён языка C.

int twoPowerOf = 2<<x;
int removeTransparent = 0xFF000000|color;

В Kotlin мы можем сделать это, используя побитовые ключевые слова.

val twoPowerOf = 2 shl x
var removeTransparent = 0xFF000000 or color

Не так уж и плохо. Просто это не совсем традиционно.

4. Цикл инкремента чисел с плавающей точкой  

Когда я нарисовал графики, как показано ниже, мне нужно циклически перебрать числа с плавающей точкой.

В Java можно легко сделать это так:

for (float i = 0; i <= 10; i += 0.1) {
    // Do something with i
}

В Kotlin у нас нет традиционной возможности использовать цикл. Но мы все равно можем проделать это, как показано ниже, и вручную разделить:

(0..100).forEach {
    val i = it/10f
    // Do something with i
}

Или использовать цикл с предусловием (while-loop), как поделились  в этом StackOverflow. Недостатком while-loop является то, что управляющая переменная должна быть установлена и инкрементирована вне цикла.

var i = 0f
while (i <= 10f) {
    // Do something with i
    i += 0.1f
}

5. Объявление нескольких переменных

В Java можно объявить несколько переменных одного типа, как показано ниже:

int w = 8, x = 10, y = 12, z = 14;

В Kotlin, поскольку тип иногда выводится, лучшее, что мы можем сделать, это использовать точку с запятой:

val w = 8; val x = 10; val y = 12; val z = 14

Получилось чуть более многословно. Полагаю, что не стоит жаловаться, поскольку в Kotlin существует умная возможность неявного приведения типов при компиляции.

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

---

Перевод материала подготовлен для будущих учащихся на Java Developer Bootcamp. Также скоро состоится открытый урок «Разветывание и управление java-сервисами в облаке», на который приглашаем всех желающих. На этом занятии мы собираемся:

• увидеть docker и kubernetes в работе;

• научиться средствами github настраивать непрерывное развертывание сервиса в облаке;

• познакомиться со средствами мониторинга состояние сервиса и используемых им ресурсов;

• найти и исправить баги.