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

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

Все типы исходных данных, встроенные в язык Java, делятся на две группы: примитивные типы (primitive types) и ссылочные типы (reference types).

Ссылочные типы делятся на массивы (arrays), массы (classes) и интерфейсы (interfaces).

Примитивных типов всего восемь. Их можно разделить на логический (иногда говорят булев) тип boolean и числовые (numeric).

К числовым типам относятся целые (integral [Название «integral» не является устоявшимся термином. Так названа категория целых типов данных в книге The Java Language Specification, Second Edition. James Gosling, Bill Joy, Guy Steele, Gilad Bracha (см. введение). — Ред.]) и вещественные (floating-point) типы.

Целых типов пять: byte , short , int , long , char .

Символы можно использовать везде, где используется тип int , поэтому JLS причисляет их к целым типам. Например, их можно использовать в арифметических вычислениях, скажем, можно написать 2 + ‘ж‘ , к двойке будет прибавляться кодировка Unicode ‘\u04i6‘ буквы ‘ж‘ . В десятичной форме это число 1046 и в результате сложения получим 1048.

Напомним, что в записи 2 + «Ж» плюс понимается как сцепление строк, двойка будет преобразована в строку, в результате получится строка «2ж» .

Вещественных типов два: float и double .

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

Замечание для специалистов

Java — язык со строгой типизацией (strongly typed language).

Разберем каждый тип подробнее.

Логический тип

Значения логического типа boolean возникают в результате различных сравнений, вроде 2 > з, и используются, главным образом, в условных операторах и операторах циклов. Логических значении всего два: true (истина) и false (ложь). Это служебные слова Java. Описание переменных этого типа выглядит так:

boolean b = true, bb = false, bool2;

Над логическими данными можно выполнять операции присваивания, например, bool2 = true , в том числе и составные с логическими операциями; сравнение на равенство b == bb и на неравенство b != bb , а также логические операции.

Логические операции

Логические операции:

отрицание (NOT) ! (обозначается восклицательным знаком);
конъюнкция (AND) & (амперсанд);
дизъюнкция (OR) | (вертикальная черта);
исключающее ИЛИ (XOR) ^ (каре).

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

Таблица 1.1. Логические операции

b1	b2	!b1	b1&b2	b1\|b2	b1^b2
true	true	false	true	true	false
true	false	false	false	true	true
false	true	true	false	true	true
false	false	true	false	false	false

Словами эти правила можно выразить так:

отрицание меняет значение истинности;
конъюнкция истинна, только если оба операнда истинны;
дизъюнкция ложна, только если оба операнда ложны;
исключающее ИЛИ истинно, только если значения операндов различны.

Замечание

Если бы Шекспир был программистом, фразу «То be or not to be» он написал бы так: 2b | ! 2b.

Кроме перечисленных четырех логических операций есть еще две логические операции сокращенного вычисления:

сокращенная конъюнкция (conditional-AND) && ;
сокращенная дизъюнкция (conditional-OR) || .

Удвоенные знаки амперсанда и вертикальной черты следует записывать без пробелов.

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

Это правило очень удобно и ловко используется, например, можно записывать выражения (n != 0) && (m/n > 0.001) или (n == 0) || (m/n > 0.001) не опасаясь деления на нуль.

Замечание

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

Целые типы

Спецификация языка Java, JLS, определяет разрядность (количество байтов, выделяемых для хранения значений типа в оперативной памяти) и диапазон значений каждого типа. Для целых типов они приведены в табл. 1.2.

Таблица 1.2. Целые типы

Тип	Разрядность (байт)	Диапазон
byte	1	от -128 до 127
short	2	от -32768 до 32767
int	4	от -2147483648 до 2147483647
long	8	от -9223372036854775808 до 9223372036854775807
char	2	от ‘\u0000’ до ‘\uFFFF’ , в десятичной форме от 0 до 65535

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

Хотя тип char занимает два байта, в арифметических вычислениях он участвует как тип int , ему выделяется 4 байта, два старших байта заполняются нулями.

Примеры определения переменных целых типов:

byte b1 = 50, b2 = -99, bЗ;

short det = 0, ind = 1;

int i = -100, j = 100, k = 9999;

long big = 50, veryBig = 2147483648L;

char c1 = ‘A’, c2 = ‘?’, newLine = ‘\n’;

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

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

Например, значение 50 переменной b1 , определенной выше, будет храниться в одном байте с содержимым 00110010 , а значение -99 переменной b2 — в байте с содержимым, которое вычисляем так: число 99 переводим в двоичную форму, получая 01100011 , меняем единицы и нули, получая 10011100 , и прибавляем единицу, получив окончательно байт с содержимым 10011101 .

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

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

Вещественные типы

Вещественных типов в Java два: float и double. Они характеризуются разрядностью, диапазоном значений и точностью представления, отвечающим стандарту IEEE 754-1985 с некоторыми изменениями. К обычным вещественным числам добавляются еще три значения»

1. Положительная бесконечность, выражаемая константой POSITIVE_INFINITY и возникающая при переполнении положительного значения, например, в результате операции умножения 3.0*6е307.

2. Отрицательная бесконечность NEGATIVE_INFINITY .

3. «Не число», записываемое константой NaN (Not a Number) и возникающее при делении вещественного числа на нуль или умножении нуля на бесконечность.

В главе 4 мы поговорим о нихподробнее.

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

Операции с бесконечностями выполняются по обычным математическим правилам.

Во всем остальном вещественные типы — это обычные, вещественные значения, к которым применимы все арифметические операции и сравнения, перечисленные для целых типов. Характеристики вещественных типов приведены в табл. 1.4.

Знатокам C/C++

В языке Java взятие остатка*от деления %, инкремент ++ и декремент — применяются и к вещественным типам.

Таблица 1.3. Вещественные типы

Тип	Разрядность	Диапазон	Точность
float	4	3,4е-38 < \|х\| < 3,4е38	7—8 цифр
double	8	1,7е-308<\|х\|<1,7е308	17 цифр

Примеры определения вещественных типов:

float х = 0.001, у = -34.789;

double 21 = -16.2305, z2;

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

если в операции один операнд имеет тип double, то и другой приводится к типу double;
если один операнд имеет тип float, то и другой приводится к типу float;
в противном случае действует правило приведения целых значений.

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

Простоя операция присваивания (simple assignment operator) записывается знаком равенства =, слева от которого стоит переменная, а справа выражение, совместимое с типом переменной:

х = 3.5, у = 2 * (х — 0.567) / (х + 2), b = х < у, bb = х >= у && b.

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

Операция присваивания имеет еще одно, побочное, действие: переменная, стоящая слева, получает приведенное значение правой части, старое ее значение теряется.

В операции присваивания левая и правая части неравноправны, нельзя написать 3.5 = х. После операции х = у изменится переменная х, став равной у, а после у = х изменится у.

Кроме простой операции присваивания есть еще 11 составных операций присваивания (compound assignment operators):

+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= _;>>>=.

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

Все составные операции присваивания действуют по одной схеме:

х ор= а эквивалентно х = (тип х), т. е. (х ор а).

Напомним, что переменная ind типа short определена у нас со значением 1. Присваивание ind +=7.8 даст в результате число 8, то же значение получит и переменная ind. Эта операция эквивалентна простой операции присваивания ind = (short)(ind + 7.8).

Перед присваиванием, при необходимости, автоматически производится приведение типа. Поэтому:

byte b = 1;

b = b + 10; // Ошибка!

b += 10; // Правильно!

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

Условная операция

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

х < 0 ? 0 : х

х > у ? х — у : х + у

Условная операция выполняется так. Сначала вычисляется логическое выражение. Если получилось значение true, то вычисляется первое выражение после вопросительного знака ? и его значение будет результатом всей операции. Последнее выражение при этом не вычисляется. Если же получилось значение false, то вычисляется только последнее выражение, его значение будет результатом операции.

Это позволяет написать n == о ? да : m / n не опасаясь деления на нуль. Условная операция поначалу кажется странной, но она очень удобна для записи небольших разветвлений.

Операции над целыми типами

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

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

К арифметическим операциям относятся:

сложение + (плюс);
вычитание — (дефис);
умножение * (звездочка);
деление / (наклонная черта — слэш);
взятие остатка от деления (деление по модулю) % (процент);
инкремент (увеличение на единицу) ++ ;
декремент (уменьшение на единицу) —

Между сдвоенными плюсами и минусами нельзя оставлять пробелы. Сложение, вычитание и умножение целых значений выполняются как обычно, а вот деление целых значений в результате дает опять целое (так называемое «целое деление»), например, 5/2 даст в результате 2 , а не 2.5 , а 5/(-3) даст -1 . Дробная часть попросту отбрасывается, происходит усечение частного. Это поначалу обескураживает, но потом оказывается удобным для усечения чисел.

Замечание

В Java принято целочисленное деление.

Это странное для математики правило естественно для программирования: если оба операнда имеют один и тот же тип, то и результат имеет тот же тип. Достаточно написать 5/2.0 или 5.0/2 или 5.0/2.0 и получим 2.5 как результат деления вещественных чисел.

Операция деление по модулю определяется так: а % b = а — (а / b) * b ; например, 5%2 даст в результате 1 , а 5% (-3) даст, 2 , т.к. 5 = (-3) * (-1) + 2 , но (-5)%3 даст -2 , поскольку -5 = 3 * (-1) — 2 .

Операции инкремент и декремент означают увеличение или уменьшение значения переменной на единицу и применяются только к переменным, но не к константам или выражениям, нельзя написать 5++ или (а + b)++ .

Например, после приведенных выше описаний i++ даст -99 , a j—— даст 99 .

Интересно, что эти операции ‘можно записать и перед переменной: ++i , — j . Разница проявится только в выражениях: при первой формe записи (постфиксной) в выражении участвует старое значение переменной и только потом происходит увеличение или уменьшение ее значения. При второй форме записи (префиксной) сначала изменится переменная и ее новое значение будет участвовать в выражении.

Например, после приведенных выше описаний, (k++) + 5 даст в результате 10004 , а переменная k примет значение 10000 . Но в той же исходной ситуации (++k) + 5 даст 10005 , а переменная k станет равной 10000 .

2. Приведение типов

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

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

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

Листинг 1.3. Неверное определение переменной

class InvalidDef{

public static void main (String [] args) {

byte b1 = 50, b2 = -99;

short k = b1 + b2; // Неверно! ‘

System.out.println(«k=» + k);

}

Эти сообщения означают, что в файле InvalidDef.java, в строке 4, обнаружена возможная потеря точности (possible loss of precision). Затем приводятся обнаруженный (found) и нужный (required) типы, выводится строка, в которой обнаружена (а не сделана) ошибка, и отмечается символ, при разборе которого найдена ошибка. Затем указано общее количество обнаруженных (а не сделанных) ошибок (1 error).

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

short k = (short)(b1 + b2) ;

будет верным.

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

byte b = (byte) 300;

даст переменной b значение 44 . Действительно, в двоичном представлении числа 300 , равном 100101100 , отбрасывается старший бит и получается 00101100 .

Таким же образом можно произвести и явное расширение (widening) типа, если в этом есть необходимость. .

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

Замечание

В языке Java нет целочисленного переполнения.

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

В языке Java шесть обычных операций сравнения целых чисел по величине:

больше > ;
меньше < ;
больше или равно >= ;
меньше или равно <= ;
равно == ;
не равно != .

Сдвоенные символы записываются без пробелов, их нельзя переставлять местами, запись => будет неверной.

Результат сравнения — логическое значение: true , в результате, например, сравнения 3 != 5 ; или false , например, в результате сравнения 3 == 5 .

Для записи сложных сравнений следует привлекать логические.операции. Например, в вычислениях часто приходится делать проверки вида а < х < b . Подобная запись на языке Java приведет к сообщению об ошибке, поскольку первое сравнение, а < х , даст true или false , a Java не знает, больше это, чем b , или меньше. В данном случае следует написать выражение (а < х) && (х < b) , причем здесь скобки можно опустить, написать просто а < х && х < b , но об этом немного позднее.

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

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

дополнение (complement) ~ (тильда);
побитовая конъюнкция (bitwise AND) & ;
побитовая дизъюнкция (bitwise OR) | ;
побитовое исключающее ИЛИ (bitwise XOR) ^ .

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

Таблица 1.4. Побитовые операции

nl	n2	~nl	nl & n2	nl \| n2	nl ^ n2
1 1 0 0	1 0 1 0	0 0 1 1	1 0 0 0	1 1 1 0	0 1 1 0

В нашем примере b1 == 50 , двоичное представление 00110010, b2 == -99 , двоичное представление 10011101 . Перед операцией происходит повышение до типа int . Получаем представления из 32-х разрядов для b1 — 0…00110010 , для b2 — 1…l0011101 . В результате побитовых операций получаем:

~b2 == 98 , двоичное представление 0…01100010 ;
b1 & b2 == 16 , двоичное представление 0…00010000 ;
b1 | b2 == -65 , двоичное представление 1…10111111 ;
b1 ^ b2 == -81 , двоичное представление 1…10101111 .

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

Заметьте, что дополнение ~х всегда эквивалентно (-x)-1 .

5. Сдвиги

В языке Java есть три операции сдвига двоичных разрядов:

сдвиг влево <<;
сдвиг вправо >>;
беззнаковый сдвиг вправо >>>.

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

Например, операция b1<< 2 сдвинет влево на 2 разряда предварительно повышенное значение 0…00110010 переменной b1, что даст в результате 0…011001000, десятичное 200. Освободившиеся справа разряды заполняются нулями, левые разряды, находящиеся за 32-м битом, теряются.

Операция b2 << 2 сдвинет повышенное значение 1…10011101 на два разряда влево. В результате получим 1…1001110100, десятичное значение —396.

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

Операция b1 >> 2 даст в результате 0…00001100, десятичное 12, а b2 >> 2 — результат 1..11100111, десятичное -25, т. е. слева распространяется старший бит, правые биты теряются. Это так называемый арифметический сдвиг.

Операция беззнакового сдвига во всех случаях ставит слева на освободившиеся места нули, осуществляя логический сдвиг. Но вследствие предварительного повышения это имеет эффект только для нескольких старших разрядов отрицательных чисел. Так, b2 >>> 2 имеет результатом 001…100111, десятичное число 1 073 741 799.

Если же мы хотим получить логический сдвиг исходного значения loomoi переменной b2, т. е., 0…00100111, надо предварительно наложить на b2 маску, обнулив старшие биты: (b2 & 0XFF) >>> 2.

Замечание

Будьте осторожны при использовании сдвигов вправо.