Java byte тип: Java. Экспресс-курс: Типы

Pro Java: Примитивные целочисленные типы Java

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

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

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

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.

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

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

Результат арифметической операции имеет тип 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Как видим для типа 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 в нули.

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

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

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

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

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

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

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

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

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

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

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

Типы в Java распределены на две категории: примитивные (простые) и ссылочные (объектные). Ссылочные типы — это массивы, классы и интерфейсы. 

В этом разделе мы рассмотрим примитивные типы. Простые типы в Java предопределены заранее и поименованы зарезервированными словами (keywords).

Примитивные типы можно разделить на следующие четыре группы:

1. Целые числа. Эта группа включает в себя типы данных byte, short, int и long, представляющие целые числа со знаком.

2. Числа с плавающей точкой. Эта группа включает в себя типы данных flоаt и double, представляющие числа с точностью до определенного знака после десятичной точки.

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

4. Логические значения. Эта группа включает в себя тип данных boolean, специально предназначенный для представления логических значений.

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

Размер Java объектов / Хабр

Знаете сколько в памяти занимает строка? Каких только я не слышал ответов на этот вопрос, начиная от «не знаю» до «2 байта * количество символов в строке». А сколько тогда занимает пустая строка? А знаете сколько занимает объект класса Integer? А сколько будет занимать Ваш собственный объект класса с тремя Integer полями? Забавно, но ни один мой знакомый Java программист не смог ответить на эти вопросы… Да, большинству из нас это вообще не нужно и никто в реальных java проектах не будет об этом думать. Но это, ведь, как не знать объем двигателя машины на которой Вы ездите. Вы можете быть прекрасным водителем и даже не подозревать о том, что значат цифры 2.4 или 1.6 на вашей машине. Но я уверен, что найдется мало людей, которые не знакомы со значением этих цифр. Так почему же java программисты так мало знают об этой части своего инструмента?

Integer vs int

Все мы знаем, что в java — everything is an object. Кроме, пожалуй, примитивов и ссылок на сами объекты. Давайте рассмотрим две типичных ситуации:

//первый случай
int a = 300;
//второй случай
Integer b = 301;

В этих простых строках разница просто огромна, как для JVM так и для ООП. В первом случае, все что у нас есть — это 4-х байтная переменная, которая содержит значение из стека. Во втором случае у нас есть ссылочная переменная и сам объект, на который эта переменная ссылается. Следовательно, если в первом случае мы определено знаем, что занимаемый размер равен:

sizeOf(int)

то во втором:

sizeOf(reference) + sizeOf(Integer)

Забегая вперед скажу — во втором случае количество потребляемой памяти приблизительно в 5 раз больше и зависит от JVM. А теперь давайте разберемся, почему разница настолько огромна.

Из чего же состоит объект?

Прежде чем определять объем потребляемой памяти, следует разобраться, что же JVM хранит для каждого объекта:

• Заголовок объекта;
• Память для примитивных типов;
• Память для ссылочных типов;
• Смещение/выравнивание — по сути, это несколько неиспользуемых байт, что размещаются после данных самого объекта. Это сделано для того, чтобы адрес в памяти всегда был кратным машинному слову, для ускорения чтения из памяти + уменьшения количества бит для указателя на объект + предположительно для уменьшения фрагментации памяти. Стоит также отметить, что в java размер любого объекта кратен 8 байтам!

Структура заголовка объекта

Каждый экземпляр класса содержит заголовок. Каждый заголовок для большинства JVM(Hotspot, openJVM) состоит из двух машинных слов. Если речь идет о 32-х разрядной системе, то размер заголовка — 8 байт, если речь о 64-х разрядной системе, то соответственно — 16 байт. Каждый заголовок может содержать следующую информацию:

• Маркировочное слово (mark word) — к сожалению мне так и не удалось найти назначение этой информации, подозреваю что это просто зарезервированная на будущее часть заголовка.
• Hash Code — каждый объект имеет хеш код. По умолчанию результат вызова метода Object.hashCode() вернет адрес объекта в памяти, тем не менее некоторые сборщики мусора могут перемещать объекты в памяти, но хеш код всегда остается одним и тем же, так как место в заголовке объекта как раз может быть использовано для хранения оригинального значения хеш кода.
• Garbage Collection Information — каждый java объект содержит информацию нужную для системы управления памятью. Зачастую это один или два бита-флага, но также это может быть, например, некая комбинация битов для хранения количества ссылок на объект.
• Type Information Block Pointer — содержит информацию о типе объекта. Этот блок включает информацию о таблице виртуальных методов, указатель на объект, который представляет тип и указатели на некоторые дополнительные структуры, для более эффективных вызовов интерфейсов и динамической проверки типов.
• Lock — каждый объект содержит информацию о состоянии блокировки. Это может быть указатель на объект блокировки или прямое представление блокировки.
• Array Length — если объект — массив, то заголовок расширяется 4 байтами для хранения длины массива.

Спецификация Java

Известно, что примитивные типы в Java имеют предопределенный размер, этого требует спецификация для переносимости кода. Поэтому не будем останавливаться на примитивах, так как все прекрасно описано по ссылке выше. А что же говорит спецификация для объектов? Ничего, кроме того, что у каждого объекта есть заголовок. Иными словами, размеры экземпляров Ваших классов могут отличатся от одной JVM к другой. Собственно, для простоты изложения я буду приводить примеры на 32-х разрядной Oracle HotSpot JVM. А теперь давайте разберем самые используемые классы Integer и String.

Integer и String

Итак, давайте попробуем подсчитать сколько же будет занимать объект класса Integer в нашей 32-х разрядной HotSpot JVM. Для этого нужно будет заглянуть в сам класс, нам интересны все поля, которые не объявлены как static. Из таких видим только одно — int value. Теперь исходя из информации выше получаем:

Заголовок: 8 байт
Поле int: 4 байта
Выравнивание для кратности 8 : 4 байта
Итого: 16 байт

Теперь заглянем в класс строки:

    private final char value[];
    private final int offset;
    private final int count;
    private int hash;

И подсчитаем размер:

Заголовок: 8 байт
Поля int: 4 байта * 3 == 12 байт
Ссылочная переменная на объект массива: 4 байта
Итого: 24 байта

Ну и это еще не все… Так как строка содержит ссылку на массив символов, то, по сути, мы имеем дело с двумя разными объектами — объектом класса String и самим массивом, который хранит строку. Это, как бы, верно с точки зрения ООП, но если посмотреть на это со стороны памяти, то к полученному размеру нужно добавить и размер выделенного для символов массива. А это еще 12 байт на сам объект массива + 2 байта на каждый символ строки. Ну и, конечно же, не забываем добавлять выравнивание для кратности 8 байтам. Итого в конечном итоге простая, казалось бы, строка new String(«a») выливается в:

new String()
Заголовок: 8 байт
Поля int: 4 байта * 3 == 12 байт
Ссылочная переменная на объект массива: 4 байта
Итого: 24 байта

new char[1]
Заголовок: 8 байт + 4 байта на длину массива == 12 байт
Примитивы char: 2 байта * 1 == 2 байта
Выравнивание для кратности 8 : 2 байта
Итого: 16 байта

Итого, new String("a") == 40 байт

Важно отметить, что new String(«a») и new String(«aa») будут занимать одинаковое количество памяти. Это важно понимать. Типичный пример использования этого факта в свою пользу — поле hash в классе String. Если бы его не было, то объект строки так или иначе занимал бы 24 байта, за счет выравнивания. А так получается что для этих 4-х байтов нашлось очень достойное применение. Гениальное решение, не правда ли?

Размер ссылки

Немножко хотел бы оговорится о ссылочных переменных. В принципе, размер ссылки в JVM зависит от ее разрядности, подозреваю, что для оптимизации. Поэтому в 32-х разрядных JVM размер ссылки обычно 4 байта, а в 64-х разрядных — 8 байт. Хотя это условие и не обязательно.

Группировка полей

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

• 1. 8-ми байтовые типы(double и long)
• 2. 4-х байтовые типы(int и float)
• 3. 2-х байтовые типы(short и char)
• 4. Одно байтовые типы(boolean и byte)
• 5. Ссылочные переменные

Зачем все это?

Иногда возникает ситуация в которой Вам необходимо прикинуть приблизительный объем памяти для хранения тех или иных объектов, например словаря, эта маленькая справка поможет быстро сориентироваться. Также, это потенциально возможный способ оптимизации, особенно в том окружении, где доступ к его настройкам не доступен.

Выводы

Тема памяти в java очень интересна и обширна, когда я начинал писать эту статью, то думал что уложусь в пару примеров с выводами. Но чем дальше и глубже копаешь, тем больше и интересней становится. Вообще, знать как выделяется память для объектов очень полезная вещь, так как поможет Вам сэкономить память, предотвратить подобные проблемы или оптимизировать вашу программу в местах, где это казалось невозможным. Конечно, места где можно использовать такие оптимизации — очень редки, но все же… Надеюсь статья была Вам интересной.

Java — Типы данных и литералы / ProgLang

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

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

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

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

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

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

Тип byte

Тип short

Тип int

Тип long

Тип float

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

  float f1 = 234.5f;

Тип double

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

  double d1 = 123.4;

Тип boolean

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

  boolean one = true;

Тип char

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

  char letterA ='A';

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

Литералы в Java

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

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

byte a = 68;
char a = 'A';

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

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

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

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

"Hello World"
"two\nlines"
"\"This is in quotes\""

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

char a = '\u0001';
String a = "\u0001";

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

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

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

Поделитесь:

Java 8 операции — urvanov.ru

Цикл статей «Учебник Java 8».

Следующая статья — «Java 8 выражения, инструкции и блоки».
Предыдущая статья — «Переменные в Java 8».

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

Содержание

Операция присваивания

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

— Расширяющее преобразование примитивов

— Сужающее преобразование примитивов

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

Унарные операции

— Отличие постфиксного и префиксного инкремента и декремента

Операции сравнения

Логические И и ИЛИ

Операция instanceof

Тернарная операция

Битовые операции

Присвоение с выполнением другой операции

Приоритеты операций

Операция присваивания

Операция «=» позволяет присвоить значение переменной:

int x = 3;
long l1 = 10_000_000_000L;
float f1 = 1.3f;
double weight = 81.34;
byte b1 = 100;
short sh2 = -10000;
char ch2 = 60000;

КОНСТАНТНЫЕ значения до
int  можно присвоить без приведения типа к переменным меньшего размера (например
short  в
byte), если значение помещается в эту переменную.

Вы можете присвоить переменной, имеющей больший тип, значение меньшего типа, например переменной типа
double  можно присвоить значение
int, но не наоборот (но можно использовать приведение типа, если очень нужно).

Примеры:

double d1 = 2; // Это можно
int x = 2.3; // так нельзя. Будет ошибка компиляции.

byte b1 = 100; //Это можно, так как литерал 100 гарантировано
// поместится в byte.

byte b2 = 10000; //Нельзя. Ошибка компиляции.

int n = 100;
byte b3 = n; //А вот так тоже нельзя, так как
// переменная n имеет тип int.

Операция присваивания возвращает значение, которое присвоила, поэтому можно присваивать значение сразу нескольким переменным по цепочке:

int x;
int y;
int z = x = y = 10; // y, x и z будет присвоено 10.

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

Есть два типа преобразования примитивных типов:

Расширяющее преобразование примитивов

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

• byte  ->
  short,
  int,
  long,
  float,
  double
• short  ->
  int,
  long,
  float,
  double
• char  ->
  int,
  long,
  float,
  double
• int  ->
  long,
  float,
  double
• long  ->
  float,
  double
• float  ->
  double

Расширяющее преобразование не приводит к потере информации в следующих случаях:

• из целого типа в другой целый тип
• из
  byte,
  short, 
  char  в тип с плавающей точкой
• из
  int  в
  double
• из
  float  в
  double  в выражении с
  strictfp  (это такой особый режим вычислений с плавающей точкой, возможно, распишу позже).

Расширяющее преобразование из
float  в
double  в обычном режиме (без
strictfp ) может привести к потере точности.

Расширяющее преобразование 
int  во
float  или из
long  во
float, или из
long  в
double  может привести к потере точности, то есть результат может потерять несколько наименее значимых бит информации, что приведёт к получению округлённого значения.

Примеры расширяющего преобразования примитивов:

byte b1 = 100;
short sh2 = b1; // Расширяющее преобразование byte->short
char ch2 = 100;
int i1 = sh2; // Расширяющее преобразование short->int
int i2 = ch2; // Расширяющее преобразование char->int
long l1 = i1; // Расширяющее преобразование int->long
float f1 = l1; // Расширяющее преобразование long->float
double d1 = f1; // Расширяющее преобразование float->double

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

Сужающее преобразование примитивов

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

• short  ->
  byte,
  char
• char  ->
  byte ,
  short
• int  ->
  byte ,
  short ,
  char
• long  ->
  byte ,
  short ,
  char ,
  int
• float  ->
  byte ,
  short ,
  char ,

Типы данных в java

// Объявить переменнуюю с названием 'valid', вида boolean.
// Она будет иметь значение false (По умолчанию).
boolean valid;


// Объявить переменнуюю с названием 'active', вида boolean.
// Значение true.
boolean active = true;

double a = 2.5d;

// Так как double является видом по умолчанию для реальных чисел,
// Вы можете написать кратко:
double b = 2.5;

class Address  {
    String address;
    String cityName;
}

class Student {

   String fullName;

   int age;

   Address address;  
   
}

типов данных в Java — с примерами

Типы данных в Java , примитивные типы, переменные среды Java, Типы переменных в java с примерами и примерами программ.

Что такое типы данных в Java?

[wp_ad_camp_3]

Типы данных в Java: Перед тем, как использовать переменную , , мы должны указать, какой тип (тип данных) переменной это.

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

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

В Java целое число занимает 4 байта памяти , а двойное число — 8 байтов памяти.

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

Различные примитивные типы данных в Java

В Java у нас есть восемь основных (примитивных типов данных).

[wp_ad_camp_2]

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

1) БАЙТОВЫЙ ТИП ДАННЫХ В JAVA

Поскольку он занимает 1 байт памяти, мы можем сохранить значение от -128 до 127. Если мы попытаемся сохранить значение больше этого, мы получим ошибку компиляции.

Например:

• байт b = 25; действительно ✔
• байт c = 225; не действует ✕

Для работы с отдельными символами (значения ASCII до 127) мы можем использовать байтовый тип, поскольку он использует только 1 байт памяти (против char, который занимает 2 байта памяти).

2) КОРОТКИЙ ТИП В JAVA:

Используется для хранения целых чисел в диапазоне от -32768 до 32767 .Любое значение вне этого диапазона не может быть коротким. В этом случае мы должны использовать int. (В C short — это модификатор данных, а в Java short — это тип данных).

3) ВНУТРЕННИЙ ТИП ДАННЫХ В JAVA:

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

Мы можем использовать до 10-значного числа (почти до 200 крор) с типом int.

4) ДЛИННЫЙ ТИП В JAVA:

Когда мы хотим сохранить значение больше, чем диапазон int, мы должны использовать тип long.С long мы можем сохранить до 19-значного числа. (в C long — это модификатор данных, но в Java long — это тип данных).

При использовании константы, превышающей диапазон int, мы должны добавить к ней суффикс «l» или «L», чтобы указать, что это длинное значение.

Например: long a = 131009; в порядке

• длинный b = 12345678

  45; не штраф ✕

• длинный c = 12345678

  45L; в порядке ✔

5) ТИП СИМВОЛОВЫХ ДАННЫХ В JAVA:

В Java тип char занимает 2 байта памяти для поддержки символов UniCode (в C тип char составляет 1 байт, так как поддерживает только символы ASCII).Согласно UniCode у нас есть ”65536 (2 ¹⁶ )“ символов, пронумерованных от 0 до 65535. Тип char не может принимать отрицательные значения.

Числовой тип может принимать как положительные, так и отрицательные значения. Первые 256 (пронумерованные от 0 до 255) символа UniCode — это только набор символов ASCII. Итак, UniCode совместим с ASCII. Таким образом, как в ASCII, так и в UniCode «A» равно 65, «B» — 66, «C» — 67, «a» — 97, «b» — 98, «0» — 48, «1» — 49, \ n ‘равно 10,’ \ t ‘равно 9.

Например: символа a = 55; действительно ✔

• char b = ’A’; действительно ✔
• символа c = -35; не действует ✕

6) FLOAT DATATYPE IN JAVA

Типы данных в java

// Объявление переменной с именем 'valid', тип данных логический
// По умолчанию значение будет false.
логическое действительное;


// Объявляем переменную с именем 'active', тип данных логический
// Значение истинно.
логическое значение active = true;
 

// Вам нужно добавить L сразу после 100
// чтобы Java создала 8-байтовую область памяти для хранения 100
длинный а = 100л;
 

двойной a = 2,5d;

// Поскольку удвоение является типом по умолчанию для действительных чисел,
// Можно написать более кратко:
двойной b = 2,5;
 

class Address {
    Адрес строки;
    Строка cityName;
}

class Student {

   String fullName;

   int age;

   Адрес адрес;
   
}
 

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

Типы данных Java — числовые данные

Стр. 1 из 3

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

Современная Java
с NetBeans и Swing

Содержание

1. Почему именно Java?
2. Начало работы с Java
3. Введение в Java — объекты Swing
4. Написание кода
5. Программы командной строки
6. Пользовательский интерфейс — больше Swing
7. Работа с классом
8. Наследование класса Java
9. Типы данных Java — числовые данные
10. Типы данных Java — массивы и строки
11. Создание графического интерфейса Java — Контейнеры
12. Расширенный ООП — Тип, литье, пакеты
13. Значение и ссылка
14. Java-лямбды, SAM и события

Мы уже знаем о переменных и способах хранения данных, но нам нужно более внимательно изучить, с какими типами данных работает Java.Во многих отношениях необходимость учитывать «тип» данных — это что-то вроде возврата к ранним дням развития вычислений, когда мы очень тесно работали с тем, как данные были сохранены. В то время имело значение, какой объем хранилища вы использовали, и разные способы хранения одних и тех же данных использовались просто из соображений эффективности — зачем использовать два байта, когда подойдет один? Сегодня такие вопросы гораздо менее важны, но мы все еще работаем с базовыми типами данных, которые были представлены тогда.

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

Просто напишите меньше

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

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

Этот подход не работает для компьютера. Все в компьютере хранится в виде двоичного числа или последовательности битов, что еще более важно.Каждая ячейка памяти имеет фиксированное количество бит, и это точно ограничивает то, что вы можете хранить. Например, один байт данных состоит всего из восьми битов, и это означает, что вы можете сохранить последовательность битов, которую можно интерпретировать как число от 0 до 255, то есть от 00000000 до 11111111. Звучит нормально, но как насчет отрицательных чисел? Если вы хотите хранить отрицательные числа, вы должны отдать более половины диапазона отрицательным числам и половину положительным числам. То есть можно сказать, что от 0 до 127 — положительные значения, а от 128 до 255 — отрицательные значения, от -1 до -127.

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

Например, если вы используете один байт для хранения восьмибитной последовательности, вы можете использовать его для кодирования положительного числа от 0 до 255 и просто игнорировать возможность наличия отрицательных чисел. В качестве альтернативы вы можете рассматривать битовые последовательности как коды для букв алфавита от A до Z и от a до z плюс цифры и другие символы.В первом случае имеет смысл складывать и выполнять арифметические операции с последовательностями битов, но во втором случае действительно не имеет смысла добавлять битовый шаблон для A к битовому шаблону для a.

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

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

Теперь нам нужно познакомиться с некоторыми примитивными типами данных.

Номера

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

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

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

Когда вы храните целое число, вы можете использовать один, два, четыре или восемь байтов. Очевидно, что чем меньший объем памяти вы используете, тем меньший числовой диапазон вы можете использовать.

Стандартные целочисленные типы данных Java:

• байт 1 байт -128 до 127
• короткие 2 байта от -32768 до 32767
• int 4 байта от -2 147 483 648 до 2 147 483 647
• длинные 8 байтов от -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807

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

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

Используйте одно из других, если вы знаете, что числа, которые вы хотите использовать, будут вне диапазона int.

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

Чтобы объявить переменную одного из целочисленных типов, вы должны использовать форму:

тип переменная = начальное значение;

, где начальное значение необязательно.Например, чтобы объявить int, вы должны использовать

int myInteger = 100;

или

int myInteger;

Чтобы объявить байтовую переменную, вы должны использовать:

байт myByte = 127;

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

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

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

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

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

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

• с плавающей запятой 4 байта 7 десятичных цифр
• двойные 8 байтов 16 десятичных цифр

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

Как и в случае целочисленных типов, типы с плавающей запятой объявляются с использованием:

float myFloat = 0,123;
двойной myDouble = 0,123;

Обратите внимание, что типы с плавающей запятой не подходят для записи точных значений в большом диапазоне, например в валюте.

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

Также стоит знать, что, хотя числа отображаются в десятичном виде, когда вы их распечатываете, на самом деле они сохраняются в двоичном формате. Это действительно вызывает проблемы только тогда, когда мы используем десятичные дроби. Проблема в том, что в любой данной системе счисления некоторые дроби могут быть точно выражены, в то время как в других основаниях те же дроби не могут. Например, в десятичном формате вы можете сказать, что 1/10 — это 0,1, но 1/3 более проблематична, потому что это 0,33333 … повторяется бесконечно. Однако в двоичном формате 1/10 0.0001011101000101110 .. повторяется вечно. В большинстве случаев арифметика Java дает тот же результат, что и при работе с десятичными числами, но вы должны знать, что есть различия.