Содержание

Java long максимальное значение • Вэб-шпаргалка для интернет предпринимателей!

Содержание

  • 1 1.1. Базовые типы данных
    • 1.1 Немного теории
    • 1.2 Описание примера
      • 1.2.1 Работа с переменными типа boolean
      • 1.2.2 Работа с переменными типа byte
      • 1.2.3 Работа с переменными типа char
      • 1.2.4 Работа с переменными типа short
      • 1.2.5 Работа с переменными типа int
      • 1.2.6 Работа с переменными типа long
      • 1.2.7 Работа с переменными типа float
      • 1.2.8 Работа с переменными типа double
  • 2 Простые числовые типы
  • 3 Целочисленные типы
    • 3.1 Тип byte
    • 3.2 Тип short
    • 3.3 Тип int
      • 3.3.1 Сказка про тип int
      • 3.3.2 Деление целочисленных чисел
      • 3.3.3 Как сконвертировать строку или CharSequence в int?
      • 3.3.4 Как сконвертировать число в строку?
      • 3.3.5 Добавить ведущие нули
    • 3.4 Тип long
  • 4 Типы с плавающей точкой
    • 4. 1 Тип float
    • 4.2 Тип double
    • 4.3 Конвертация строки в double
    • 4.4 Конвертация double в строку
  • 5 Символы (тип char)
    • 5.1 Класс Character
  • 6 Булевы значения
    • 6.1 Класс Boolean
  • 7 Приведение типов
  • 8 Содержание
  • 9 Примитивные типы [ править ]
    • 9.1 Целочисленные типы [ править ]
    • 9.2 Типы с плавающей точкой [ править ]
    • 9.3 Логический тип [ править ]
  • 10 Ссылочные [ править ]
    • 10.1 Строки [ править ]
    • 10.2 Обертки [ править ]
    • 10.3 Рекомендуем к прочтению

Логический тип boolean может принимать только два значения: false и true. Они никаким образом не соотносятся со значениями численных типов. Поэтому вы не можете выполнить преобразование типа boolean, например, в тип int.

В этом примере мы будем демонстрировать методы работы с базовыми типами данных.

Описание примера

Наш пример представляет собой автономную программу Java. Когда она запускается, управление передается методу main:

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

Перед началом каждой серии операций мы выводим на консоль название соответствующего типа данных.

Работа с переменными типа boolean

Прежде всего мы выполняем инициализацию переменной fBooleanValue, записывая в нее значение true:

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

Очень часто переменные типа boolean применяются совместно с условными операторами. В нашем примере мы проверяем значение переменной fBooleanValue, и если оно равно true, выполняем с этой переменной некоторые действия:

Прежде всего, мы записываем в переменную fBooleanValue значение false:

Затем мы отображаем новое значение этой переменной на консоли:

Вот фрагмент текста, который выводится на консоль при работе с переменной типа boolean:

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

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

Работа с переменными типа byte

Переменная типа byte занимает в оперативной памяти один байт. В нашем примере мы создаем переменную этого типа с именем bByteValue, а затем инициализируем ее:

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

Так как максимальное значение переменной типа byte равно 127, то после второго увеличения происходит переполнение:

В результате значение переменной bByteValue становится равным -128.

Работа с переменными типа char

Создавая переменную типа char с именем chCharValue, мы инициализируем ее следующим образом:

Затем наша программа отображает текущее значение переменной на консоли, увеличивает это значение на единицу и отображает вновь:

В первый раз отображается символ *, а во второй — символ +.

Главное, что нужно помнить при работе с переменными типа char, это то что для представления символов в них применяется кодировка Unicode. В этой кодировке каждый символ представляется 16-разрядным значением, в котором помимо кода символа имеется и номер набора символов.

В нашем примере мы присваиваем переменной chCharValue значение, равное 0x0455, а затем отображаем полученный символ на консоли:

Вот что там появится:

Работа с переменными типа short

Когда вы работаете с переменными типа short, не следует забывать, что максимальное значение, которое можно в них записать, равно 32767.

В нашем примере мы инициализируем переменную типа short с именем shShortValue максимально допустимым значением, а затем увеличиваем на 2:

В результате происходит переполнение и значение переменной становится равным -32767.

Далее мы преобразуем значение, хранящееся в переменной chCharValue типа char к переменной типа short и выодим результат на консоль:

Вот что мы увидим на консоли:

Число 1109 есть ни что иное, как десятичное значение числа 0x0455, записанное нами в переменную chCharValue на одном из предыдущих этапов.

Работа с переменными типа int

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

Вначале мы инициализируем переменную iIntValue максимальным значением 2147483647, а потом увеличиваем содержимое переменной на 2:

Ниже представлен результат работы этого фрагмента программы:

Работа с переменными типа long

Аналогичные действия выполняются и над переменной lLongValue типа long:

После увеличения значения переменной lLongValue не единицу происходит переполнение:

Работа с переменными типа float

Наша программа инициализирует переменную типа float с именем flFloatValue значением 0. 526, представленным в следующем виде:

Затем мы отображаем исходное число и делим его на три:

Значение полученной в результате периодической дроби выводится на консоль:

Работа с переменными типа double

В этом фрагменте программы выполняются те же самые действия, что и в предыдущем, однако переменная имеет тип double:

Тип данных double допускает вычисления с удвоенной точностью. Поэтому полученная периодическая дробь будет содержать больше значащих цифр, чем в случае типа float:

Статья проплачена кошками — всемирно известными производителями котят.

Если статья вам понравилась, то можете поддержать проект.

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

Примитивные типы Java не являются объектами. К ним относятся:

  • boolean — булев тип, может иметь значения true или false
  • byte — 8-разрядное целое число
  • short — 16-разрядное целое число
  • int — 32-разрядное целое число
  • long — 64-разрядное целое число
  • char — 16-разрядное беззнаковое целое, представляющее собой символ UTF-16 (буквы и цифры)
  • float — 32-разрядное число в формате IEEE 754 с плавающей точкой
  • double — 64-разрядное число в формате IEEE 754 с плавающей точкой

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

Да что он вообще умеет? Ой, всё.

Простые числовые типы

Оглавление
Базовые типы
Замещающие типы

Без указателей

Массивы
Структурное программи-
рование

Обработка исключений
Возбуждение исключений
Классы обработки исключений
Блок finally
Строки String
Класс Math
Класс Vector
Класс Stack
Словарь на базе Hashtable
Словарь на базе Properties
Цифровые часы
Собственный класс
Наследование классов

Интерфейсы

1.

1. Базовые типы данных

В примере демонстрируется использование базовых типов данных Java.

Немного теории

Согласно описанию Java, в этом языке программирования предусмотрены следующие типы данных:

  • базовые;
  • замещающие

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

Тип Размер, бит Значение по умолчанию Минимальное значение Максимальное значение
byte 8 -128 127
char 16 ‘x0’ 65535
short 16 -32768 32767
int 32 -2147483648 2147483647
long 64
-9223372036854775808
9223372036854775807
float 32 0. 0F -224*10 104 224*10 104
double 64 0.0D -253*10 970 253*10 970
Тип Разрядность MIN MAX
byte 8 бит -128 127
short 16 бит -32768 32767
int 32 бит -2147483648 2147483647
long 64 бит -9223372036854775808 9223372036854775807
float 32 бит -3.4E+38
3.4E+38
double 64 бит -1.7E+308 1.7E+308

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

Java определяет четыре целочисленных типа: byte, short, int, long. Они могут быть положительными и отрицательными (Java не поддерживает только положительные значения без знака, как некоторые языки программирования).

Тип byte

Наименьший по размеру целочисленный тип — byte. Это 8-битовый тип с диапазоном допустимых значений от -128 до 127. Переменные типа byte часто используются при работе с потоком данных из сети или файла, а также при работе с необработанными двоичными данными или в массивах для экономии памяти.

Объявить переменную типа byte можно следующим образом:

В арифметических выражениях с переменными типа short вычисления выполняются как с типом int, т.е. с помощью 32-битовой арифметики, а полученный результат будет 32-битовым. Смотри пример с short.

Строку с числом перевести в данный тип можно через метод parseByte(String):

Класс Byte является оболочкой для данного типа. Без необходимости не используйте в Android класс Byte.

Тип short

Тип short — 16-битовый тип в диапазоне от -32768 до 32767. Используется очень редко.

В арифметических выражениях с переменными типа short вычисления выполняются как с типом int, т.е. с помощью 32-битовой арифметики, а полученный результат будет 32-битовым. Например, такой код не пройдёт.

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

Явно перевести строку с числом в тип short можно через метод parseShort(String):

Класс Short является оболочкой для данного типа. Без необходимости не используйте в Android класс Short.

Тип int

Целые числа, представленные типом int, являются самым распространённым типом в программе, с которым вы будете работать. Поэтому нужно хорошенько изучить его и узнать его достоинства и ограничения. Это 32-битовый тип, имеющий диапазон допустимых значений от -2147483648 до 2147483647 (около двух миллиардов). Этого числа вполне достаточно, чтобы посчитать всех котов на свете. Часто используется в циклах, индексировании массивов, хотя может показаться, что для небольших операций в цикле и массивах проще использовать short или byte. Нужно запомнить, что тип int эффективен в этих случаях из-за особенностей структуры вычислительных процессоров. Просто примите на веру.

Сказка про тип int

Зададим себе вопрос, насколько большим может быть целое число типа int?

Напишем простую программу, где будем умножать переменную саму на себя. Для начала присвоим ей значение 2, а дальше строчка за строчкой будем выводить результат. Результаты будем отдавать коту учёному LogCat. Весь код поместим в обработчик события щелчка на кнопке нашей учебной программы, а первую строчку поместим выше её.

Запустите программу и нажмите кнопку. В нижней части студии откройте панель Android Monitor и в ней вкладку logcat. Настройте его фильтр, чтобы отображались только наши сообщения. В результате мы получим такую картину:

Что за бред, скажете вы. Когда мы умножаем 65536 на себя, то получаем 0 (Только не говорите об этом учительнице по математике). А потом, естественно, программа умножает 0 на 0 и продолжает выводить результаты.

Вы ещё больше удивитесь, если в качестве начального значения возьмёте число 3. На этот раз вы сможете получить даже отрицательные значения.

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

Деление целочисленных чисел

Запомните, что при делении целочисленных чисел остаток отбрасывается. Поэтому следующие примеры вернут один и тот же результат. Бедная учительница, её увезут в психушку.

На ноль делить нельзя, увидите ошибку.

Если нужен узнать остаток от деления, то используйте оператор % (оператор деления по модулю).

Класс Integer является оболочкой для данного типа. Без необходимости не используйте в Android класс Integer. Для сравнения: тип int занимает 4 байт памяти, а Integer — 16 байт.

Также есть специальный класс BigInteger для проведения арифметических действий повышенной точности (финансовые расчёты).

В Java 7 можно использовать знак подчёркивания для удобства. Например, так:

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

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

Как сконвертировать строку или CharSequence в int?

Если у вас тип CharSequence, то его можно сконвертировать сначала в строку при помощи метода toString(), а потом в int.

Метод parseInt() предпочтительнее метода valueOf():

Как сконвертировать число в строку?

Если сложить число и строку, то Java автоматически конвертирует число в строку. Пользуясь этим свойством, программисты часто прибавляют к числу пустую строку. Но лучше использовать метод valueOf():

Добавить ведущие нули

Если мы хотим получить строку из числа, добавим при этом несколько нулей вначале, то поможет метод format(), только учитывайте число цифр в самом числе.

Тип long

Тип long — это 64-битный тип со знаком, используемый в тех случаях, когда используется очень большое значение, которое не способен хранить тип int. Например, чтобы вычислить расстояние, которое прошёл солнечный луч от солнца до зеркала, превратившись в солнечного зайчика, за которым безуспешно охотится котёнок, вам понадобится именно этот тип.

Можно использовать символы l или L для обозначения числа типа long. Рекомендую использовать заглавную букву, чтобы избежать возможной путаницы. Например, напишем пример:

Запустив пример, вы увидите ответ 101. Почему так получилось? А потому что последний символ — это не единица, а символ l. Присмотритесь внимательнее. Если бы мы написали long night = 101L, то не ломали бы голову себе.

Конвертируем строку в данный тип.

Класс Long является оболочкой для данного типа. Без необходимости не используйте в Android класс Long.

Типы с плавающей точкой

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

Слово «плавающая» означает, что десятичная точка может располагаться в любом месте (она «плавает»). Вот коты плавать не особенно любят, поэтому они не float и не double.

Тип float

Тип float определяет значение одинарной точности, которое занимает 32 бит. Переменные данного типа удобны, когда требуется дробная часть без особой точности, например, для денежных сумм.

Рекомендуется добавлять символ F или f для обозначения этого типа, иначе число будет считаться типом double.

Конвертируем из строки.

Класс Float является оболочкой для данного типа. Без необходимости не используйте в Android класс Float.

Также есть специальный класс BigDecimal для проведения арифметических действий повышенной точности (финансовые расчёты).

Тип double

Тип double обеспечивает двойную точность, что видно из его названия (double — двойная). Занимает 64 бит для хранения значений. Многие математические функции возвращают значения типа double. Кстати, современные процессоры оптимизированы под вычисления значений двойной точности, поэтому они предпочтительнее, чем тип float.

Тип double содержит не только числа, но и слова. Сейчас вам докажу. Разделим число типа double на ноль. Ошибки не произойдёт.

Пример вернёт значение Infinity (Бесконечность). Если разделить отрицательное число на ноль, то вернётся -Infinity.

А что произойдёт, если сложить две бесконечности? Если рассуждать логически, то сломается интернет, наступит конец света или можно вызвать Волдеморта. Я долго не решался, но потом набрался храбрости и попробовал.

Вернулось ещё одно слово — NaN. Что это вообще? Может должно вернуться Nyan — ну вы знаете, это странный котик, который летит бесконечно в космосе, оставляя за собой шлейф из радуги.

Умножать две бесконечности я побоялся. И вам не советую.

Класс Double является оболочкой для данного типа. Без необходимости не используйте в Android класс Double.

Конвертация строки в double

Есть несколько вариантов.

Конвертация double в строку

При работе с числами double следует держать ухо востро. Рассмотрим пример конвертации трёх чисел.

Первые два числа нормально преобразовались, а вот третье число преобразовалось в строку в странном виде (на самом деле это научное представление числа). И это может источником проблемы при передаче строки куда-нибудь, например, на сервер. Если сервер не ожидает от вас такой подлости, то будет генерировать ошибки из-за странной записи. Нужно найти другие способы конвертации.

Первый способ — используем String.format().

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

Второй способ — метод Double.toString(). У меня метод превратил число в «непонятную» строку. А у некоторых этот пример возвращал строку в нормальном виде. Не заслуживает доверия.

Третий способ — добавить пустую строку. В Android не помогло, хотя тоже утверждается, что у кого-то выводится в нормальном виде. Врут, наверное.

Четвёртый экзотический способ, которым редко пользуются — DecimalFormat.

Символы (тип char)

Для хранения символов Java использует специальный тип char. Он отличается от типа char в языках C/C++, где представляет собой целочисленный тип с размером 8 бит. В Java для char используется кодировка Unicode и для хранения Unicode-символов используется 16 бит или 2 байта. Диапазон допустимых значений — от 0 до 65536 (отрицательных значений не существует).

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

Не следует путать символ ‘a’ со строкой «a», состоящей из одного символа. На экране монитора они выглядят одинаково, но в программах ведут себя по разному.

Стандартные символы ASCII можно выводить сразу. Если нужно вывести специальный символ из Unicode, то можно воспользоваться шестнадцатеричным представлением кода в escape-последовательности — вы указываете обратную наклонную черту и четыре цифры после u. Например:

Хотя тип char используется для хранения Unicode-символов, его можно использовать как целочисленный тип, используя сложение или вычитание.

В результате получим:

Если вы думаете, что увеличив значение переменной ch2 ещё на одну единицу, получите символ «й», то глубоко заблуждаетесь.

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

Для стандартных символов ASCII:

Для расширенной таблицы символов:

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

В упрощённом виде, если работаем со стандартными символами ASCII (on 0 до 127), то можно получить символ из int ещё проще.

Класс Character

Класс Character является оболочкой вокруг типа char. Чтобы получить значение типа char, содержащее в объекте класса Character, вызовите метод charValue().

С классом Character редко имеют дело в Android, но помните, что класс содержит огромное количество констант и методов. Например, можно определить, является ли символ цифрой или буквой, или написан ли символ в нижнем или в верхнем регистре.

Булевы значения

Тип boolean предназначен для хранения логических значений и может принимать только одно из двух возможных значений: true или false. Данный тип всегда возвращается при использовании операторов сравнения (больше, меньше, равно, больше или равно, меньше или равно, не равно). Также он используется в управляющих операторах if и for.

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

В компьютерной программе нужно чётко определиться — истина или ложь.

В операторах if используется укороченная запись при значении true:

Java сам поймёт, что переменную check нужно сравнить с true.

Класс Boolean

Класс Boolean является оболочкой вокруг значений типа boolean. Чтобы получить значение типа boolean из объекта класса Boolean, используйте метод booleanValue(). Тип boolean использует 4 байт памяти, а Boolean — 16. Вывод понятен?

Ещё один совет, применимый ко всем типам. Допустим, нам нужно объявить 32 переменных типа boolean:

Умножаем 4 байта на 32 переменных и получаем 128 байт занятой памяти. А если объявим массив:

Считаем: 4 + 8 + 8 + 32 * 1 = 52. С учётом выравнивания памяти по 8 байт, получаем не 52, а 56. Всё равно меньше, чем в первом примере.

Конвертируем строку в булево значение.

Конвертируем булево значение в строку.

Приведение типов

Когда мы производим какие-то действия с переменными, то нужно следить за типами. Нельзя умножать котов на футбольные мячи, это противоречит здравому смыслу. Также и с переменными. Если вы присваиваете переменной одного типа значение другого типа, то вспоминайте теорию. Например, вы без проблем можете присвоить значение типа int переменной типа long, так как все числа из диапазона типа int гарантировано помещаются в диапазон чисел long. В этом случае Java выполнит преобразование автоматически, вы даже ничего не заметите.

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

Итак, автоматическое преобразование типов осуществляется, если оба типа совместимы и длина целевого типа больше длины исходного типа. В этом случае происходит преобразование с расширением. Вы всегда можете преобразовать любое число типа byte в число типа int. Такая операция произойдёт без вашего участия автоматически.

Таблица выглядит следующим образом.

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

Типы целых чисел и чисел с плавающей точкой совместимы частично. Например, число 5 вполне может быть числом с плавающей точкой (5.0).

Совсем не совместимы, например, char и boolean.

С автоматическим приведением мы разобрались. Рассмотрим вариант, когда нужно преобразовать число типа int в число типа byte. Преобразование автоматически невозможно, поскольку byte меньше int. Но, например, число 99 вполне можно использовать и как int и как byte. В этом случае используется явное приведение типов, то есть преобразование из одного типа в другой (преобразование с сужением).

Выглядит это следующим образом:

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

Существует ещё вариант приведения с усечением. Это когда число с плавающей точкой приводится к целочисленному типу. В этом случае отбрасывается дробная часть (хвост). Например, число 3.14 будет усечено до числа 3:

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

Например, попробуйте преобразовать число 454.874 в тип byte:

У меня вывелся удивительный результат: b равно -58.

Рассмотрим такой пример. Допустим у нас есть выражение, где промежуточное значение может выходить за пределы допустимого диапазона:

При умножении переменных a * b промежуточный результат вышел за пределы диапазона допустимых значений для типов byte. Java во время вычисления промежуточных результатов автоматически повышает тип каждого операнда до int и ошибки не происходит.

Это удобно, но может поставить в тупик в следующем примере:

С виду всё правильно. Если не слишком больше число типа byte, а итоговый результат тоже не выходит за диапазон допустимых значений. Но Java не позволит вам написать подобный код. Происходит следующее. Во время вычисления выражения тип операндов был автоматически повышен до int, как об этом говорилось выше. При этом тип результата тоже был повышен до int. Получается, что результат вычисления равен типу int, а мы пытаемся его присвоить переменной b, которая у нас объявлена как byte. И это несмотря на то, что итоговый результат может быть типом byte. Как же выйти из этого положения? Следует использовать явное приведение типов:

Мы рассмотрели единичные примеры. Пора обобщить и запомнить несколько правил.

Типы всех значений byte, short, char повышаются до типа int, как это было рассмотрено выше.

Если один операнд имеет тип long, то тип всего выражения повышается до long.

Если один операнд имеет тип float, то тип всего выражения повышается до float.

Если один операнд имеет тип double, то тип всего выражения повышается до double.

В первом промежуточном выражении (f * b) тип переменной b повышается до float и промежуточный результат также становится float. В следующем выражении (i / c) тип у переменной c повышается до int и промежуточный результат также становится типом int. В выражении (d * s) тип переменной s повышается до double и промежуточное выражение также становится double. В результате у нас появились три промежуточные значения типов: float, int, double. При сложении float и int мы получаем float, затем при вычитании с использованием float и double тип повышается до double, который и становится окончательным типом результата выражения.

Содержание

Примитивные типы [ править ]

В Java есть 8 примитивных типов, которые делят на 4 группы, вот они:

  1. Целые числа — byte, short, int, long
  2. Числа с плавающей точкой (иначе вещественные) — float, double
  3. Логический — boolean
  4. Символьный — char

Целочисленные типы [ править ]

Целочисленные типы различаются между собой только диапазонами возможных значений, например, для хранения номера элемента в таблице Менделеева пока хватит переменной типа byte.

Тип Размер (бит) Диапазон
byte 8 бит от -128 до 127
short 16 бит от -32768 до 32767
char 16 бит беззнаковое целое число, представляющее собой символ UTF-16 (буквы и цифры)
int 32 бит от -2147483648 до 2147483647
long 64 бит от -9223372036854775808L до 9223372036854775807L

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

Символы тоже относят к целочисленным типам из-за особенностей представления в памяти и традиций.

Типы с плавающей точкой [ править ]

Тип Размер (бит) Диапазон
float 32 от 1.4e-45f до 3.4e+38f
double 64 от 4.9e-324 до 1.7e+308

Логический тип [ править ]

Тип Размер (бит) Значение
boolean 8 (в массивах), 32 (не в массивах используется int) true (истина) или false (ложь)

Ссылочные [ править ]

Ссылочные типы — это все остальные типы: классы, перечисления и интерфейсы, например, объявленные в стандартной библиотеке Java, а также массивы.

Строки [ править ]

Строки это объекты класса String, они очень распространены, поэтому в некоторых случаях обрабатываются отлично от всех остальных объектов. Строковые литералы записываются в двойных кавычках.

Эта программа выведет:
Hello World
foo == bar ? true
foo равен bar ? true
foo == baz ? false
foo равен baz ? true

Обертки [ править ]

Если требуется создать ссылку на один из примитивных типов данных, необходимо использовать соответствующий класс-обертку. Также в таких классах есть некоторые полезные методы и константы, например минимальное значение типа int можно узнать использовав константу Integer.MIN_VALUE. Оборачивание примитива в объект называется упаковкой (boxing), а обратный процесс распаковкой (unboxing).

Тип Класс-обертка
byte Byte
short Short
int Integer
long Long
char Character
float Float
double Double
boolean Boolean

Рекомендуется использовать valueOf, он может быть быстрее и использовать меньше памяти потому что применяет кэширование, а конструктор всегда создает новый объект.

Получить примитив из объекта-обертки можно методом Value.

Java.lang.Long Class — CoderLessons.com

Класс java.lang.Long оборачивает значение примитивного типа long в объекте. Объект типа Long содержит одно поле, тип которого long.

Декларация класса

Ниже приводится объявление для класса java.lang.Long

public final class Long
   extends Number
      implements Comparable<Long>

поле

Ниже приведены поля для класса java.lang.Long

  • static long MAX_VALUE – это константа, содержащая максимальное значение, которое может иметь long 2 63 -1.

  • static long MIN_VALUE – это константа, содержащая минимальное значение, которое может иметь long, -2 63 .

  • static int SIZE – это число битов, используемых для представления длинного значения в двоичной форме дополнения до двух.

  • static Class <Long> TYPE – это экземпляр класса, представляющий примитивный тип long.

static long MAX_VALUE – это константа, содержащая максимальное значение, которое может иметь long 2 63 -1.

static long MIN_VALUE – это константа, содержащая минимальное значение, которое может иметь long, -2 63 .

static int SIZE – это число битов, используемых для представления длинного значения в двоичной форме дополнения до двух.

static Class <Long> TYPE – это экземпляр класса, представляющий примитивный тип long.

Конструкторы классов

Sr.No. Конструктор и описание
1

Long (длинное значение)

Это создает недавно выделенный объект Long, который представляет указанный длинный аргумент.

2

Long (String s)

Это создает вновь распределенный объект Long, представляющий значение long, указанное параметром String.

Long (длинное значение)

Это создает недавно выделенный объект Long, который представляет указанный длинный аргумент.

Long (String s)

Это создает вновь распределенный объект Long, представляющий значение long, указанное параметром String.

Методы класса

Sr.No. Метод и описание
1 static int bitCount (long i)

Этот метод возвращает число однобитовых двоичных данных в двоичном представлении указанного длинного значения.

2 byte byteValue ()

Этот метод возвращает значение этого Long в байтах.

3 int CompareTo (длинный другой длинный)

Этот метод сравнивает два объекта Long численно.

4 статическое длинное декодирование (String nm)

Этот метод декодирует String в Long.

5 double doubleValue ()

Этот метод возвращает значение этого Long как double.

6 логическое равенство (Object obj)

Этот метод сравнивает этот объект с указанным объектом.

7 float floatValue ()

Этот метод возвращает значение этого Long как float.

8 статический длинный getLong (String nm)

Этот метод определяет длинное значение системного свойства с указанным именем.

9 статический Long getLong (String nm, long val)

Этот метод определяет длинное значение системного свойства с указанным именем.

10 статический Long getLong (String nm, Long val)

Этот метод возвращает длинное значение системного свойства с указанным именем.

11 int hashCode ()

Этот метод возвращает хеш-код для этого Long.

12 статическое длинное самое высокоеOneBit (длинное я)

Этот метод возвращает длинное значение, содержащее не более одного бита, в позиции одного бита высшего порядка («крайнего левого») в указанном длинном значении.

13 int intValue ()

Этот метод возвращает значение этого Long как int.

14 long longValue ()

Этот метод возвращает значение этого Long как длинное значение.

15 статический длинный lowOneBit (long i)

Этот метод возвращает длинное значение, содержащее не более одного бита, в позиции младшего бита («самого правого») в указанном длинном значении.

16 static int numberOfLeadingZeros (long i)

Этот метод возвращает число нулевых битов, предшествующих одному биту высшего порядка («крайнего левого») в двоичном представлении дополнения до двух указанных длинных значений.

17 static int numberOfTrailingZeros (long i)

Этот метод возвращает число нулевых битов, следующих за одним битом самого низкого порядка («крайнего правого») в двоичном представлении дополнения двух указанных длинных значений.

18 static long parseLong (String s)

Этот метод анализирует строковый аргумент как длинный десятичный знак со знаком.

19 static long parseLong (String s, int radix)

Этот метод анализирует строковый аргумент как длинную со знаком в основании, указанном вторым аргументом.

20 статический длинный реверс (длинный я)

Этот метод возвращает значение, полученное путем изменения порядка битов в двоичном представлении двоичного дополнения указанного длинного значения.

21 static long reverseBytes (long i)

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

22 static long rotateLeft (long i, int distance)

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

23 static long rotateRight (long i, int distance)

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

24 short shortValue ()

Этот метод возвращает значение этого Long как short.

25 static int signum (long i)

Этот метод возвращает функцию signum указанного длинного значения.

26 статическая строка toBinaryString (long i)

Этот метод возвращает строковое представление длинного аргумента в виде целого числа без знака в базе 2.

27 статическая строка toHexString (долго я)

Этот метод возвращает строковое представление длинного аргумента в виде целого числа без знака в базе 16.

28 статическая строка toOctalString (long i)

Этот метод возвращает строковое представление длинного аргумента в виде целого числа без знака в базе 8.

29 Строка toString ()

Этот метод возвращает объект String, представляющий значение этого Long.

30 статическая строка toString (long i)

Этот метод возвращает объект String, представляющий указанный long.

31 static String toString (long i, int radix)

Этот метод возвращает строковое представление первого аргумента в основании, заданном вторым аргументом.

32 static Long valueOf (long l)

Этот метод возвращает экземпляр Long, представляющий указанное значение long.

33 static Long valueOf (String s)

Этот метод возвращает объект Long, содержащий значение указанной строки.

34 static Long valueOf (String s, int radix)

Этот метод возвращает объект Long, содержащий значение, извлеченное из указанной строки при анализе с основанием, заданным вторым аргументом.

Этот метод возвращает число однобитовых двоичных данных в двоичном представлении указанного длинного значения.

Этот метод возвращает значение этого Long в байтах.

Этот метод сравнивает два объекта Long численно.

Этот метод декодирует String в Long.

Этот метод возвращает значение этого Long как double.

Этот метод сравнивает этот объект с указанным объектом.

Этот метод возвращает значение этого Long как float.

Этот метод определяет длинное значение системного свойства с указанным именем.

Этот метод определяет длинное значение системного свойства с указанным именем.

Этот метод возвращает длинное значение системного свойства с указанным именем.

Этот метод возвращает хеш-код для этого Long.

Этот метод возвращает длинное значение, содержащее не более одного бита, в позиции одного бита высшего порядка («крайнего левого») в указанном длинном значении.

Этот метод возвращает значение этого Long как int.

Этот метод возвращает значение этого Long как длинное значение.

Этот метод возвращает длинное значение, содержащее не более одного бита, в позиции младшего бита («самого правого») в указанном длинном значении.

Этот метод возвращает число нулевых битов, предшествующих одному биту высшего порядка («крайнего левого») в двоичном представлении дополнения до двух указанных длинных значений.

Этот метод возвращает число нулевых битов, следующих за одним битом самого низкого порядка («крайнего правого») в двоичном представлении дополнения двух указанных длинных значений.

Этот метод анализирует строковый аргумент как длинный десятичный знак со знаком.

Этот метод анализирует строковый аргумент как длинную со знаком в основании, указанном вторым аргументом.

Этот метод возвращает значение, полученное путем изменения порядка битов в двоичном представлении двоичного дополнения указанного длинного значения.

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

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

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

Этот метод возвращает значение этого Long как short.

Этот метод возвращает функцию signum указанного длинного значения.

Этот метод возвращает строковое представление длинного аргумента в виде целого числа без знака в базе 2.

Этот метод возвращает строковое представление длинного аргумента в виде целого числа без знака в базе 16.

Этот метод возвращает строковое представление длинного аргумента в виде целого числа без знака в базе 8.

Этот метод возвращает объект String, представляющий значение этого Long.

Этот метод возвращает объект String, представляющий указанный long.

Этот метод возвращает строковое представление первого аргумента в основании, заданном вторым аргументом.

Этот метод возвращает экземпляр Long, представляющий указанное значение long.

Этот метод возвращает объект Long, содержащий значение указанной строки.

Этот метод возвращает объект Long, содержащий значение, извлеченное из указанной строки при анализе с основанием, заданным вторым аргументом.

Методы унаследованы

Этот класс наследует методы от следующих классов –

Переменные в Java • Vertex Academy

Vertex Academy boolean,byte,char,double,float,integer,long,переменные java,создание переменных,типы переменных Java

Данная статья:

  • написана командой Vertex Academy. Надеемся, что она Вам будет полезна. Приятного прочтения!
  • это одна из статей из нашего «Самоучителя по Java»

Что такое переменная в Java?

Часто Вы можете услышать такое определение переменной:

  • Переменная — это некоторый контейнер,  в котором может храниться значение для дальнейшего использования в программе.

Помните, как в школе было:  y = x + 1

И в зависимости от того, какие значения принимает переменная x, меняется значение переменной y.

Если x = 1, тогда x+ 1 =2

Если x = 2, тогда x +1 = 3

Если х = 1.5 , тогда x + 1 =2.5

В Java переменные играют такую же роль, как и в приведенном примере со школы y =  x + 1. Они выполняют роль контейнера для разных значений, которые можно подставить в переменную. В приведённом примере — в переменную x.

Типы переменных в Java. Объявление переменной

В Java можно указать, какие именно значения может принимать переменная.

Для этого все переменные сгруппировали в 4 группы:

  1. Целочисленные (к ним относятся byte, short, int, long)
  2. С плавающей точкой (к ним относятся float, double)
  3. Символы (char)
  4. Логические (boolean)

Примечание:  Итого 8 типов переменных (byte, short, int, long, float, double, char, boolean). Многоуважаемый Брюс Эккель выделяет еще и 9-й тип – так называемый тип void («пустое» значение). Но в этой статье мы рассмотрим 8 типов, как это обычно принято. Что же такое тип void мы разберёмся в теме, посвященной методам в Java.

Теперь давайте рассмотрим каждую группу переменных. И начнём с целочисленных.

Целочисленные: byte, short, int, long

Как видно из таблички, byte, short, int, long относятся к целочисленным, то есть к целым числам. Например, 1, 9, 1278, -5, -107 и т.д.

Очевидно:

  1. byte может принимать значения от -128 до 127 и при этом занимает 1 байт памяти
  2. short принимает значения от -32768 до 32767 и занимает 2 байта памяти
  3. int от -2147483648 до 2147483647 и занимает 4 байта памяти
  4. long от -9223372036854775808 до 9223372036854775807 и занимает 8 байтов памяти

«Ну, хорошо», — скажете Вы. «Если byte, short, int и long отвечают все за целые числа, как мне понять какой именно тип нужно выбирать?» Помните детские задачки по математике, которые сейчас будут как нельзя кстати для объяснения за что отвечают byte, short, int, long.

Задача 1:

У Димы 3 яблока, у Ани 2 яблока. Сколько яблок у Димы и Ани вместе?

Как видите, в задаче речь идет о целых яблоках.  Не предполагается, что яблоки будут делить на части.

Значит, если бы мы писали код в Java, который бы предполагал решение данной задачи, мы бы использовали для переменных целочисленный тип. Остается понять только какой именно мы бы использовали: byte, short, int или long?

Всегда необходимо отталкиваться от контекста.

  1. Если мы знаем точно, что при решении данной задачи, даже если будут меняться значения, например, у Димы 50 яблок, у Ани 30, но в сумме это будет не больше 127 яблок, то можем смело использовать тип byte
  2. Если же мы знаем, что могут поменять условия задачи и у Димы может быть, например, 10 000 яблок, а у Ани, например, 7 000 яблок, то уже тип byte мы использовать не можем. Поскольку это явно выходит за пределы допустимых значений в byte – не более 127.  Значит, могли бы использовать тип short, у которого максимально допустимое значение 32767
  1. Если же предположить, что у Димы и у Ани может быть даже больше, чем 32767 яблок. Ну, например, у них яблоневые сады по всей Украине. Тогда необходимо использовать тип int. Кстати, int – это сокращенно от английского integer (целое число).
  2. Ну, а если предположить, что Дима и Аня – это «яблочные магнаты» и им принадлежат все яблоневые сады в мире, то тогда число может быть намного больше, чем даже максимальное значение int 2147483647. И тогда необходимо использовать тип long.

Однако чаще всего при написании программ на Java, Вы будете использовать тип int. Это самый распространенный целочисленный тип. Более того, тип int в Java является типом «по умолчанию» для целочисленных типов. Что это значит, Вы узнаете на практике.

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

А вот и примеры объявления переменных:

byte apples;

short apples;

int apples;

long apples;

И здесь сразу же хочется сказать о том, что переменные, когда их название состоит из 2 и более слов, пишутся слитно и  как бы «горбиками» как у верблюда. Такой стиль написания слов называется CamelStyle (от англ. camel — «верблюд»).

 

Например:

int applesDima;

int applesAnnaJune;

int applesDimaJuneUkraine;

Видите, названия примеров переменных состоят из 2 и более слов и пишутся слитно. Причем первое слово пишется с маленькой буквы, а во всех последующих словах первая буква большая. Теперь Вы знаете — это CamelStyle, стиль написания названий. Он иногда называется CamelCase. Мы об этом даже статью написали 🙂

Ну что ж, самое время понять за что отвечают переменные с плавающей точкой.


С плавающей точкой: float, double

И снова обратимся к примеру школьной задачи.

Задача 2:

У Димы 3,5 яблока, у Ани 2,5 яблока. Сколько яблок у Димы и Ани вместе?

Как видите, в задаче речь идёт уже не о целых яблоках.  Уже речь идёт о дробных числах. А значит мы уже не можем использовать целочисленный тип: нам не подойдет ни byte, ни short, ни int, ни long. Запомните: как только речь идет о дробных числах, значит, речь идет о float или double. Примеры дробных чисел: 1.0, 1.8, 3.141562, 9.0, 12.579, 1278.0, -5.0, — 9.4, -107.0, -107.356 и т.д.

Как видно из таблички:

  1. float может принимать значения от -3.4Е +38 до 3.4Е +38 и при этом занимает 4 байта памяти
  2. double принимает значения от -1.7E + 308 до 1.7Е + 308 и занимает 8 байт памяти

Запомните:

  • дробные числа пишутся не через запятую, как мы привыкли со школы, а через точку. Например,  1,5 — это неправильно. Правильно 1.5
  • float определяет значение одинарной точности. Это значит, что переменные данного типа удобны, когда требуется дробная часть без особой точности. Например, для денежных сумм.
  • double обеспечивает двойную точность и это видно из названия (double — двойная).

Прежде, чем использовать переменную, её необходимо объявить. А объявляются переменные float и double по такому же принципу.

А вот и примеры объявления переменных:

float money; // объявили переменную money типа float

float wage; // объявили переменную wage типа float

float c; // объявили переменную c типа float

double stat; //объявили переменную stat типа double


 Символы: char

В Java для char используется кодировка Unicode. Как видно из таблички, диапазон допустимых значений char от 0 до 65536 и при этом занимает 2 байта памяти. Отрицательных значений не существует. На самом деле переменная типа char хранит не сам символ, а его числовой код из таблички Unicode, по этому мы можем проводить целочисленные операции над символами.

Прежде, чем использовать переменную, её необходимо объявить. А объявляются переменные char по такому же принципу, что и ранее.

Примеры объявления переменных:

char y; //объявили переменную y типа char

char f; //объявили переменную f типа char


Логические: boolean

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

Только у славян возможен такой разговор:

— Кушать будешь?

— Да нет, наверное.

Это то, что очень удивляет иностранцев, когда они учат, например, украинский или русский язык. Так все-таки да или все-таки нет?

Так вот в языке программирования Java всё очень точно:

  • либо true (с английского — «истина»)
  • либо false (с английского — «ложь)

Чуть позже Вы поймете где применяется данный тип переменных, когда мы, например, дойдём до темы конструкции ветвления. А пока просто запомните, что есть такой тип. Пусть это будет пока «черной лошадкой» для Вас.

Прежде, чем использовать переменную, её необходимо объявить. А объявляются переменные boolean по такому же принципу, что и ранее.

Примеры объявления переменных:

boolean check1; //объявили переменную check1 типа boolean

boolean check2; //объявили переменную check2 типа boolean


 

Ну вот, теперь Вы знаете за что отвечают эти типы переменных:

Что ещё Вы должны знать?

1. Вы должны знать, что эти типы переменных относятся к так называемым примитивным типам переменных. Поэтому если услышите «примитивные типы данных» , «примитивы» или «primitives», знайте, речь идёт о 8 типах переменных — byte, short, int, long, float, double, char, boolean.

2. Есть еще один тип переменных — тип String. О нём мы поговорим в статье «Как присвоить значение переменной»

3. В Java очень важно правильно оформлять код. Да-да, не только писать работающие программы, но  ещё и правильно оформленные. Существует целый свод правил, который называется Code Conventions в Java. Так что можете смело скачивать и постепенно изучать. А сейчас мы рассмотрим только часть Code Conventions, а именно правила написания названий переменных. Итак, запоминаем.

5 правил выбора названий для переменных:

Правило №1 —  переменные пишутся только латинскими буквами. Никакой кириллицы!!!

Например:

int st;

int width;


Правило №2 – имя переменной, по возможности, должно быть «говорящим»

Например:

int s; // так можно называть переменную, но когда кода много и все переменные имеют не говорящие названия, код очень тяжело читать

int size; // этот вариант более «говорящий», чем первый вариант int s; поскольку понятно из названия, что переменная отвечает за размер чего-то


Правило №3 —  с чего может/не может начинаться имя переменной

 Может начинаться с :

  1. Любых латинских букв
  2. $ или _

Не может начинаться с:

  1. Цифр

Ниже приводим несколько примеров — правильных и неправильных.

Правильно:

  • int square;
  • int $money;
  • int width;
  • int boxSize;
  • double sum;
  • double sumJune;

Неправильно:

  • int 2square;
  • int 101dalmatians;

Правило №4 – название переменной, состоящее из 2 и более слов, пишется в CamelStyle

Что такое CamelStyle мы с Вами уже обсудили в этой статьей чуть выше.


Правило №5 – нельзя использовать в названиях переменных эти 54 слова:

abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, strictfp, String, super, switch, synchronized, this, throw, throws, transient, true, try, void, volatile, while

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

abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, strictfp, String, super, switch, synchronized, this, throw, throws, transient, true, try, void, volatile, while


ПОДЫТОЖИМ:

Всего 4 группы переменных:

  1. Целочисленные (к ним относятся byte, short, int, long)
  2. С плавающей точкой (к ним относятся float, double)
  3. Символы (char)
  4. Логические (boolean)

Эти 8 типов переменных (byte, short, int, long, float, double, char, boolean) относятся к там называемым примитивным типам переменных.

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

5 правил выбора названий переменных:

  1. Переменные пишутся только латинскими буквами. Никакой кириллицы!!!
  2. Имя переменной, по возможности, должно быть «говорящим»
  3. Если переменная состоит из 2 и более слов, пишется в CamelStyle (другое название — CamelCase)
  4. Есть 54 слова, которые нельзя использовать в названиях переменных
  5. Имя переменной:
  • может начинаться с любых латинских букв, $ или _
  • не может начинаться с цифр

Также есть еще один тип переменных — тип String, о котором мы поговорим в статье «Как присвоить значение переменной в Java»


Надеемся, что наша статья была Вам полезна. Также есть возможность записаться на наши курсы по Java в Киеве. Обучаем с нуля.

По всем вопросам звоните:

+38 050 205 77 99

+38 098 205 77 99

Или читайте информацию по нашим курсам Java c нуля у нас на сайте.


Документация JDK 19 — Главная

  1. Главная
  2. Ява
  3. Java SE
  4. 19

Обзор

  • Прочтите меня
  • Примечания к выпуску
  • Что нового
  • Руководство по миграции
  • Загрузить JDK
  • Руководство по установке
  • Формат строки версии

Инструменты

  • Технические характеристики инструментов JDK
  • Руководство пользователя JShell
  • Руководство по JavaDoc
  • Руководство пользователя средства упаковки

Язык и библиотеки

  • Обновления языка
  • Основные библиотеки
  • HTTP-клиент JDK
  • Учебники по Java
  • Модульный JDK
  • Руководство программиста API бортового регистратора
  • Руководство по интернационализации

Технические характеристики

  • Документация API
  • Язык и ВМ
  • Имена стандартных алгоритмов безопасности Java
  • банок
  • Собственный интерфейс Java (JNI)
  • Инструментальный интерфейс JVM (JVM TI)
  • Сериализация
  • Проводной протокол отладки Java (JDWP)
  • Спецификация комментариев к документации для стандартного доклета
  • Прочие характеристики

Безопасность

  • Руководство по безопасному кодированию
  • Руководство по безопасности

Виртуальная машина HotSpot

  • Руководство по виртуальной машине Java
  • Настройка сборки мусора

Управление и устранение неполадок

  • Руководство по устранению неполадок
  • Руководство по мониторингу и управлению
  • Руководство по JMX

Client Technologies

  • Руководство по специальным возможностям Java

Long — язык программирования Kotlin

Common

JVM

JS

Native

1. 0

For Common, JVM, JS

Представляет 64-битное целое число со знаком. В JVM необнуляемые значения этого типа представлены как значения примитивного типа long .

Для собственного

Представляет 64-битное целое число со знаком.

Функции

Общий

JVM

JS

Собственный

1.0

и

Выполняет операцию побитового И между двумя значениями.

infix fun and(other: Long): Long

Common

JVM

JS

Native

1.0

Сравните указанные значения заказов с
Возвращает ноль, если это значение равно указанному другому значению, отрицательное число, если оно меньше другого, или положительное число, если оно больше другого.

operator fun compareTo(other: Byte): Int

operator fun compareTo(other: Short): Int

operator fun compareTo(other: Int): Int

4

operator fun : Long): Int

operator fun compareTo(other: Float): Int

operator fun compareTo(other: Double): Int

Common

JVM

JS

Native

1. 0

dec

Возвращает это значение, уменьшенное на единицу.

Оператор Fun Dec (): Long

Common

JVM

JS

Native

1,0

DIV

Дивирует это значение, что является и другим, что это за то, что это будет, на то, что это за то, что это будет по другому, то, что это за то, что это будет. .

operator fun div(other: Byte): Long

operator fun div(other: Short): Long

operator fun div(other: Int): Long

оператор fun div(other: Long): Long

Делит это значение на другое значение.

Оператор Fun Div (Другой: Float): Float

Оператор Fun Div (Другой: Double): Double

Equals

Native

1,3

8 FANIEN

1,3

FUN EATHEN: Длина.

Common

JVM

JS

Native

1.0

Указывает, является ли какой-либо другой объект «равным» этому объекту. Реализации должны выполнять следующие требования:

fun equals(other: Any?): Boolean

Native

1.3

hashCode

Возвращает значение хэш-кода для объекта. Генеральный контракт Hashcode IS:

FUN HASHCODE (): INT

Common

JVM

JS

NATIN

10119

8 INC.

оператор fun inc(): Long

Common

JVM

JS

Собственный

1.0

inv

Инвертирует биты в этом значении.

fun inv(): Long

Common

JVM

JS

Native

1.0

вычесть из этого значения

.

operator fun minus(other: Byte): Long

operator fun minus(other: Short): Long

operator fun minus(other: Int): Long

Оператор Веселый Минус (Другой: Лонг): Лонг

Оператор Веселый Минус (Другой: FLOAT): FLOAT

Оператор Веселый Минус (ДРУГОЙ: Двойной): Double

18.

JS

Собственный

1.0

или

Выполняет операцию побитового ИЛИ между двумя значениями.

инфикс fun or(other: Long): Long

Common

JVM

JS

Собственный

1,0

плюс

Добавляет другое значение к этому значению.

operator fun plus(other: Byte): Long

operator fun plus(other: Short): Long

operator fun plus(other: Int): Long

operator fun plus(other: Int): : Long): Long

operator fun plus(other: Float): Float

operator fun plus(other: Double): Double

Common

JVM

JS

Собственный

1.0

rangeTo

Создает диапазон от этого значения до указанного другого значения.

operator fun rangeTo(other: Byte): LongRange

operator fun rangeTo(other: Short): LongRange

operator fun rangeTo(other: Int): LongRange

4 operator fun : Long): LongRange

Common

JVM

JS

Собственный

1.1

rem

Вычисляет остаток от деления этого значения на другое значение.

operator fun rem(other: Byte): Long

operator fun rem(other: Short): Long

operator fun rem(other: Int): Long

: Long): Long

operator fun rem(other: Float): Float

operator fun rem(other: Double): Double

Общий

JVM

JS

Собственный

1. 0

shl

Сдвигает это значение влево на число битов, равное bitCount.

Infix Fun Shl (BitCount: Int): Long

Common

JVM

JS

Native

1,0

SHR

SHIFTS Это значение BITS -BITS. копии знакового бита.

инфикс fun shr(bitCount: Int): Long

Общий

JVM

JS

Собственный

1,0

умножить на

Умножает это значение на другое значение.

развлечение оператора (другое: байт): длинное

время развлечения оператора (другое: короткое): длинное

время развлечения оператора (другое: Int): длинное

время развлечения оператора : Long): Long

развлечение оператора (другое: Float): Float

время развлечения оператора (другое: Double): Double

Common

JVM

JS

Native

1. 0

toByte Convert this Long
.901

fun toByte(): Byte

Common

JVM

JS

Native

1.0

toChar
9 Преобразует это значение в Char 9.

забава toChar (): Char

Общий

JVM

JS

Собственный

1.0

toDouble

Преобразует это значение Long в Double.

fun toDouble(): Double

Common

JVM

JS

Native

1.0

toFloat
1.0

toFloat

fun toFloat(): Float

Common

JVM

JS

Native

1.0

toInt

Преобразует это значение Long в Int.

fun toInt(): Int

Common

JVM

JS

Native

1. 0

toLong
90.

fun toLong(): Long

Common

JVM

JS

Native

1.0

toShort Преобразуйте это значение Long
s 901.

весело toShort(): Short

Common

JVM

JS

Собственный

1.0

toString

Возвращает строковое представление объекта.

fun toString(): String

Common

JVM

JS

Native

1.0

unaryMinus
9.

оператор fun unaryMinus(): Long

Common

JVM

JS

Native

1.0

unaryPlus

Возвращает это значение.

Оператор Fun Unaryplus (): Long

Common

JVM

JS

Native

1,0

USHR

.

infix fun ushr(bitCount: Int): Long

Common

JVM

JS

Native

1.0

xor

Выполняет побитовую операцию XOR между двумя значениями.

инфикс fun xor(другое: Long): Long

Свойства объекта-компаньона

Common

JVM

JS

Native

1.0

MAX_VALUE

Константа, содержащая максимальное значение, которое может иметь экземпляр Long.

const val MAX_VALUE: Long

Common

JVM

JS

Native

1.0

MIN_VALUE

Константа, содержащая минимальное значение, которое может иметь экземпляр Long.

const val val min_value: long

Общий

JVM

JS

Натив

1,3

Size_Bits

. Номер из BITS, используемых в BITS, используемый в течение длиной.

const val SIZE_BITS: Int

Common

JVM

JS

Native

1.3

SIZE_BYTES

Количество байтов, используемых для представления экземпляра Long в двоичной форме.

константное значение SIZE_BYTES: целое

Свойства расширения

Common

JVM

JS

Native

1.3

days

Возвращает Duration, равную этому длинному количеству дней.

Общий

JVM

JS

Собственный

1.3

часов

Возвращает Duration, равную этому длинному количеству часов. 1.3 1.3

Общий

JVM

JS

Собственный

1.3

минут

Возвращает длительность, равную этому длинному количеству минут. 1.3

Общий

JVM

JS

Собственный

1.3

секунд

Возвращает длительность, равную этому длинному количеству секунд.

Дополнительные функции

Общий

JVM

JS

Собственный

1.0

coerceAtLeast

Гарантирует, что это значение не меньше указанного минимального значения.

fun Long.coerceAtLeast(minimumValue: Long): Long

fun > T.coerceAtLeast(minimumValue: T): T

Common

JVM

JS

Native

1.0

принудить к максимуму

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

fun Long.coerceAtMost(maximumValue: Long): Long

fun > T.coerceAtMost(maximumValue: T): T

Common

JVM

JS

Native

1.0

coerceIn

Гарантирует, что это значение находится в указанном диапазоне минимального значения. . максимальное значение.

забава Long.coerceIn(
Минимальная обстановка: Long,
Maximumvalue: Long
): Long

FUN > T.Coercein (
Минимальная обстановка: T?,
MaximumValue: T?
): T

Оборудование, что T?
): T

, что T?
): T

. это значение находится в указанном диапазоне.

FUN LONG.COERCEIN (диапазон: закрытый рандр ): Long

Common

JVM

JS

Натив

1,6

Comparteto

1,6

Comparteto

1,6

Сравнение

1,6

. Возвращает ноль, если этот объект равен к указанному другому объекту, отрицательное число, если оно меньше, чем другое, или положительное число если это больше, чем другие.

инфикс fun Comparable. compareTo(other: T): Int

Native

1.3

convert

fun 9

: R

: R Common

JVM

JS

Native

1.0

downTo

Возвращает прогрессию от этого значения вниз до указанного значения с шагом -1.

Общий

JVM

JS

Собственный

1.5

floorDiv

Делит это значение на другое значение, сводя результат к целому числу, близкому к отрицательной бесконечности.

fun Long.floorDiv(other: Byte): Long

fun Long.floorDiv(other: Short): Long

fun Long.floorDiv(other: Int): Long

  • fun .floorDiv(другое: Long): Long

    Common

    JVM

    JS

    Native

    1,5

    mod

    Вычисляет остаток от деления этого значения на другое значение.

    fun Long.mod(другое: Byte): Byte

    fun Long.mod(другое: Short): Short

    fun Long.mod(other: Int): Int

    4 9013 fun .mod(другое: Long): Длинный

    Собственный

    1.3

    узкий

    Общий

    JVM

    JS

    Собственный

    18

    диапазон 18

    0129

    Создает диапазон от этого сопоставимого значения до указанного этого значения.

    Common

    JVM

    JS

    Native

    1.7

    rangeUntil

    Возвращает диапазон от этого значения до, но исключая указанное значение.

    оператор fun Long.rangeUntil(to: Byte): LongRange

    operator fun Long.rangeUntil(to: Int): LongRange

    operator fun Long. rangeUntil(to: Long): LongRange

    оператор fun Long.rangeUntil(to: Short): LongRange

    Создает открытый диапазон от этого сопоставимого значения до указанного этого значения.

    Native

    1.3

    signExtend

    JVM

    1.2

    toBigDecimal

    Возвращает значение этого длинного числа как BigDecimal.

    JVM

    1.2

    toBigInteger

    Возвращает значение этого длинного числа как BigInteger.

    Native

    1,3

    TOCPOINTER

    Общий

    JVM

    JS

    Native

    1,6

    Toduration

    Возврат.

    Common

    JVM

    JS

    Native

    1.5

    toUByte

    Преобразует это длинное значение в UByte.

    fun Long.toUByte(): UByte

    Общий

    JVM

    JS

    Собственный

    1.5

    toUInt

    Преобразует это длинное значение в UInt.

    fun Long.toUInt(): UInt

    Common

    JVM

    JS

    Собственный

    1.5

    toULong
    Преобразовать это значение в ULong
      9

      fun Long.toULong(): ULong

      Common

      JVM

      JS

      Native

      1.5

      toUShort 9012

      Преобразует это значение Long в UShort.

      Fun Long.toushort (): USHORT

      Common

      JVM

      JS

      Native

      1,0

      до

      возвращается по норме на это до

    .

    infix fun Long.until(to: Byte): LongRange

    infix fun Long.until(to: Int): LongRange

    infix fun Long.until(to: Long): LongRange

    infix fun Long. until(to: Short): LongRange

    Примитивные типы данных Java — HowToDoInJava

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

    Примитивные типы данных предопределены языком Java и названы зарезервированным ключевым словом. Давайте посмотрим на каждый примитивный тип данных на изображении ниже.

    Примитивные типы данных в Java

    1. Интегральные типы данных Java

    Целочисленный тип данных — это числовой тип данных, значения которого имеют целочисленный тип .

    Java offers five integral data types :

    • byte
    • short
    • int
    • long
    • char
    1.1.
    int type
    • Тип данных int представляет собой 32-разрядный знаковый примитивный тип данных Java . переменная 9Тип данных 0131 int занимает 32 бита памяти .
    • Допустимый диапазон: от -2 147 483 648 до 2 147 483 647 (от -2 31 до 2 31 – 1).
    • Все целые числа в этом диапазоне известны как целочисленные литералы (или целочисленные константы). Например, 10, -200, 0, 30, 19 и т. д. являются целочисленными литералами типа int.

    Целочисленный литерал может быть назначен переменной int , скажем, counter , например:

    счетчик целых чисел = 21;
     
    1.1.1. Integer Wrapper Class

    Java имеет класс-оболочку с именем Integer , который определяет две константы для представления максимального и минимального значений для типа данных int: Integer.MAX_VALUE и Integer.MIN_VALUE . Это объектное представление значения int.

    int max = целое число.MAX_VALUE; // Присваивает максимальное значение int для max
    int мин = целое число. MIN_VALUE; // Присваивает минимальное значение int для min
     
    1.2.
    long type
    • Длинный тип данных представляет собой 64-битный подписанный примитивный тип данных Java .
    • Используется, когда результат вычислений над целыми числами может выйти за пределы диапазона данных типа int.
    • Его диапазон от -2 63 до 2 63 – 1.
    • Все целые числа в диапазоне long называются целочисленными литералами типа long .

    Целочисленный литерал типа long всегда заканчивается на «L» (или «l» в нижнем регистре).

    длинное число1 = 0L;
    длинное число2 = 401L;
    длинная мама3 = -3556L;
     
    1.2.1. Приведение типов

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

    целое число1 = 5;
    длинное число2 = 25 л;
     
    // Ошибка времени компиляции.  Даже если значение num2 равно 25, которое находится в пределах диапазона int.
    число1 = число2;
     

    Если вы хотите присвоить значение переменной long переменной int , вы должны явно упомянуть этот факт в своем коде , чтобы Java удостоверился, что вы знаете о возможном переполнении данных. Вы делаете это, используя «приведение» в Java, например:

    длинное число1 = (целое) число2; // Теперь все в порядке из-за приведения типа "(int)"
     

    Написав (int)num2 , вы указываете Java обрабатывать значение, хранящееся в num2 , как целое число. Во время выполнения Java будет использовать только 32 младших бита из 9.0131 num2 и присвойте значение, хранящееся в этих 32 битах, num1 . Если num2 имеет значение, выходящее за пределы диапазона данных типа int, вы не получите такое же значение в num1 , и это приведет к потере данных .

    1.2.2. Long Wrapper Class

    Java имеет класс Long (обратите внимание на заглавную букву L в слове Long), который определяет две константы для представления максимального и минимального значений типа данных long, Long.MAX_VALUE и Long.MIN_VALUE .

    длинный максимум = Long.MAX_VALUE;
    длинная мин. = длинная.MIN_VALUE;
     
    1.3.
    byte type
    • Тип данных byte представляет собой 8-битный знаковый тип данных Java 8-битного целого числа со знаком .
    • Диапазон: от -128 до 127 (от -27 до 27 – 1). Это наименьших целочисленных типов данных , доступных в Java.
    • В отличие от литералов int и long , байтовых литералов нет.
    • Однако вы можете присвоить любой литерал int, попадающий в диапазон byte, переменной byte.
    байт b1 = 125;
    байт b2 = -11;
     
    1.
    3.1. Преобразование типов

    Если вы присваиваете литерал int переменной byte , а значение выходит за пределы диапазона типа данных byte, Java генерирует ошибку компилятора. Следующий фрагмент кода вызовет ошибку компилятора:

    .
    // Ошибка. 150 - это литерал int вне диапазона от -128 до 127.
    байт b3 = 150;
     

    Java не позволяет присваивать значение переменной с более высоким типом данных переменной диапазона типа данных с более низким диапазоном, поскольку при выполнении такого присваивания возможна потеря точности. Чтобы сделать такое присваивание от int к byte, вы должны использовать приведение, как вы сделали в случае присваивания long-to-int.

    b1 = (байт) число1; // Ok
     
    1.3.2. Byte Wrapper Class

    Java имеет класс Byte (обратите внимание на заглавную букву B в Byte), который определяет две константы для представления максимального и минимального значений типа данных byte, Байт. MAX_VALUE и Байт.MIN_VALUE .

    Максимальный байт = Байт.MAX_VALUE;
    байт мин. = байт.MIN_VALUE;
     
    1.4.
    short type
  • Тип данных short представляет собой 16-разрядный знаковый тип данных Java типа . Его диапазон составляет от -32768 до 32767 (или от -215 до 215 – 1).
  • В отличие от литералов типа int и long, здесь нет литерала short.
  • Однако вы можете присвоить любой литерал int, попадающий в диапазон short (от -32768 до 32767), переменной short.
  • короткий s1 = 12905; // Ok
    короткий s2 = -11890; // Ok
     

    Значение байтовой переменной всегда можно присвоить короткой переменной, поскольку диапазон типа данных byte находится в пределах диапазона короткого типа данных. Все остальные правила присвоения значения переменной типа int или long переменной типа short такие же, как и для переменной типа byte.

    1.4.1. Short Wrapper Class

    В Java есть класс с именем Short (обратите внимание на S в верхнем регистре в слове Short), который определяет две константы для представления максимальных и минимальных значений типа данных short, Короткий. MAX_VALUE и Короткий.MIN_VALUE .

    короткий максимум = Short.MAX_VALUE;
    короткая мин = короткая.MIN_VALUE;
     
    1.5.
    char тип данных
    • Тип данных char представляет собой 16-битный беззнаковый примитивный тип данных Java.
    • Представляет символ Unicode .
    • Обратите внимание, что char является беззнаковым типом данных. Следовательно, переменная char не может иметь отрицательное значение.
    • Диапазон типа данных char — от 0 до 65535, что совпадает с диапазоном набора Unicode.
    • Символьный литерал представляет значение типа данных char.
    символ с1 = 'А';
    символ с2 = 'L';
    символ с3 = '5';
    символ с4 = '/';
     
    1.5.1. Управляющие последовательности символов

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

    Имеется восемь предопределенных управляющих последовательностей символов as listed below:

    Character Escape Sequence Description
    ‘\n’ A linefeed
    ‘\r’ A carriage return
    ‘\f’ A form feed
    ‘\b’ A backspace
    ‘\t’ A tab
    ‘\\’ A backslash
    ‘\”’ A двойная кавычка
    ‘\’ Одинарная кавычка

    Это всего лишь восьмисимвольные управляющие последовательности в Java. Вы не можете определить escape-последовательности для своего персонажа.

    1.5.2. escape-последовательность Unicode

    Символьный литерал также может быть выражен как escape-последовательность Unicode в форме '\uxxxx' , Здесь \u (обратная косая черта, сразу за которой следует строчная буква u) обозначает начало escape-последовательности Unicode. последовательность, а xxxx представляет ровно четыре шестнадцатеричных цифры.

    символ с1 = 'А';
    символ c2 = '\ u0041'; // То же, что и c2 = 'A'
     

    2. Типы данных Java с плавающей запятой

    Число с плавающей запятой, содержащее дробную часть , известно как действительное число , например, 3,25, 0,49, -9,19 и т. д.

    Как хранятся числа в памяти

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

    1. Формат числа с фиксированной запятой — хранить только двоичное представление числа и предполагать, что всегда есть фиксированное количество цифр до и после точки. Точкой называется десятичная точка в десятичном представлении числа и двоичная точка в двоичном представлении. Тип представления, в котором положение точки всегда фиксировано в числе, известен как числовой формат с фиксированной точкой.
    2. Формат чисел с плавающей запятой — сохранить двоичное представление действительного числа и положение точки в вещественном числе. Поскольку количество цифр до и после точки может варьироваться в таком представлении действительного числа, мы говорим, что точка может плавать. Такой вид представления называется форматом «с плавающей запятой».

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

    Java поддерживает числовой формат с плавающей запятой.

    IEEE-754 32-разрядные числа с плавающей запятой одинарной точности

    Java имеет два числовых типа данных с плавающей запятой: float и double .

    2.1.
    float type

    Тип данных float использует 32 бита для хранения числа с плавающей запятой в стандартном формате IEEE 754 ( число с плавающей запятой одинарной точности ). Он может представлять действительное число размером 1,4 x 10 9 .1396 -45 и размером 3,4 x 10 38 (приблизительно). Диапазон включает только величину. Он может быть положительным или отрицательным.

    Все действительные числа, оканчивающиеся на «f» или «F», называются литералами с плавающей запятой .

    поплавок f1 = 8F;
    поплавок f2 = 8.F;
    поплавок f3 = 8,0F;
     
    2.1.1. Положительная и отрицательная бесконечность

    Тип данных float определяет две бесконечности: положительную бесконечность и отрицательную бесконечность. Например, результат деления 2.5F на 0.0F представляет собой положительную бесконечность с плавающей запятой, тогда как результат деления 2.5F на -0.0F представляет собой отрицательную бесконечность с плавающей запятой.

    2.1.2. NaN (Not-a-Number)

    Результаты некоторых операций над числом с плавающей запятой не определены. Эти результаты представлены специальным значением типа данных float, называемым NaN (Not-a-Number).

    Класс Float определяет три константы, представляющие положительную бесконечность, отрицательную бесконечность и NaN типа данных float. Есть еще две константы, которые представляют максимальное и минимальное (больше нуля) значения с плавающей запятой, которые могут быть сохранены в переменной с плавающей запятой.

    Float.POSITIVE_INFINITY - Положительная бесконечность типа float.
    Float.NEGATIVE_INFINITY - Отрицательная бесконечность типа float.
    Float.NaN - Не число типа float.
    Float.MAX_VALUE — наибольшее положительное значение, которое может быть представлено в переменной с плавающей запятой.
    Float.MIN_VALUE — наименьшее положительное значение больше нуля, которое может быть представлено в переменной с плавающей запятой.
     

    Обратите внимание, что значение всех целочисленных типов (int, long, byte, short и char) может быть присвоено переменной типа данных float без использования явного приведения, НО значение float должно быть приведено до того, как оно будет присваивается переменной любого целочисленного типа данных int, long, byte, short или char.

    2.2.
    double type

    Тип данных double использует 64 бита для хранения числа с плавающей запятой в «стандартном формате IEEE 754». Число с плавающей запятой, представленное в 64 битах в соответствии со стандартом IEEE 754, также известно как число с плавающей запятой двойной точности .

    Все действительные числа называются двойными литералами . Двойной литерал может дополнительно заканчиваться на «d» или «D», например, 19.27d. Однако суффикс d или D необязателен в двойных литералах. То есть оба 19.27 и 19.27d представляют один и тот же двойной литерал.

    двойной d1 = 8D
    двойной д2 = 8.;
    двойной d3 = 8,0;
    двойное д4 = 8.Д;
     

    Как и тип данных float, тип данных double определяет максимальное, минимальное, две бесконечности и значения NaN.

    Double.POSITIVE_INFINITY - Положительная бесконечность типа double.
    Double.NEGATIVE_INFINITY - Отрицательная бесконечность типа double.