8 примитивных типов в Java

Когда я начал редактировать свою серию «Основы Java» пару лет назад, я подумал, что было бы разумно начать выкладывать действительно детальную информацию в свои посты. Таким образом, контент для начинающих намного легче усваивается. Для начала я извлекаю всю информацию о 8 примитивных типах в Java.

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

Как следует из названия этой статьи, в Java есть 8 примитивных типов, встроенных в язык. В следующих подразделах мы рассмотрим все восемь примитивных типов в произвольном порядке. Для каждого примитивного типа мы опишем, как его использовать и каковы его ограничения.

Примитивный тип Int

Для начала, целые числа Java имеют 32-битные значения со знаком (что означает положительные или отрицательные значения) и обозначаются ключевым словом int :

Конечно, как и у всех примитивных типов, целые числа имеют свои пределы. Поскольку они 32-разрядные, мы рассматриваем диапазон значений от -2 147 483 648 до 2 147 483 647. Это много цифр! Конечно, мы можем подтвердить этот диапазон, используя удобный трюк в панели взаимодействий DrJava:

Естественно, int , вероятно, является наиболее распространенным целочисленным типом, используемым для простых вычислений. Если вам нужен больший диапазон, смотрите long ниже.

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

В отличие от int , двойники Java являются 64-битными значениями с плавающей запятой, и они помечаются ключевым словом double :

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

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

Имейте в виду, что отрицательные показатели означают чрезвычайно малые числа — в отличие от крайне отрицательных чисел — поэтому мы не совсем смотрим на тот же диапазон, что и с целыми числами.

В общем, double является выбором по умолчанию для значений с плавающей точкой в ​​Java. Альтернатива — float .

Чар Примитивный Тип

Как мы уже видели, символы Java представляют 16-разрядные символы и помечаются ключевым словом char :

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

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

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

Как оказалось, тип char является единственным типом без знака в Java. Другими словами, символ может варьироваться от 0 до 65 535, где каждое число соответствует определенному символу. Чтобы создать символы вне этого списка, Java может объединять пары символов. Проверьте несколько строк в Java для некоторых примеров.

Тип байтового примитива

Когда мы болтали о двоичном коде, мы немного поговорили о концепции. Ну, группа из восьми битов составляет байт, который Java поддерживает как примитивный тип. Тип byte — это, по сути, просто 8-битное число, которое варьируется от -128 до 127. Как и ожидалось, байты обозначаются ключевым словом byte :

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

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

Короткий Примитивный Тип

Тип short — это другой целочисленный тип, но он занимает меньше места, чем тип int. На самом деле, он занимает ровно половину пространства в 16 битах и ​​помечается short ключевым словом:

С точки зрения диапазона, short тип включает в себя только половину битов как целое число, но мы можем подтвердить это как обычно:

Для практических целей short имеет только 65 546 возможных значений. И byte и short обычно используются при нехватке памяти и дискового пространства. В противном случае безопасно использовать int как это тип по умолчанию при объявлении целых чисел.

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

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

Естественно, мы обозначаем длинные с ключевым словом long :

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

Возможно, long будет полезен для вычисления расстояния, которое проходит свет в данный период времени. Через одну секунду свет проходит около 300 миллионов метров. Если бы мы написали программу для отслеживания расстояния света в реальном времени, тип int исчезнет примерно через 7 секунд, в то время как long может рассчитать до 975 лет. Не веришь мне? Проверьте этот Gist, который проходит через весь расчет.

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

Хотя мы часто используем double который является 64-битным типом чисел с плавающей запятой, Java поддерживает другой тип чисел с плавающей запятой, называемый float . Однако, как и в случае с int , для значений по умолчанию Java по умолчанию double . В любом случае, мы можем обозначить 32-битное число с плавающей запятой, используя ключевое слово float :

Чтобы получить представление о диапазоне float , давайте снова воспользуемся нашим приемом:

Как мы видим, 32 бита действительно уменьшают наш диапазон и точность. Если мы хотим использовать десятичное значение с меньшей точностью, чем double при использовании половины пробела, тип с float является опцией.

Булев примитивный тип

Наконец, мы можем охватить boolean тип. Чтобы объявить boolean , мы можем использовать ключевое слово boolean :

Булевы значения немного уникальны, потому что они не представляют числовые значения, как все другие примитивные типы. На самом деле наш маленький MAX_VALUE и MIN_VALUE здесь не сработает. Вместо этого логические значения представляют true или false которые мы могли бы вспомнить из предыдущего урока по логике.

Сейчас мы не будем тратить на это много времени, потому что это станет частью почти всего, что мы делаем в Java. Тем не менее, мы часто не будем объявлять их явно так. Вместо этого они являются результатом сравнений, которые управляют логикой в ​​коде. Проверьте раздел логических операторов ниже для получения дополнительной информации.

Хотите узнать больше?

Как уже упоминалось, эту информацию можно было ранее найти в статье « Примитивные типы и переменные в Java» . Конечно, теперь эту статью гораздо легче читать.

В любом случае, еще раз спасибо за вашу поддержку. Увидимся в следующий раз!