13 апр. 2015 г.

Примитивные целочисленные типы Java - byte, short, int, long, char

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

  Тип   Содержит   По умолчанию   Размер   Диапазон   Обертки
  char   целое беззнаковое   \u0000   16 bits   от \u0000  до \uFFFF (от 0 до 65535 десятичное)   Charaster
  byte   целое знаковое   0   8 bits   от -128 до 127   Byte
  short   целое знаковое   0   16 bits   от -32768 до 32767   Short
  int   целое знаковое   0   32 bits   от -2147483648 до 2147483647   Integer
  long   целое знаковое   0   64 bits   от -9223372036854775808 до 9223372036854775807   Long

Целочисленные литералы

Значения целочисленным переменным и константам задаются при помощи следующих литералов:

108 – десятичный литерал
0154 – восьмеричный литерал (в начале стоит ноль)
0x6c – шестнадцатеричный литерал
0b01101100 – двоичный литерал (с Java 7)

Так же в числовых литералах можно использовать символ подчеркивания _ для разграничения разрядов, это сделано только для удобства написания и понимания и ни как не влияет на значение (с Java 7). Например:

0110_1100, 0x7fff_ffff, 0177_7777_7777

Для обозначения литерала типа long можно использовать суффикс L (можно использовать и маленькую l, но ее легко попутать с единицей 1). Например:

3_000_000_000L

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

long iLong = 2147483648;

Хотя значение 2147483648 является допустимым для типа long, но компилятор считает это число 2147483648 литералом типа int, поскольку у него нет суффикса L, а для типа int число 2147483648 является не допустимым значением и поэтому компилятор выдаст ошибку. Чтобы этого не было надо использовать суффикс L. Например:

long iLong = 2147483648L;

Такое выражение компилятор уже примет как правильное.

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

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

Арифметические операции

I00001

Тут впрочем все просто. На что только надо обратить внимание это то, что деление над целочисленными типами тоже целочисленное и в результате этих операций можно получить как целое число или целую или дробную часть от операции совершенной соответствующими операторами. Инкремент и декремент (увеличение или уменьшение на единицу) может быть как префиксным, так и постфиксным. При использовании префиксного оператора сперва происходит инкремент иди декремент переменной,  а затем используется ее значение, при постфиксной наоборот – сперва используется текущее значение переменной, а затем происходит ее декремент или инкремент.

 

Grabli

Результат арифметической операции имеет тип int, кроме того случая, когда один из
операндов типа long. В этом случае результат будет типа long
. Перед выполнением арифметической операции всегда происходит повышение (promotion) типов byte, short, char. Они преобразуются в тип int, а может быть, и в тип long, если другой операнд типа long. Операнд типа int повышается до типа long, если другой операнд типа long. Конечно, числовое значение операнда при этом не меняется. Это правило приводит иногда к неожиданным результатам.

Все это мы подробно рассмотрим на практических примерах.

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

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

Операция деление по модулю (или остаток) определяется так:
a % b = a — (a / b) * b

То есть 5%3=2, потому что 5-(5/3)*3=2, имейте в виду что 5/3 в данном случае это целочисленное деление и результат этой операции равен 1.

Все операции кроме инкремента и декремента имеют короткую форму записи, представленную в левой колонке. С подобным мы уже сталкивались в типе boolean.

И еще стоит упомянуть об унарном операторе минус (). Если «» используется как унарный оператор перед отдельным операндом, он выполняет унарную инверсию знака. Другими словами, он переводит положительное значение в эквивалентное ему отрицательное, и наоборот.

I00002Ну а теперь, чтобы не было скучно, простенький пример на пройденную тему.

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

Если не понятно то в двух словах объясню. Максимальное положительное значение переменной типа byte равно 127. Что мы и задали в строке 32. Затем чтобы обмануть компилятор мы два раза сделали инкремент этого значения, то есть по идее должны были получить число 129. Если бы мы просто попытались сделать c=c+2, то компилятор и IDE показали бы нам ошибку приведения типов (можете попробовать и убедиться).  Далее мы вывели получившиеся значение, которое стало равно –127. Это произошло потому, что в старший разряд (первый слева) была помещена единица. Числу 129 соответствует двоичное значение 1000 0001.

Но для типа byte, максимальным положительным значением является 127, что соответствует двоичному числу 0111 1111. Когда в старший разряд помещается единица, то это число начинает интерпретироваться как отрицательное. То есть если двоичное число 1000 0001 интерпретировать как отрицательное, то его десятичное значение будет равно –127. Почему так?

А потому-что надо было учить информатику Smile

Теперь приведу вывод этой программы:

I00003

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

Побитовые операции в ряде случаев вещь чрезвычайно полезная и нужная.

В данном примере я рассмотрел из совмещенных операций только операции совмещенного сложения и присвоения, а так же вычитания и присвоения (строки 28 и 30), умножение, деление и деление по модулю уже не стал кодить, так как там все аналогично.

Про операцию деления по модулю еще стоит отметить одно правило:

a == (a / b) * b + (a % b)

Это так на заметку. Ну и поперли дальше!

Побитовые операции

I00004

Побитовые операторы и операторы сдвига манипулируют отдельными битами целого числа. Чаще всего побитовые операторы применяются для проверки и установки отдельных флаговых битов. Чтобы понять их поведение, необходимо понимать двоичные числа и формат дополнения, используемый для представления отрицательных чисел. Эти операторы нельзя использовать с массивами, объектами или с плавающей точкой. Операторы побитового сдвига и оператор NOT (~) так же нельзя использовать с операндами типа boolean. Все побитовые операторы за NOT, имеют совмещенные операторы присваивания. Если один из аргументов побитового оператора имеет значение long, то в результате тоже получится long. Если нет, то результат получается int. Если левый операнд оператора сдвига имеет значение long, то в результате тоже будет long. Если нет, то в результате получится int.

I00005

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

Арифметический сдвиг влево бывает только один, так как там только один вариант чем заполнять младшие освободившиеся биты – это ноль.

Grabli

Побитовые операции выполняются поразрядно, после того как оба операнда будут приведены к одному типу int или long, так же как и для арифметических операций. Это обстоятельство надо учитывать, если вы применяете побитовые операции к типам byte, short и возможно char, поскольку тут тоже могут быть неожиданные эффекты.

Особенно осторожным надо быть с логическим сдвигом вправо >>>.

 

Теперь рассмотрим все эти операторы более подробно.

Побитовое НЕ (~)

Унарный оператор ~ является оператором побитового отрицания, или побитового НЕ. Он инвертирует каждый бит своего единственного операнда, преобразовывая единицы в нули и нули в единицы. Например:

I00006

Побитовое И (&)

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

I00007

Побитовое ИЛИ (|)

Этот оператор объединяет два целых операнда посредством логической операции ИЛИ с их отдельными битами. В результате биты устанавливаются в единицу только там, где соответствующие биты установлены в единицу в одном или обоих операндах. Если оба соответствующих бита в операндах равны нулю, то результат содержит нулевой бит. Например:

I00008

Побитовое исключающее ИЛИ (^)

Этот оператор объединяет два целых операнда посредством логической операции
исключающего ИЛИ с их отдельными битами. В результате биты установлены в единицу только там, где соответствующие биты в двух операндах различны. Если оба бита – нули или единицы, то результат будет содержать нулевой бит. Например:

I00009

Побитовый сдвиг влево (<<)

Оператор << сдвигает биты левого операнда влево на количество позиций, обозначенное правым операндом. Старшие биты левого операнда теряются, а справа добавляются нулевые биты. Сдвиг целого числа влево на n позиций равносилен умножению этого числа на 2n. Например:

I00010

Если левый операнд представляет тип long, то значение правого операнда должно находиться в диапазоне между 0 и 63. В противном случае левый операнд считается int, а значение правого операнда должно располагаться между 0 и 31.

Побитовый арифметический сдвиг вправо со знаком (>>)

Оператор >> сдвигает биты левого операнда вправо на количество позиций, обозначенное правым операндом. Младшие биты левого операнда сдвигаются «наружу» и теряются. Старшие биты, сдвигаемые «внутрь», идентичны изначальному старшему биту левого операнда, то есть если в старшем бите была единица, то освободившиеся старшие биты заполняются единицами, а если ноль, то нолями.  Данный прием называется расширением знака. Он применяется для сохранения знака левого операнда. Если левый операнд положительный, а правый имеет значение n, то оператор >> равносилен целочисленному делению на 2n.
Например:

I00011

Побитовый логический сдвиг вправо без знака (>>>)

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

I00012

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

И еще несколько небольших замечаний:

  • В побитовых операциях используется по умолчанию тип int, то есть компилятор java всегда воспринимает правый операнд как int, поэтому при операциях с byte и short необходимо пользоваться операцией приведения типов. Мы это еще пока не проходили, но скоро пройдем, а пока мотаем на ус.
  • Это же справедливо и для арифметических операций, как я уже говорил, происходит автоматическое приведение всех операндов к типу int или long.

Ну а теперь немножко практики.

В библиотеку ProJava.jar я добавил еще парочку статических методов printlnByte и printByte для вывода значений типа byte в двоичном виде как строку.

И далее то что это программа выводит

I00013

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

Теперь посмотрим на вывод этой программы:

I00014

Как видим для типа int все идет так как написано, то есть старшие биты заполняются нужным количеством нулей. А вот для типа byte, уже начинаются глюки.
Строка 32 выводит нам десятичное значение переменной типа byte b1. И это значение равно 1073741811. Не хило так для типа byte, у которого максимальное положительное значение это 127. Это произошло потому, что, как уже говорилось, при арифметических и побитовых операциях происходит автоматическое приведение типов byte и short до типа int (или long). Вот на это мы и напоролись в 32 строке.

39 строка, которая выводит двоичное значение переменной типа byte b1 тоже преподнесла нам сюрприз. По идее в двух старших битах должны быть два нуля, но мы их там не наблюдаем. Там пара единиц. Это опять же произошло все по той же причине автоматического расширение byte и short до int или long, если long присутствует в выражении.

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

И так в строке 39 мы просто получили обрубок значения int, старшие разряды которого были выкинуты, вместе с двумя нулями в начале (смотрите внимательно скриншот вывода).

Теперь поправим эту ситуацию, чтобы все работало правильно. Для этого надо применить маску 0xff, которая превратит все старшие 24 разряда типа int в нули.

Исправленный вариант:

и далее вывод программы (только новая часть):

I00015

Ну и напоследок приведу табличку побитовых операций (не сдвиговых, т.к. это не имеет смысла)

I00016

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

Grabli

Хотя про еще одни грабли все таки стоит упомянуть. Это опять же касается операций сдвига. Перед тем как совершать любой побитовый сдвиг (например, x>>y) виртуальная машина java вычисляет остаток от деления y на ширину типа данных (для int 32 (y%32), для long 64 (y%64) и т.д.) и производит сдвиг на величину этого остатка. Поэтому, например, если мы задумаем сдвинуть значение типа int на 32 бита или 64 бита и т.п., каким либо оператором сдвига, то значение x останется прежним, потому что 32%32=0 (64%32=0).

А теперь, чтобы стало понятнее рассмотрим это на примере:

I00017

И вывод этой программы на консоль:

I00018

Как видим, там где мы сдвигали на 32 разряда, ни какого сдвига на самом деле не произошло по описанной выше причине.

Кроме того, при сдвиге на 48 позиций вправо, сдвиг на самом деле произошел на 16 позиций, по той же причине.

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

2 комментария:

  1. Автор респект тебе. Так понятно мне еще никогда не было.
    Продолжай вести блог дальше, помоги стать мидлом скорее)

    ОтветитьУдалить