Типы byte, short, int, long
Целочисленные числа представлены в языке Java четырьмя типами — byte, short, int и long.
int — основной целочисленный тип, используемый в Java по умолчанию. Любое целое число будет рассматриваться компилятором как число типа int. Используется в качестве счётчика циклов, индексов массивов и индексов символов в строках.
long — целочисленный тип содержащий практически бесконечное количество значений. Используется в случаях, где числа превосходят 2 миллиарда и стандартного int уже не хватает. Используется в повседневной жизни для создания уникальных значений.
byte — используется для передачи данных по сети, записи и чтения из файла. В математических операциях, как правило, не используется.
short — самый редко используемый тип в Java, может использоваться только в целях экономии памяти.
| Тип | Размер в байтах | Размер в битах | Возможные значения (от..до) | Значение по умолчанию |
|---|---|---|---|---|
| byte | 1 | 8 | -128..127 | 0 |
| short | 2 | 16 | -32,768..32,767 | 0 |
| int | 4 | 32 | -2,147,483,648..2,147,483,647 | 0 |
| long | 8 | 64 | -9,223,372,036,854,775,808..9,223,372,036,854,775,807 | 0 |
Пример объявления целочисленных типов:
byte b = 4; short s1 = 7, s2 = 5; int i1 = 56, i2; i2 = 78; long a1 = 456;Презентацию с видео можно скачать на Patreon .
Максимальное количество цифр в типе данных Long в языке Java
В языке программирования Java существует несколько встроенных типов данных, предназначенных для хранения числовых значений. Один из таких типов — long. Long является целочисленным типом данных, который используется для хранения целых чисел в диапазоне от -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807.
Таким образом, long может содержать до 19 цифр, включая знак минуса для отрицательных чисел. Благодаря такому большому диапазону значений, long применяется для хранения данных, требующих большой точности и диапазона, например, для работы с большими числами, датами и временем, а также для итераций в больших циклах.
Для объявления переменной типа long в Java используется ключевое слово long, за которым следует имя переменной. Например, long myVariable;
Примечание: Для ясного понимания дальнейшего материала, рекомендуется быть знакомым с основами языка Java, такими как операторы, условные выражения и циклы.
Сколько цифр может содержать long в Java?
Тип данных long в Java представляет собой 64-битное целое число. Он может содержать 19 цифр.
Ниже приведена таблица, показывающая максимальное и минимальное значение типа long:
| Минимальное значение | Максимальное значение |
|---|---|
| -9,223,372,036,854,775,808 | 9,223,372,036,854,775,807 |
При работе с числами большей длины, рекомендуется использовать тип данных BigInteger из класса java.math. BigInteger позволяет работать с числами любой длины и обеспечивает большую точность.
Длина long в Java
- Тип данных long в Java представляет собой 64-битное знаковое целое число, который может содержать значения от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 включительно.
- Диапазон значений типа данных long ограничен и является в два раза больше по сравнению с типом данных int .
- Целое число типа long занимает 8 байт в памяти компьютера, что позволяет хранить большие числа и обрабатывать большие объемы данных.
- Для объявления переменной типа long необходимо использовать ключевое слово long и присвоить ей значение. Например: long number = 1234567890L; (обратите внимание на суффикс L , который указывает на то, что это значение типа long ).
- Операции над переменными типа long подобны операциям над переменными типа int , только тип переменных отличается.
Пример объявления и использования переменной типа long :
long population = 7764844767L; long GDP = 12000000000000L;
System.out.println("Население: " + population);
System.out.println("ВВП: " + GDP);
Особенности типа данных long
Тип данных long в языке программирования Java является целочисленным и занимает 8 байт, то есть 64 бита. Этот тип данных используется для хранения целочисленных значений в диапазоне от -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807.
Особенности типа данных long:
- Диапазон значений: Тип данных long может хранить целочисленные значения в очень широком диапазоне, позволяя работать с очень большими числами как положительными, так и отрицательными.
- Расход памяти: Поскольку long занимает 8 байт, он требует больше памяти по сравнению с другими целочисленными типами данных, такими как int или short.
- Указание значения: Для указания значения типа данных long можно использовать суффикс «L» или «l». Например, для указания числа 10 можно использовать запись long num = 10L;
- Арифметические операции: Тип данных long поддерживает все арифметические операции, такие как сложение, вычитание, умножение и деление. Результатом таких операций всегда будет значение типа long.
Важно помнить, что использование типа данных long может быть нецелесообразным, если вы работаете с числами, которые не требуют такого большого диапазона значений. В таких случаях можно использовать более компактные целочисленные типы данных, такие как int или short, чтобы экономить память.
| Тип данных | Размер (в байтах) | Диапазон значений |
|---|---|---|
| byte | 1 | -128 до 127 |
| short | 2 | -32,768 до 32,767 |
| int | 4 | -2,147,483,648 до 2,147,483,647 |
| long | 8 | -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807 |
Вопрос-ответ
Чем отличается тип данных long от типа данных int в Java?
Тип данных long в Java является целочисленным типом данных, который может хранить целые числа большего диапазона, чем int. В то время как тип int может хранить значения от -2147483648 до 2147483647, тип long может хранить значения от -9223372036854775808 до 9223372036854775807. Таким образом, long имеет более широкий диапазон значений, чем int.
Какой диапазон значений может содержать переменная типа long в Java?
Переменная типа long в Java может содержать значения от -9223372036854775808 до 9223372036854775807. Это означает, что long может хранить целочисленные значения, которые являются значительно больше, чем те, которые может хранить переменная типа int. Диапазон long составляет примерно от -9,2 квинтиллиона до 9,2 квинтиллиона.
Сколько цифр может содержать целое число типа long в Java?
Целое число типа long в Java может содержать до 19 цифр. Диапазон значений для переменной типа long простирается от -9223372036854775808 до 9223372036854775807. Это означает, что вы можете использовать long для представления довольно больших чисел.
Что произойдет, если присвоить целочисленное значение, которое выходит за пределы диапазона типа данных long?
Если вы присваиваете значение, которое выходит за пределы диапазона типа данных long (от -9223372036854775808 до 9223372036854775807), будет произведено переполнение или недостаток. Например, если попытаться присвоить значение больше 9223372036854775807, оно переполнит и станет отрицательным числом. Аналогично, если попытаться присвоить значение меньше -9223372036854775808, оно будет недостаточным и также станет отрицательным числом.
Java/Типы данных
В Java есть 8 примитивных типов, которые делят на 4 группы, вот они:
- Целые числа — byte, short, int, long
- Числа с плавающей точкой (иначе вещественные) — float, double
- Логический — boolean
- Символьный — char
Целочисленные типы [ править ]
Целочисленные типы различаются между собой только диапазонами возможных значений, например, для хранения номера элемента в таблице Менделеева пока хватит переменной типа byte.
| Тип | Размер (бит) | Диапазон |
|---|---|---|
| byte | 8 бит | от -128 до 127 |
| short | 16 бит | от -32768 до 32767 |
| char | 16 бит | беззнаковое целое число, представляющее собой символ UTF-16 (буквы и цифры) |
| int | 32 бит | от -2147483648 до 2147483647 |
| long | 64 бит | от -9223372036854775808L до 9223372036854775807L |
Пример использования целочисленных типов:
public class IntegralTypes public static void main(String[] args) byte b = 216; // Вот тут будет ошибка, т.к. у нас диапазон от -128 до 127! short s = 1123; int i = 64536; long l = 2147483648L; // Постфикс l или L обозначает литералы типа long System.out.println(i); System.out.println(b); System.out.println(s); System.out.println(l); > >
Символы тоже относят к целочисленным типам из-за особенностей представления в памяти и традиций.
public class Characters public static void main(String[] args) char a = 'a', b, c = 'c'; b = (char) ((a + c) / 2); // Можно складывать, вычитать, делить и умножать // Но из-за особенностей арифметики Java результат приходится приводить к типу char явно System.out.println(b); // Выведет символ 'b' > >
Типы с плавающей точкой [ править ]
| Тип | Размер (бит) | Диапазон |
|---|---|---|
| float | 32 | от 1.4e-45f до 3.4e+38f |
| double | 64 | от 4.9e-324 до 1.7e+308 |
public class FloatingPointTypes public static void main(String[] args) double a, b = 4.12; a = 22.1 + b; float pi = 3.14f; // При использовании типа float требуется указывать суффикс f или F // так как без них типом литерала будет считаться double float anotherPi = (float) 3.14; // Можно привести явно double c = 27; double d = pi * c; System.out.println(d); > >
Логический тип [ править ]
| Тип | Размер (бит) | Значение |
|---|---|---|
| boolean | 8 (в массивах), 32 (не в массивах используется int) | true (истина) или false (ложь) |
В стандартной реализации Sun JVM и Oracle HotSpot JVM тип boolean занимает 4 байта (32 бита), как и тип int. Однако, в определенных версиях JVM имеются реализации, где в массиве boolean каждое значение занимает по 1-му байту.
Ссылочные [ править ]
Ссылочные типы — это все остальные типы: классы, перечисления и интерфейсы, например, объявленные в стандартной библиотеке Java, а также массивы.
Строки [ править ]
Строки это объекты класса String, они очень распространены, поэтому в некоторых случаях обрабатываются отлично от всех остальных объектов. Строковые литералы записываются в двойных кавычках.
public class Strings public static void main(String[] args) String a = "Hello", b = "World"; System.out.println(a + " " + b); // Здесь + означает объединение (конкатенацию) строк // Пробел не вставляется автоматически // Строки конкатенируются слева направо, надо помнить это когда соединяешь строку и примитив String c = 2 + 2 + ""; // "4" String d = "" + 2 + 2; // "22" d = "" + (2 + 2); // а теперь d тоже "4" String foo = "a string"; String bar = "a string"; // bar будет указывать на тот же объект что и foo String baz = new String("a string"); // Чтобы гарантированно создать новую строку надо вызвать конструктор System.out.println("foo == bar ? " + (foo == bar)); // == сравнивает ссылки на объекты System.out.println("foo равен bar ? " + (foo.equals(bar))); // Метод equals служит для проверки двух объектов на равенство System.out.println("foo == baz ? " + (foo == baz)); System.out.println("foo равен baz ? " + (foo.equals(baz))); > >
Эта программа выведет:
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 |
int i; Integer boxed; // Обычное создание объекта boxed = new Integer(i); // Фабричный метод boxed = Integer.valueOf(i); // Автоматическая упаковка, компилятор просто вставит вызов Integer.valueOf boxed = i;
Рекомендуется использовать valueOf, он может быть быстрее и использовать меньше памяти потому что применяет кэширование, а конструктор всегда создает новый объект.
Получить примитив из объекта-обертки можно методом Value.
Integer boxed; int i; // Явная распаковка i = boxed.intValue(); // Автоматическая распаковка i = boxed;
Long java сколько цифр
Одной из основных особенностей Java является то, что данный язык является строго типизированным. А это значит, что каждая переменная и константа представляет определенный тип и данный тип строго определен. Тип данных определяет диапазон значений, которые может хранить переменная или константа.
Итак, рассмотрим систему встроенных базовых типов данных, которая используется для создания переменных в Java. А она представлена следующими типами.
-
boolean : хранит значение true или false
boolean isActive = false; boolean isAlive = true;
byte a = 3; byte b = 8;
short a = 3; short b = 8;
int a = 4; int b = 9;
long a = 5; long b = 10;
double x = 8.5; double y = 2.7;
float x = 8.5F; float y = 2.7F;
При этом переменная может принимать только те значения, которые соответствуют ее типу. Если переменная представляет целочисленный тип, то она не может хранить дробные числа.
Целые числа
Все целочисленные литералы, например, числа 10, 4, -5, воспринимаются как значения типа int , однако мы можем присваивать целочисленные литералы другим целочисленным типам: byte , long , short . В этом случае Java автоматически осуществляет соответствующие преобразования:
byte a = 1; short b = 2; long c = 2121;
Однако если мы захотим присвоить переменной типа long очень большое число, которое выходит за пределы допустимых значений для типа int, то мы столкнемся с ошибкой во время компиляции:
long num = 2147483649;
Здесь число 2147483649 является допустимым для типа long, но выходит за предельные значения для типа int. И так как все целочисленные значения по умолчанию расцениваются как значения типа int, то компилятор укажет нам на ошибку. Чтобы решить проблему, надо добавить к числу суффикс l или L , который указывает, что число представляет тип long:
long num = 2147483649L;
Как правило, значения для целочисленных переменных задаются в десятичной системе счисления, однако мы можем применять и другие системы счисления. Например:
int num111 = 0x6F; // 16-теричная система, число 111 int num8 = 010; // 8-ричная система, число 8 int num13 = 0b1101; // 2-ичная система, число 13
Для задания шестнадцатеричного значения после символов 0x указывается число в шестнадцатеричном формате. Таким же образом восьмеричное значение указывается после символа 0 , а двоичное значение — после символов 0b .
Также целые числа поддерживают разделение разрядов числа с помощью знака подчеркивания:
int x = 123_456; int y = 234_567__789; System.out.println(x); // 123456 System.out.println(y); // 234567789
Числа с плавающей точкой
При присвоении переменной типа float дробного литерала с плавающей точкой, например, 3.1, 4.5 и т.д., Java автоматически рассматривает этот литерал как значение типа double . И чтобы указать, что данное значение должно рассматриваться как float , нам надо использовать суффикс f:
float fl = 30.6f; double db = 30.6;
И хотя в данном случае обе переменных имеют практически одно значения, но эти значения будут по-разному рассматриваться и будут занимать разное место в памяти.
Символы и строки
В качестве значения переменная символьного типа получает одиночный символ, заключенный в одинарные кавычки: char ch=’e’; . Кроме того, переменной символьного типа также можно присвоить целочисленное значение от 0 до 65535 . В этом случае переменная опять же будет хранить символ, а целочисленное значение будет указывать на номер символа в таблице символов Unicode (UTF-16). Например:
char ch=102; // символ 'f' System.out.println(ch);
Еще одной формой задания символьных переменных является шестнадцатеричная форма: переменная получает значение в шестнадцатеричной форме, которое следует после символов «\u». Например, char ch=’\u0066′; опять же будет хранить символ ‘f’.
Символьные переменные не стоит путать со строковыми, ‘a’ не идентично «a». Строковые переменные представляют объект String , который в отличие от char или int не является примитивным типом в Java:
String hello = "Hello. "; System.out.println(hello);
Кроме собственно символов, которые представляют буквы, цифры, знаки препинания, прочие символы, есть специальные наборы символов, которые называют управляющими последовательностями. Например, самая популярная последовательность — «\n». Она выполняет перенос на следующую строку. Например:
String text = "Hello \nworld"; System.out.println(text);
Результат выполнения данного кода:
Hello world
В данном случае последовательность \n будет сигналом, что необходимо сделать перевод на следующую строку.
Начиная с версии 15 Java поддерживает тестовые блоки (text blocks) — многострочный текст, облеченный в тройные кавычки. Рассмотрим, в чем их практическая польза. Например, выведем большой многострочный текст:
String text = "Вот мысль, которой весь я предан,\n"+ "Итог всего, что ум скопил.\n"+ "Лишь тот, кем бой за жизнь изведан,\n"+ "Жизнь и свободу заслужил."; System.out.println(text);
С помощью операции + мы можем присоединить к одному тексту другой, причем продолжение текста может располагаться на следующей строке. Чтобы при выводе текста происходил перенос на следующую строку, применяется последовательность \n.
Результат выполнения данного кода:
Вот мысль, которой весь я предан, Итог всего, что ум скопил. Лишь тот, кем бой за жизнь изведан, Жизнь и свободу заслужил.
Текстовые блоки, которые появились в JDK15, позволяют упростить написание многострочного текста:
String text = """ Вот мысль, которой весь я предан, Итог всего, что ум скопил. Лишь тот, кем бой за жизнь изведан, Жизнь и свободу заслужил. """; System.out.println(text);
Весь текстовый блок оборачивается в тройные кавычки, при этом не надо использовать соединение строк или последовательность \n для их переноса. Результат выполнения программы будет тем же, что и в примере выше.