Long java сколько цифр

Java/Типы данных

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

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

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

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

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

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

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

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

В стандартной реализации Sun JVM и Oracle HotSpot JVM тип boolean занимает 4 байта (32 бита), как и тип int. Однако, в определенных версиях JVM имеются реализации, где в массиве boolean каждое значение занимает по 1-му биту.

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

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

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

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

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

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

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

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

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

Java Numbers

Integer types stores whole numbers, positive or negative (such as 123 or -456), without decimals. Valid types are byte , short , int and long . Which type you should use, depends on the numeric value.

Floating point types represents numbers with a fractional part, containing one or more decimals. There are two types: float and double .

Even though there are many numeric types in Java, the most used for numbers are int (for whole numbers) and double (for floating point numbers). However, we will describe them all as you continue to read.

Integer Types

The byte data type can store whole numbers from -128 to 127. This can be used instead of int or other integer types to save memory when you are certain that the value will be within -128 and 127:

Example

Short

The short data type can store whole numbers from -32768 to 32767:

Example

The int data type can store whole numbers from -2147483648 to 2147483647. In general, and in our tutorial, the int data type is the preferred data type when we create variables with a numeric value.

Example

The long data type can store whole numbers from -9223372036854775808 to 9223372036854775807. This is used when int is not large enough to store the value. Note that you should end the value with an «L»:

Example

Floating Point Types

You should use a floating point type whenever you need a number with a decimal, such as 9.99 or 3.14515.

The float and double data types can store fractional numbers. Note that you should end the value with an «f» for floats and «d» for doubles:

Float Example

Double Example

Use float or double ?

The precision of a floating point value indicates how many digits the value can have after the decimal point. The precision of float is only six or seven decimal digits, while double variables have a precision of about 15 digits. Therefore it is safer to use double for most calculations.

Scientific Numbers

A floating point number can also be a scientific number with an «e» to indicate the power of 10:

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

int aInt = 8; // Определяющая (числовая) часть этого объявления int называется литералом.

int hexInt = 0x1a; // = 26; Вы можете определить литералы с шестнадцатеричными значениями с префиксом 0x .

int binInt = 0b11010; // = 26; Вы также можете определить бинарные литералы; с префиксом 0b .

long goodLong = 10000000000L; // По умолчанию целочисленные литералы имеют тип int. Добавив L в конец литерала, вы сообщаете компилятору, что литерал длинный. Без этого компилятор будет вызывать ошибку «Целое число слишком большое».

double aDouble = 3,14; // Литералы с плавающей запятой по умолчанию имеют тип double.

float aFloat = 3.14F; // По умолчанию этот литерал был бы двойным (и вызвал ошибку «Несовместимые типы»), но, добавив F, мы скажем компилятору, что это float.

замечания

Java имеет 8 примитивных типов данных , а именно: boolean , byte , short , char , int , long , float и double . (Все остальные типы являются ссылочными типами, включая все типы массивов и встроенные типы объектов / классы, которые имеют особое значение на языке Java, например String , Class и Throwable и его подклассы).

Результат всех операций (сложение, вычитание, умножение и т. Д.) В примитивном типе — это, по меньшей мере, int , поэтому добавление short в short вызывает int , как и добавление byte в byte , или char для char , Если вы хотите присвоить результат этого значения значению того же типа, вы должны его бросить. например

Неисполнение операции приведет к ошибке компиляции.

Это связано со следующей частью Java Language Spec, §2.11.1 :

Компилятор кодирует нагрузки буквенных значений byte типов и short с помощью инструкций Java Virtual Machine, которые подписывают эти значения до значений типа int во время компиляции или времени выполнения. Загрузка значений букв типов boolean и char кодируется с использованием инструкций, которые нулевым образом расширяют литерал до значения типа int во время компиляции или времени выполнения. [..]. Таким образом, большинство операций над значениями фактических типов boolean , byte , char и short корректно выполняются инструкциями, действующими на значения вычислительного типа int .

Причина этого также указана в этом разделе:

Учитывая однобайтовый размер кода операции Java Virtual Machine, типы кодирования в opcodes оказывают давление на дизайн своего набора команд. Если каждая типизированная команда поддерживает все типы данных во время выполнения Java Virtual Machine, будет больше инструкций, чем может быть представлено в byte . [. ] Отдельные инструкции могут использоваться для преобразования между неподдерживаемыми и поддерживаемыми типами данных по мере необходимости.

Int примитив

Примитивный тип данных, такой как int содержит значения непосредственно в переменной, которая его использует, между тем переменная, которая была объявлена ​​с использованием Integer содержит ссылку на значение.

Согласно java API : «Класс Integer обертывает значение примитивного типа int в объекте. Объект типа Integer содержит одно поле, тип которого является int».

По умолчанию int представляет собой 32-разрядное целое число со знаком. Он может хранить минимальное значение -2 31 и максимальное значение 2 31 — 1.

Если вам нужно сохранить номер за пределами этого диапазона, следует использовать его в качестве long . Превышение диапазона значений int приводит к переполнению целых чисел, в результате чего значение, превышающее диапазон, будет добавлено к противоположному сайту диапазона (положительное становится отрицательным и наоборот). Значение равно ((value — MIN_VALUE) % RANGE) + MIN_VALUE или ((value + 2147483648) % 4294967296) — 2147483648

Максимальное и минимальное значения int можно найти по адресу:

Значение по умолчанию для int равно 0

Короткий примитив

short является 16-разрядное целое число со знаком. Он имеет минимальное значение -2 15 (-32,768), а максимальное значение составляет 2 15 -1 (32 767)

Максимальные и минимальные значения short можно найти по адресу:

Значение по умолчанию short равно 0

Длинный примитив

По умолчанию long — это 64-разрядное целое число со знаком (в Java 8 оно может быть либо подписано, либо без знака). Подписано, оно может хранить минимальное значение -2 63 и максимальное значение 2 63 — 1, а без знака оно может хранить минимальное значение 0 и максимальное значение 2 64 — 1

Максимальное и минимальное значения long можно найти по адресу:

Значение по умолчанию long равно 0L

Примечание: буква «L», добавленная в конце long литерала, нечувствительна к регистру, однако хорошей практикой является использование капитала, поскольку ее легче отличить от цифры один:

Предупреждение: Java кэширует объекты Integer объектов из диапазона от -128 до 127. Объяснение здесь объясняется: https://blogs.oracle.com/darcy/entry/boxing_and_caches_integer_valueof

Следующие результаты можно найти:

Чтобы правильно сравнить значения 2 объекта Long, используйте следующий код (начиная с Java 1.7):

Сравнение примитива long long с Object long не приведет к ложному отрицанию, сравнив 2 объекта с.

Булевский примитив

boolean может сохранять одно из двух значений: true или false

Значение по умолчанию для boolean равно false

Байт-примитив

byte представляет собой 8-разрядное целое число со знаком. Он может хранить минимальное значение -2 7 (-128), а максимальное значение 2 7 — 1 (127)

Максимальное и минимальное значения byte можно найти по адресу:

Значение по умолчанию byte равно 0

Поплавковый примитив

float — это 32-битное число с плавающей запятой IEEE 754 с одной точностью. По умолчанию десятичные знаки интерпретируются как двойные. Чтобы создать float , просто добавьте f в десятичный литерал.

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

Примечание. В результате ошибок с плавающей запятой могут незначительно отличаться. Некоторые результаты были округлены для ясности и удобочитаемости (т. Е. Напечатанный результат примера добавления был фактически 34.600002).

Из-за того, что хранятся числа с плавающей точкой (т. Е. В двоичной форме), многие числа не имеют точного представления.

Хотя использование float подходит для большинства приложений, для хранения точных представлений десятичных чисел (например, денежных сумм) или чисел, где требуется более высокая точность, не следует использовать float или double . Вместо этого следует использовать класс BigDecimal .

Значение по умолчанию для float равно 0.0f .

float точностью до ошибки составляет 1 из 10 миллионов.

Примечание: Float.POSITIVE_INFINITY , Float.NEGATIVE_INFINITY , Float.NaN — значения с float . NaN означает результаты операций, которые невозможно определить, например, деление 2 бесконечных значений. Кроме того, 0f и -0f различны, но == дает true:

Двойной примитив

double — это 64-битное число с плавающей запятой IEEE 754 с двойной точностью.

Из-за того, что хранятся числа с плавающей запятой, многие номера не имеют точного представления.

Хотя для большинства приложений используется double для хранения точных чисел, таких как валюта, не следует использовать ни float ни double . Вместо этого следует использовать класс BigDecimal

Значение по умолчанию double равно 0.0d

Примечание: Double.POSITIVE_INFINITY , Double.NEGATIVE_INFINITY , Double.NaN — double значения. NaN означает результаты операций, которые невозможно определить, например, деление 2 бесконечных значений. Кроме того, 0d и -0d различны, но == -0d true:

Первоначальный символ

char может хранить один 16-разрядный символ Юникода. Символьный литерал заключен в одинарные кавычки

Он имеет минимальное значение \u0000 (0 в десятичном представлении, также называемое нулевым символом ) и максимальное значение \uffff (65,535).

Значением по умолчанию char является \u0000 .

Чтобы определить значение символа «char ' использовать escape-последовательность (символ, которому предшествует обратная косая черта):

Существуют также другие escape-последовательности:

Вы можете объявить char любого символа Юникода.

Также можно добавить char . например, для повторения каждой строчной буквы, вы можете сделать следующее:

Представление отрицательного значения

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

Для уникального двоичного представления типа данных с использованием n бит значения кодируются следующим образом:

Наименее значимые n-1 биты сохраняют положительное целое число x в интегральном представлении. Наиболее значимое значение хранит бит с значением s . Значение, представленное этими битами, равно

т.е. если самый старший бит равен 1, то значение, которое просто на 1 больше, чем число, которое вы могли бы представить с другими битами ( 2 n-2 + 2 n-3 + . + 2 1 + 2 0 = 2 n-1 — 1 ), что дает уникальное двоичное представление для каждого значения от — 2 n-1 (s = 1; x = 0) до 2 n-1 — 1 (s = 0; x = 2 n-1 — 1).

Это также имеет хороший побочный эффект, что вы можете добавить двоичные представления, как если бы они были положительными двоичными числами:

Обратите внимание, что этот факт упрощает поиск двоичного представления аддитивного обратного (т. Е. Отрицательного значения):

Обратите внимание, что добавление побитового дополнения к числу приводит к тому, что все биты равны 1. Теперь добавьте 1, чтобы сделать переполнение значения, и вы получите нейтральный элемент 0 (все биты 0).

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

Пример: принятие отрицательного значения 0 ( byte ):

Результатом отрицания 0 является 11111111 . Добавление 1 дает значение 100000000 (9 бит). Поскольку byte может хранить только 8 бит, самое левое значение усекается, а результат равен 00000000

Потребление памяти примитивов против бокс-примитивов

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

В операциях с интенсивным использованием данных потребление памяти может существенно повлиять на производительность. Потребление памяти растет еще больше при использовании массивов: для массива float[5] требуется только 32 байта; тогда как Float[5] хранящий 5 различных ненулевых значений, потребует всего 112 байтов (на 64-разрядном без сжатых указателей, это увеличивается до 152 байт).

Вложенные кеширование значений

Косвенные накладные расходы в штучной упаковке могут быть в некоторой степени смягчены кэшами в штучной упаковке. Некоторые из типов в штучной упаковке реализуют кеш экземпляров. Например, по умолчанию класс Integer будет кэшировать экземпляры для представления чисел в диапазоне от -128 до +127 . Однако это не снижает дополнительные затраты, связанные с дополнительной памятью.

Если вы создаете экземпляр типа boxed либо с помощью autoboxing, либо путем вызова статического метода valueOf(primitive) , система времени выполнения попытается использовать кешированное значение. Если ваше приложение использует множество значений в кэше, то это может существенно снизить штраф за использование ящиков в коробке. Конечно, если вы создаете экземпляры экземпляров в штучной упаковке «вручную», лучше использовать valueOf вместо new . ( new операция всегда создает новый экземпляр.) Если, однако, большинство ваших значений не находятся в кешированном диапазоне, быстрее можно вызвать new и сохранить поиск кеша.

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

В Java мы можем конвертировать между целыми значениями и значениями с плавающей запятой. Кроме того, поскольку каждый символ соответствует числу в кодировке Unicode, типы char могут быть преобразованы в типы и с целыми числами и с плавающей точкой. boolean — единственный примитивный тип данных, который не может быть преобразован в какой-либо другой примитивный тип данных.

Существует два типа конверсий: расширение конверсии и сужение конверсии .

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

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

Java автоматически расширяет конверсии . Но если вы хотите выполнить сужение конверсии (если вы уверены, что потеря данных не произойдет), вы можете заставить Java выполнить преобразование с использованием языковой конструкции, известной как cast .

Расширение конверсии:

Сужение конверсии:

Примитивные типы

Таблица, показывающая диапазон размеров и значений всех примитивных типов:

1. Спецификация языка Java предусматривает, что подписанные интегральные типы ( byte через long ) используют двоичное представление двухкомпонента, а типы с плавающей точкой используют стандартные двоичные представления с плавающей точкой IEE 754.
2. Java 8 и более поздние версии предоставляют методы для выполнения беззнаковых арифметических операций по int и long . Хотя эти методы позволяют программе обрабатывать значения соответствующих типов как неподписанные, типы остаются подписанными типами.
3. Наименьшая плавающая точка, показанная выше, является субнормальной ; т.е. они имеют меньшую точность, чем нормальное значение. Наименьшие нормальные числа: 1.175494351e-38 и 2.2250738585072014e-308
4. char обычно представляет собой блок кода Unicode / UTF-16.
5. Хотя boolean содержит только один бит информации, его размер в памяти варьируется в зависимости от реализации виртуальной машины Java (см. Boolean type ).

report this ad

Типы данных и литералы

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

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

Существует два типа данных в Java:

• простые или примитивные типы данных;
• ссылочные типы данных (ссылка/объект).

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

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

Тип byte

• Тип данных byte является 8-разрядным знаковым целым числом.
• Минимальная величина равна -128 (-2 7 ).
• Максимальное значение равно 127 (включительно) (2 7 -1).
• По умолчанию – 0.
• byte предназначен для экономии места в больших массивах, главным образом вместо целых чисел, поскольку byte в четыре раза меньше, чем int.
• Пример:

Тип short

• Тип данных short является 16-разрядным знаковым целым числом.
• Минимальное значение равно -32768 (-2 15 ).
• Максимальная величина равна 32 767 (включительно) (2 15 -1).
• Тип short в Java может также использоваться для экономии памяти как byte. Размер short в 2 раза меньше, чем int.
• По умолчанию — 0.
• Пример:

Тип int

• В языке Java тип данных int является 32-разрядным знаковым целым числом.
• Минимальный размер int — 2 147 483 648 (-2 31 ).
• Максимальная величина равна 2,147,483,647 (включительно)(2 31 -1).
• Тип int обычно используется для целых значений. Если нет озабоченности по поводу памяти.
• По умолчанию равно 0.
• Пример:

Тип long

• Тип данных long является 64-разрядным знаковым целым числом.
• Минимальное значение равно — 9,223,372,036,854,775,808 (-2 63 ).
• Максимальная величина — 9,223,372,036,854,775,807 (включительно). (2 63 -1).
• В Java Применяется когда требуется более широкий диапазон, чем int.
• По умолчанию — 0L.
• Пример:

Тип float

• Тип данных float является c одинарной точностью 32-битный IEEE 754 с плавающей точкой.
• Тип float используется главным образом для сохранения памяти в больших массивах чисел с плавающей точкой.
• По умолчанию — 0.0f.
• Тип float никогда не должен применяется для точного значения, например, валюты.
• Пример:

Тип double

• Тип данных double является c двойной точностью 64-битный IEEE 754 с плавающей точкой.
• Обычно используется для десятичных значений.
• Тип double никогда не должен применяется для точного значения, например, валюты.
• По умолчанию — 0.0d.
• Пример:

Тип boolean

• Тип данных boolean представляет собой один бит информации.
• Существует только два возможных значения: true и false.
• Предназначен для простых признаков, которые позволяют отслеживать условия true или false.
• По умолчанию — false.
• Пример:

Тип char

• Тип данных char является одним 16-разрядным символом Юникода.
• Минимальная величина равна «\u0000» (или 0).
• Максимальная величина равна «\uffff» (или 65535 включительно).
• В Java char нужен для хранения любого символа.
• Пример:

Ссылочные типы данных

• Ссылочные переменные создаются с использованием определенных конструкторов классов. Они предназначены для доступа к объектам. Эти переменные объявляются с определенным типом, который не может быть изменен. Например, Employee, Puppy и т.д.
• Объекты класса и различные виды переменных массива подпадают под ссылочный тип данных.
• По умолчанию в Java значение любой переменной ссылки — null.
• Ссылочная переменная может применяться для обозначения любого объекта, объявленного или любого совместимого типа.
• Пример:

Литералы в Java

Литерал — представление исходного кода как фиксированное значение. Оно представлено непосредственно в коде без каких-либо вычислений.

Литерал в Java можно назначить любой переменной из основного типа. Например:

Byte, int, long, и short может выражаться десятичной (основание 10), шестнадцатеричной (основание 16) или восьмеричной (основание 8) системой исчисления.

При использовании литералов в Java, префикс 0 применяться для указания восьмеричной системы, а префикс 0x указывает на шестнадцатеричную систему. Например:

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

Типы литералов String и char могут содержать любые символы Юникода. Например:

Язык Java поддерживает несколько специальных управляющих последовательностей для литералов String и char:

Более подробно управляющие последовательности с примерами рассмотрим в следующих уроках.

Следующий урок объясняет различные типы переменных и их использование. Это даст Вам хорошее представление о том, как они могут использоваться в java-классах, интерфейсах и т.д.