есть ли у kotlin примитивные типы данных такие как int long float

Базовые типы

В Kotlin нет примитивных типов int, float, double и т.д., всё является объектами. Соответственно, вместо примитивных типов используются объекты Byte, Short, Int (не Integer как в Java), Double, Char, Float, Long, Boolean.

Float и Double являются числами с плавающей точкой и могут содержать 32 и 64 бита соответственно.

Переменную типа Int нельзя присвоить переменной Long автоматически, нужно это сделать явно.

Присвоить значение одного типа переменной другой типа можно при помощи специальных функций toByte(), toInt(), toLong(), toFloat(), toDouble(), toChar(), toShort(). Одну мы уже использовали выше.

Переводим строку в число.

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

Можно представить число в двоичном коде, добавив префикс 0b. Для представления в шестнадцатеричной форме используется префикс 0x. Восьмеричная форма не поддерживается.

В числах можно использовать символ подчёркивания для удобного чтения больших величин.

Boolean

Сравнение этого типа аналогично как во многих языках.

Перевести булево значение в строку можно через toString().

Для символов используется класс Char. Символ обрамляется одиночными кавычками. Проверим, что это символ.

Если из контекста понятно, о каком типе идёт речь, то его можно опустить.

Тип Char нельзя использовать как число (как в Java), поэтому прибегаем к функции.

Аналогично используем toByte() и др. похожие функции.

Функции проверки регистра символа и перевода в верхний или нижний регистр.

Для проверки, является ли символ цифрой или буквой, используем Char.isDigit() и Char.isLetter().

Битовые операции происходят иначе. Если в Java используются специальные символы для сравнения: | для ИЛИ (OR) или & для И (AND), то в Kotlin не нужно запоминать, пишем словами.

Другие виды побитовых операторов: shl (signed shift left (Java >)), ushr (unsigned shift right (Java >>>)), xor, inv.

Определить тип числа

Узнать тип числа можно через конструкцию ::class.

Узнать максимальное число из двух

Функция maxOf() позволяет узнать максимальное число из двух предложенных вариантов.

При сравнении объектов нужно добавить третий аргумент с компаратором.

Можно сравнивать не только два значения, но и три.

Источник

Основные типы

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

Числа

Kotlin обрабатывает численные типы примерно так же, как и Java, хотя некоторые различия всё же присутствуют. Например, отсутствует неявное расширяющее преобразование для чисел, а литералы в некоторых случаях немного отличаются.

Для представления чисел в Kotlin используются следующие встроенные типы (подобные типам в Java):

Обратите внимание, что символы (characters) в языке Kotlin не являются числами (в отличие от Java).

Символьные постоянные

В языке Kotlin присутствуют следующие виды символьных постоянных (констант) для целых значений:

ВНИМАНИЕ: Восьмеричные литералы не поддерживаются.

Также Kotlin поддерживает числа с плавающей запятой:

Нижние подчеркивания в числовых литералах (начиная с версии 1.1)

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

Представление

Обычно платформа Java хранит числа в виде примитивных типов JVM; если же нам необходима ссылка, которая может принимать значение null (например, Int? ), то используются обёртки. В приведённом ниже примере показано использование обёрток.

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

Однако, равенство по значению сохраняется:

Явные преобразования

Из-за разницы в представлениях меньшие типы не являются подтипами бОльших типов. В противном случае у нас возникли бы сложности:

Таким образом, будет утрачена не только тождественность (равенство по ссылке), но и равенство по значению.

Как следствие, неявное преобразование меньших типов в большие НЕ происходит. Это значит, что мы не можем присвоить значение типа Byte переменной типа Int без явного преобразования:

Мы можем использовать явное преобразование для «расширения» чисел

Каждый численный тип поддерживает следующие преобразования:

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

Арифметические действия

Kotlin поддерживает обычный набор арифметических действий над числами, которые объявлены членами соответствующего класса (тем не менее, компилятор оптимизирует вызовы вплоть до соответствующих инструкций). См. Перегрузка операторов.

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

Ниже приведён полный список битовых операций (доступны только для типов Int и Long ):

Символы

Подобно числам, символы оборачиваются при необходимости использования nullable ссылки. При использовании обёрток тождественность (равенство по ссылке) не сохраняется.

Логический тип

При необходимости использования nullable ссылок логические переменные оборачиваются.

Встроенные действия над логическими переменными включают

Массивы

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

Строки

Строковые литералы

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

Экранирование выполняется общепринятым способом, а именно с помощью обратной косой черты.

Обычная строка выделена тройной кавычкой ( «»» ), не содержит экранированных символов, но может содержать символы новой строки и любые другие символы:

Строковые шаблоны

Строки могут содержать шаблонные выражения, т.е. участки кода, которые выполняются, а полученный результат встраивается в строку. Шаблон начинается со знака доллара ($) и состоит либо из простого имени (например, переменной):

либо из произвольного выражения в фигурных скобках:

Источник

BestProg

Базовые типы. Числовые литералы. Числовые константы. Примеры

Содержание

Поиск на других ресурсах:

1. Классификация базовых типов

Чтобы использовать в программе некоторую переменную (объект), нужно правильно описать тип этой переменной. Согласно описанному типу определяется назначение переменной в программе. В языке Kotlin выделено 5 видов базовых типов:

2. Классификация числовых типов. Характеристики типов

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

2.1. Целочисленные типы

В нижеследующей таблице представлены характеристики целочисленных типов.

Если в программе фигурирует целое число (литерал), то для него действуют следующие правила:

Примеры целочисленных литералов

2.2. Типы с плавающей запятой

Для чисел с плавающей запятой характерна следующая таблица.

Согласно стандарту IEEE 754 для чисел с плавающей запятой характерны следующие утверждения:

Разделителем разрядов в числах с плавающей запятой выступает символ ‘.’ (точка).

Примеры чисел с плавающей запятой

3. Примеры объявления и использования целочисленных типов

Результат выполнения программы

4. Примеры объявления и использования типов с плавающей запятой

Результат выполнения программы

5. Представление числовых констант в шестнадцатеричной системе исчисления

Целочисленные константы могут быть представлены в системе исчисления с основанием 16. В этой системе исчисления для обозначения числа используются:

Пример. Объявление целочисленных констант в шестнадцатеричной системе счисления

В десятичной системе исчисления значение h1 равно 165. Так же значение h2 равно 248.

6. Представление числовых констант (литералов) в двоичной системе исчисления

Пример.

Нижеприведенный код вызовет ошибку «The value is out of range»

7. Представление числовых констант в более читабельной форме. Символ ‘_’

Пример 1. Способы представления числа 1000000000 (один миллиард):

Пример 2. Способы представления двоичного числа 15

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

9. Вывод допустимых значений типов с плавающей запятой. Пример

Результат выполнения программы

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

В примере выводится минимально-допустимое и максимально-допустимое значение беззнаковых типов UByte

Источник

Русские Блоги

Котлин основные типы

цифровой

Три метода шестнадцатеричного представления:

Примечание: восьмеричное число не поддерживается

Kotlin также поддерживает общее представление чисел с плавающей запятой:
По умолчанию double: 123.5, 123.5e10
Поплавок отмечен буквой f или F: 123.5f

Подчеркивание в числах (начиная с версии 1.1)

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

Сравните два числа

В Kotlin нет основных типов данных, только инкапсулированные числовые типы.Каждый раз, когда вы определяете переменную, Kotlin фактически инкапсулирует объект для вас, чтобы гарантировать, что не будет нулевых указателей. То же самое и с числовыми типами: при сравнении двух чисел есть разница между сравнением размера данных и сравнением того, являются ли два объекта одинаковыми.
В Kotlin три знака равенства === указывают адрес объекта сравнения, а два == указывают величину сравнения двух значений.

Преобразование типов

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

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

Следовательно, меньшие типы не могут быть неявно преобразованы в более крупные типы. Это означает, что мы не можем присвоить значение Byte переменной Int без явного преобразования.

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

Каждый числовой тип поддерживает следующие преобразования:

Отсутствие неявного преобразования типа не имеет значения, поскольку тип будет выводиться из контекста, а арифметические операции будут перегружены для правильного преобразования, например:

Расчет

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

Это полный список битовых операций (только для Int и Long):

характер

Char
представление типа. Их нельзя рассматривать напрямую как числа

Мы можем явно преобразовать символы в числа ** Int **:

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

Булево

БулевоBooleanТип указывает, что он имеет два значения:true с участием false。
Обнуляемая ссылка Boolean будет помещена в рамку при необходимости.
Встроенные логические операции:

Массив

Массивы представлены в Kotlin классом Array, который определяет функции get и set (которые будут преобразованы в []) в соответствии с соглашением о перегрузке операторов, атрибутом размера и некоторыми другими полезными функциями-членами:

Как упоминалось выше, оператор ** [] ** представляет вызывающие функции-членыget()с участием set()。

Примечание. В отличие от Java массивы в Kotlin неизменны. Это означает, что Котлин не позволит намArray Назначить наArray Чтобы предотвратить возможные сбои во время выполнения (но вы можете использоватьArray ）。

В Kotlin также есть специальные классы без накладных расходов для представления примитивных массивов: ByteArray, ShortArray, IntArray и т. Д. Эти классы не имеют отношения наследования с Array, но имеют одинаковый набор атрибутов метода. У них также есть соответствующие фабричные методы:

Строка

Символьная строка представлена ​​типом String. Строки неизменны. Доступ к элементам строковых символов можно получить с помощью оператора индекса: s [i]. Можешь использовать for Пропустите строку:

Строковый литерал

В Kotlin есть два типа строковых литералов: экранированные строки могут иметь escape-символы, а собственные строки могут содержать символы новой строки и произвольный текст. Экранированные строки очень похожи на строки Java:

Для экранирования используется традиционный метод обратной косой черты. См. Символ выше], чтобы увидеть поддерживаемые escape-последовательности.
Родная строка Используйте три разделителя в кавычках («» «), они не имеют внутреннего выхода и могут содержать символы новой строки и любые другие символы:

Вы можете удалить ведущие пробелы с помощью функции trimMargin:

По умолчанию ** | ** используется как префикс границы, но вы можете выбрать другие символы и передать их в качестве параметров, напримерtrimMargin(«>»)。

Шаблон строки

Или любое выражение, заключенное в фигурные скобки:

Источник

Basic types

Numbers

Integer types

Kotlin provides a set of built-in types that represent numbers.
For integer numbers, there are four types with different sizes and, hence, value ranges.

-9,223,372,036,854,775,808 (-2 63 )

Floating-point types

To convert numeric values to different types, use Explicit conversions.

Literal constants

There are the following kinds of literal constants for integral values:

Longs are tagged by a capital L : 123L

Octal literals are not supported.

Kotlin also supports a conventional notation for floating-point numbers:

Floats are tagged by f or F : 123.5f

You can use underscores to make number constants more readable:

Numbers representation on the JVM

Note that nullable references to the same number can be different objects:

On the other hand, they are still equal:

Explicit conversions

Due to different representations, smaller types are not subtypes of bigger ones. If they were, we would have troubles of the following sort:

So equality would have been lost silently, not to mention identity.

As a consequence, smaller types are NOT implicitly converted to bigger types. This means that assigning a value of type Byte to an Int variable requires an explicit conversion.

All number types support conversions to other types:

In many cases, there is no need for explicit conversions because the type is inferred from the context, and arithmetical operations are overloaded for appropriate conversions, for example:

Operations

You can also override these operators for custom classes. See Operator overloading for details.

Division of integers

Division between integers numbers always returns an integer number. Any fractional part is discarded.

This is true for a division between any two integer types.

To return a floating-point type, explicitly convert one of the arguments to a floating-point type.

Bitwise operations

Here is the complete list of bitwise operations:

shl(bits) – signed shift left

shr(bits) – signed shift right

ushr(bits) – unsigned shift right

and(bits) – bitwise and

or(bits) – bitwise or

xor(bits) – bitwise xor

inv() – bitwise inversion

Floating-point numbers comparison

The operations on floating-point numbers discussed in this section are:

When the operands a and b are statically known to be Float or Double or their nullable counterparts (the type is declared or inferred or is a result of a smart cast), the operations on the numbers and the range that they form follow the IEEE 754 Standard for Floating-Point Arithmetic.

NaN is considered equal to itself

NaN is considered greater than any other element including POSITIVE_INFINITY

-0.0 is considered less than 0.0

Unsigned integers

In addition to integer types, Kotlin provides the following types for unsigned integer numbers:

UByte : an unsigned 8-bit integer, ranges from 0 to 255

UShort : an unsigned 16-bit integer, ranges from 0 to 65535

Unsigned types support most of the operations of their signed counterparts.

Changing type from unsigned type to signed counterpart (and vice versa) is a binary incompatible change.

Unsigned arrays and ranges

Unsigned arrays and operations on them are in Beta. They can be changed incompatibly at any time. Opt-in is required (see the details below).

As with primitives, each unsigned type has a corresponding type that represents arrays of that type:

UByteArray : an array of unsigned bytes

UShortArray : an array of unsigned shorts

UIntArray : an array of unsigned ints

ULongArray : an array of unsigned longs

Like signed integer arrays, they provide an API similar to the Array class without boxing overhead.

When you use unsigned arrays, you’ll get a warning that indicates that this feature is not stable yet. To remove the warning, opt in using the @ExperimentalUnsignedTypes annotation. It’s up to you to decide if your clients have to explicitly opt-in into usage of your API, but keep in mind that unsigned array are not a stable feature, so an API which uses them can be broken by changes in the language. Learn more about opt-in requirements.

Literals

To make unsigned integers easier to use, Kotlin provides an ability to tag an integer literal with a suffix indicating a specific unsigned type (similarly to Float or Long ):

u and U tag unsigned literals. The exact type is determined based on the expected type. If no expected type is provided, compiler will use UInt or ULong depending on the size of literal.

uL and UL explicitly tag literal as unsigned long.

Further discussion

See language proposal for unsigned types for technical details and further discussion.

Booleans

Boolean has a nullable counterpart Boolean? that also has the null value.

Built-in operations on booleans include:

|| – disjunction (logical OR)

&& – conjunction (logical AND)

On JVM: nullable references to boolean objects are boxed similarly to numbers.

Characters

If a value of character variable is a digit, you can explicitly convert it to an Int number using the digitToInt() function.

On JVM: Like numbers, characters are boxed when a nullable reference is needed. Identity is not preserved by the boxing operation.

Strings

Strings are immutable. Once you initialize a string, you can’t change its value or assign a new value to it. All operations that transform strings return their results in a new String object, leaving the original string unchanged.

To concatenate strings, use the + operator. This also works for concatenating strings with values of other types, as long as the first element in the expression is a string:

Note that in most cases using string templates or raw strings is preferable to string concatenation.

String literals

Kotlin has two types of string literals:

escaped strings that may contain escaped characters

raw strings that can contain newlines and arbitrary text

Here’s an example of an escaped string:

Escaping is done in the conventional way, with a backslash ( \ ). See Characters above for the list of supported escape sequences.

A raw string is delimited by a triple quote ( «»» ), contains no escaping and can contain newlines and any other characters:

To remove leading whitespace from raw strings, use the trimMargin() function:

String templates

or an expression in curly braces:

Arrays

Arrays in Kotlin are represented by the Array class. It has get and set functions that turn into [] by operator overloading conventions, and the size property, along with other useful member functions:

Another option is to use the Array constructor that takes the array size and the function that returns values of array elements given its index:

Primitive type arrays

Источник