Результат арифметических операций int или long

Максимальные и минимальные по модулю значения

Пример хранения float 0.8125 = 0.5+0.25+0.0625

Операторы сравнения и неточность вещественной арифметики

951.26K

Категория:

Программирование

Похожие презентации:

Типы, переменные, управляющие инструкции. Обёртки примитивных типов. (Тема 2.4)

Типы, переменные, управляющие инструкции. (Тема 2.1)

Типы, переменные, управляющие инструкции. Ссылочные типы и переменные. (Тема 2.3)

Java.SE.01. Java fundamentals. Введение в язык java. Типы данных, переменные, операторы. Простейшие классы и объекты

Платформа и язык программирования Java

Введение в Java. Типы данных. Переменные

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

Java (level 1) - Опорный конспект

Кодировка ASCII. Управляющие символы ASCII

Начальный курс Java. (8 занятий)

Типы, переменные, управляющие инструкции. Примитивные типы. (Тема 2.2)

1.

II. Типы, переменные,
управляющие инструкции
2. Примитивные типы
1

Примитивный тип предопределён в языке и для него зарезервировано
ключевое слово. Всего существует 8 примитивных типов: булевский
примитивный тип boolean и 7 численных типов. Численные типы делятся на
целочисленные типы byte, short, char, int, long и вещественные типы float и
double.
Примитивы могут быть операндами операторов. Существует 1 оператор
присваивания, 12 арифметических операторов, 12 логических операторов, 6
операторов сравнения и 13 битовых операторов.
2

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

Тип
Размер
Мин. значение
Макс. значение
Значение по
умолчанию
byte
8 бит
-128
127
0
short
16 бит
-32,768
32,767
0
char
16 бит
'\u0000' (0)
'\uffff' (65535)
'\u0000'(0)
int
32 бита
-2,147,483,648
2,147,483,647
0
long
64 бита
-9,223,372,036,854,775,808
9,223,372,036,854,775,807
0L
float
32 бита
IEEE754
IEEE754
0.0f
double
64 бита
IEEE754
IEEE754
0.0d
boolean
-
-
-
false
3

4. Диапазоны значений и размер

public
public class
class RangeSizeDemo
RangeSizeDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
System.out.println("byte
System.out.println("byte
System.out.println("byte
System.out.println("byte
System.out.println("byte
System.out.println("byte
min:
min: "" ++ Byte.MIN_VALUE);
Byte.MIN_VALUE);
max:
max: "" ++ Byte.MAX_VALUE);
Byte.MAX_VALUE);
length:
length: "" ++ Byte.SIZE);
Byte.SIZE);
System.out.println("short
System.out.println("short
System.out.println("short
System.out.println("short
System.out.println("short
System.out.println("short
System.out.println("char
System.out.println("char
System.out.println("char
System.out.println("char
System.out.println("char
System.out.println("char
System.out.println("int
System.out.println("int
System.out.println("int
System.out.println("int
System.out.println("int
System.out.println("int
min:
min: "" ++ Short.MIN_VALUE);
Short.MIN_VALUE);
max:
"
+
Short.MAX_VALUE);
max: " + Short.MAX_VALUE);
length:
length: "" ++ Short.SIZE);
Short.SIZE);
min:
min: "" ++ (int)
(int) Character.MIN_VALUE);
Character.MIN_VALUE);
max:
max: "" ++ (int)
(int) Character.MAX_VALUE);
Character.MAX_VALUE);
length:
"
+
Character.SIZE);
length: " + Character.SIZE);
min:
min: "" ++ Integer.MIN_VALUE);
Integer.MIN_VALUE);
max:
max: "" ++ Integer.MAX_VALUE);
Integer.MAX_VALUE);
length:
length: "" ++ Integer.SIZE);
Integer.SIZE);
System.out.println("long
System.out.println("long min:
min: "" ++ Long.MIN_VALUE);
Long.MIN_VALUE);
System.out.println("long
System.out.println("long max:
max: "" ++ Long.MAX_VALUE);
Long.MAX_VALUE);
System.out.println("long
System.out.println("long length:
length: "" ++ Long.SIZE);
Long.SIZE);
System.out.println("float
System.out.println("float
System.out.println("float
System.out.println("float
System.out.println("float
System.out.println("float
}}
}}
min
min approx:
approx:
max
approx:
max approx:
length:
length: "" ++
System.out.println("double
System.out.println("double
System.out.println("double
System.out.println("double
System.out.println("double
System.out.println("double
"" ++ Float.MIN_VALUE);
Float.MIN_VALUE);
"" ++ Float.MAX_VALUE);
Float.MAX_VALUE);
Float.SIZE);
Float.SIZE);
min
min approx:
approx:
max
approx:
max approx:
length:
length: "" ++
"" ++ Double.MIN_VALUE);
Double.MIN_VALUE);
"" ++ Double.MAX_VALUE);
Double.MAX_VALUE);
Double.SIZE);
Double.SIZE);
4

5. Диапазоны значений и размер

byte
byte min:
min: -128
-128
byte
byte max:
max: 127
127
byte
byte length:
length: 88
short
short min:
min: -32768
-32768
short
max:
32767
short max: 32767
short
short length:
length: 16
16
char
char min:
min: 00
char
char max:
max: 65535
65535
char
length:
char length: 16
16
int
min:
-2147483648
int min: -2147483648
int
int max:
max: 2147483647
2147483647
int
int length:
length: 32
32
long
long min:
min: -9223372036854775808
-9223372036854775808
long
max:
9223372036854775807
long max: 9223372036854775807
long
long length:
length: 64
64
float
float min
min approx:
approx: 1.4E-45
1.4E-45
float
float max
max approx:
approx: 3.4028235E38
3.4028235E38
float
float length:
length: 32
32
double
min
approx:
double min approx: 4.9E-324
4.9E-324
double
max
approx:
1.7976931348623157E308
double max approx: 1.7976931348623157E308
double
double length:
length: 64
64
5

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

[byte|short|char|int|long|float|double|boolean]
[byte|short|char|int|long|float|double|boolean] variable
variable [[ == literal
literal || == expression
expression ];
];
Значения переменных примитивных типов хранятся по значению. Переменная
примитивного типа всегда содержит значение именно этого типа. При объявлении
переменная примитивного типа может быть сразу же инициализирована. Переменные
примитивных типов могут быть инициализированны примитивными литералами.
Примитивные литералы это значения примитивных типов в исходном коде программы. Для
примитивов существуют четыре вида литералов: целочисленные литералы, литералы с
плавающей точкой, символьные литералы и булевские литералы.
6

7. Примитивы и литералы

public
public class
class LiteralDemo
LiteralDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
String
String name
name == "Harry
"Harry Hacker";
Hacker";
char
gender
=
'm';
char gender = 'm';
boolean
boolean isMarried
isMarried == true;
true;
byte
byte numChildren
numChildren == 2;
2;
short
short yearOfBirth
yearOfBirth == 1987;
1987;
int
salary
=
30000;
int salary = 30000;
long
long netAsset
netAsset == 8234567890L;
8234567890L;
double
double weight
weight == 88.88;
88.88;
float
float gpa
gpa == 4.58f;
4.58f;
}}
}}
System.out.println("Name:
System.out.println("Name: "" ++ name);
name);
System.out.println("Gender:
"
+
System.out.println("Gender: " + gender);
gender);
System.out.println("Is
System.out.println("Is married:
married: "" ++ isMarried);
isMarried);
System.out.println("Number
System.out.println("Number of
of children:
children: "" ++ numChildren);
numChildren);
System.out.println("Year
System.out.println("Year of
of birth:
birth: "" ++ yearOfBirth);
yearOfBirth);
System.out.println("Salary:
"
+
salary);
System.out.println("Salary: " + salary);
System.out.println("Net
System.out.println("Net Asset:
Asset: "" ++ netAsset);
netAsset);
System.out.println("Weight:
System.out.println("Weight: "" ++ weight);
weight);
System.out.println("GPA:
System.out.println("GPA: "" ++ gpa);
gpa);
Name:
Name: Harry
Harry Hacker
Hacker
Gender:
Gender: mm
Is
Is married:
married: true
true
Number
Number of
of children:
children: 22
Year
Year of
of birth:
birth: 1987
1987
Salary:
30000
Salary: 30000
Net
Net Asset:
Asset: 8234567890
8234567890
Weight:
Weight: 88.88
88.88
GPA:
GPA: 4.58
4.58
7

8.

Булевский тип
8

9. Булевские литералы

Тип
Литерал
Пример
boolean
true
true
boolean
false
false
Булевские литералы имеют тип
boolean и могут использоваться
только
для
инициализации
переменных типа boolean. Есть всего
два булевских литерала true и false.
Тип boolean не имеет никакого
отношения к целочисленным типам.
Переменную типа boolean нельзя
инициализировать 0 или 1.
9

10. Булевы логические операторы

Оператор
Результат
&
Логическое и
|
Логическое или
^
Логическое исключающее или (XOR)
||
Логическое или быстрой оценки
&&
Логическое и быстрой оценки
!
Отрицание
&=
Логическое и с присваиванием
|=
Логическое или с присваиванием
^=
Логическое ислючающее или с
присваиванием
==
Равно
!=
Не равно
?:
Тернарный оператор if-then-else
У тернарного оператора первый операнд должен быть
boolean другие операнды и результат могут быть любого
типа. У других операторов операндами могут быть только
boolean. Результат тоже boolean.
10

11. Таблица истинности

public
public class
class TruthTableDemo
TruthTableDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
}}
System.out.println("L\tR\tAND\tOR\tXOR\tNOT");
System.out.println("L\tR\tAND\tOR\tXOR\tNOT");
printLine(true,
printLine(true, true);
true);
printLine(true,
printLine(true, false);
false);
printLine(false,
printLine(false, true);
true);
printLine(false,
printLine(false, false);
false);
static
static void
void printLine(boolean
printLine(boolean l,
l, boolean
boolean r)
r) {{
}}
}}
LL
true
true
true
true
false
false
false
false
System.out.println(l
System.out.println(l ++ "\t"
"\t" ++ rr ++ "\t"
"\t" ++ (l
(l && r)
r) ++ "\t"
"\t" ++ (l
(l || r)
r) ++ "\t"
"\t" ++ (l
(l ^^ r));
r));
RR
true
true
false
false
true
true
false
false
AND
AND
true
true
false
false
false
false
false
false
OR
OR
true
true
true
true
true
true
false
false
XOR
XOR
false
false
true
true
true
true
false
false
11

12.

Целочисленные типы
12

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

Тип
Суффикс
int
long
Пример
-123412
L или l
12341234123L
Целочисленные
литералы
без
суффикса (по умолчанию) имеют тип int
и
могут
использоваться
для
инициализации переменных типа byte,
short, char, int и long при условии что
значение
литерала
находится
в
диапазоне
значений
типа.
Целочисленные литералы с cуффиксом
L или l имеют тип long и могут быть
использованы
для
инициализации
переменных
типа
long.
Значение
литерала
должно
быть
в
соответствующем
диапазоне
иначе
произойдёт ошибка компиляции.
Система счисления
Префикс
десятичная
Пример
27
двоичная
0b
0b11011
восьмиричная
0
033
шестнадцатиричная
0x
0x1b
Необходимо помнить что целочисленный
литерал начинающийся с 0 это число в
восьмиричной системе.
Суффикс l использовать не следует. Его
легко перепутать с цифрой 1. Вместо
него следует использовать суффикс L.
13

14. Символьные литералы

Тип
Литерал
Описание
char
'\uxxxx'
Символ с кодом xxxx в кодировке Unicode
char
'X'
Символ X
Символьные литералы имеют тип char и
могут
использоваться
для
инициализации
целочисленных
переменных при условии что значение
литерала
находится
в
диапазоне
значений типа.
Литерал
Значение
Эквивалент
'\b'
возврат каретки
'\u0008'
'\t'
табулятор
'\u0009'
'\n'
переход строки
'\u000A'
'\f'
подача бланка
'\u000C'
'\r'
возврат каретки
'\u000D'
'\"'
двойная кавычка
'\u005C'
'\''
одинарная кавычка
'\u0027'
'\\'
обратная косая черта
'\u0022'
14

15. Преобразования целочисленных типов

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

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

public
public class
class ByteIntConversionDemo
ByteIntConversionDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
int
int xInt;
xInt;
byte
byte xByte;
xByte;
System.out.println("Implicit
System.out.println("Implicit conversion
conversion byte
byte to
to int
int ...");
...");
xByte
xByte == 100;
100;
xInt
=
xByte;
xInt = xByte;
System.out.println("xByte
System.out.println("xByte variable's
variable's value:
value: "" ++ xByte);
xByte);
System.out.println("xInt
System.out.println("xInt variable's
variable's value:
value: "" ++ xInt);
xInt);
System.out.println("\nNow
System.out.println("\nNow explicit
explicit conversion
conversion int
int to
to byte
byte ...");
...");
xInt
xInt == 150;
150;
xByte
xByte == (byte)
(byte) xInt;
xInt;
}}
}}
System.out.println("xInt
System.out.println("xInt variable's
variable's value:
value: "" ++ xInt);
xInt);
System.out.println("xByte
System.out.println("xByte variable's
variable's value:
value: "" ++ xByte);
xByte);
Implicit
Implicit conversion
conversion byte
byte to
to int
int ...
...
xByte
variable's
value:
100
xByte variable's value: 100
xInt
xInt variable's
variable's value:
value: 100
100
Now
Now explicit
explicit conversion
conversion int
int to
to byte
byte ...
...
xInt
variable's
value:
150
xInt variable's value: 150
xByte
xByte variable's
variable's value:
value: -106
-106
16

17. Арифметические операторы

Оператор
Результат
+
Сложение (унарный плюс)
-
Вычитание (унарный минус)
*
Умножение
/
Деление
%
Модуль от деления
++
Инкремент
+=
Сложение с присваиванием
-=
Вычитание с присваиванием
*=
Умножение с присваиванием
/=
Деление с присваиванием
%=
Модуль от деления с присваиванием
--
Декремент
Если операнды целочисленных типов кроме long то они
все приводятся к int и результат тоже будет int. Если
операнды целочисленных типов и один из них long то
результат будет long. Переполнение целочисленных типов
маскируется.
17

18. Результат арифметических операций int

public
public class
class ByteDemo
ByteDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
byte
byte aa == 10;
10;
byte
byte bb == 20;
20;
byte
byte cc == (byte)
(byte) (a
(a ++ b);
b);
}}
}}
System.out.println("And
System.out.println("And the
the result
result is:
is: "" ++ c);
c);
And
And the
the result
result is:
is: 30
30
18

19. Маскировка переполнения целых чисел

public
public class
class SilentOverflowDemo
SilentOverflowDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
int
int posint
posint == 2147483647;
2147483647;
System.out.println("number
System.out.println("number is:
is: "" ++ posint);
posint);
System.out.println("number
System.out.println("number ++ 11 is:
is: "" ++ (posint
(posint ++ 1));
1));
System.out.println();
System.out.println();
int
int negint
negint == -2147483648;
-2147483648;
}}
}}
System.out.println("number
System.out.println("number
System.out.println("number
System.out.println("number
number
number
number
number
is:
is:
++ 11
is:
is:
-- 11
"" ++
is:
is:
negint);
negint);
"" ++ (negint
(negint -- 1));
1));
2147483647
2147483647
is:
is: -2147483648
-2147483648
number
number is:
is: -2147483648
-2147483648
number
number -- 11 is:
is: 2147483647
2147483647
19

20. Маскировка переполнения целых чисел

21. Маскировка переполнения целых чисел

22. Маскировка переполнения целых чисел

23. Маскировка переполнения целых чисел

24. Результат арифметических операций int или long

public
public class
class ResultOverflowDemo
ResultOverflowDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
long
long yearMilliseconds
yearMilliseconds == 1000
1000 ** 365
365 ** 24
24 ** 60
60 ** 60;
60;
System.out.println("Wrong
System.out.println("Wrong number
number of
of milliseconds
milliseconds per
per year:
year: "" ++ yearMilliseconds);
yearMilliseconds);
yearMilliseconds
yearMilliseconds == 1000L
1000L ** 365
365 ** 24
24 ** 60
60 ** 60;
60;
System.out.println("Correct
System.out.println("Correct number
number of
of milliseconds
milliseconds per
per year:
year: "" ++ yearMilliseconds);
yearMilliseconds);
}}
}}
Wrong
Wrong number
number of
of milliseconds
milliseconds per
per year:
year: 1471228928
1471228928
Correct
Correct number
number of
of milliseconds
milliseconds per
per year:
year: 31536000000
31536000000
24

25. Результат арифметических операций int или long

public
public class
class ResultOverflowVarDemo
ResultOverflowVarDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
int
int
int
int
int
int
int
int
int
int
millis
millis == 1000;
1000;
days
days == 365;
365;
hours
hours == 24;
24;
minutes
minutes == 60;
60;
seconds
seconds == 60;
60;
long
long yearMilliseconds
yearMilliseconds == (long)(millis
(long)(millis ** days
days ** hours
hours ** minutes
minutes ** seconds);
seconds);
System.out.println("Wrong
System.out.println("Wrong conversion
conversion int
int to
to long
long variable
variable :: "" ++ yearMilliseconds);
yearMilliseconds);
}}
}}
yearMilliseconds
yearMilliseconds == (long)(millis)
(long)(millis) ** days
days **
System.out.println("Correct
System.out.println("Correct conversion
conversion int
int
Wrong
Wrong conversion
conversion int
int to
to long
long variable
variable ::
Correct
Correct conversion
conversion int
int to
to long
long variable
variable
hours
hours **
to
to long
long
minutes
minutes ** seconds;
seconds;
variable
:
variable : "" ++ yearMilliseconds);
yearMilliseconds);
1471228928
1471228928
:: 31536000000
31536000000
25

26. Деление на ноль

public
public class
class ArithmeticExceptionDemo
ArithmeticExceptionDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
int
int aa == 10;
10;
int
int bb == 0;
0;
System.out.println("We
System.out.println("We will
will try
try to
to divide
divide "" ++ aa ++ "" by
by "" ++ b);
b);
System.out.println(a
System.out.println(a // b);
b);
}}
}}
We
We will
will try
try to
to divide
divide 10
10 by
by 00
Exception
Exception in
in thread
thread "main"
"main" java.lang.ArithmeticException:
java.lang.ArithmeticException: // by
by zero
zero
at
at primitives.ArithmeticExceptionDemo.main(ArithmeticExceptionDemo.java:11)
primitives.ArithmeticExceptionDemo.main(ArithmeticExceptionDemo.java:11)
26

27. Операторы сравнения и упорядоченности

Оператор
Результат
==
Равно
!=
Не равно
>
Больше
<
Меньше
>=
Больше или равно
<=
Меньше или равно
Операнды могут быть любых целочисленных типов.
Результатом операции сравнения или упорядоченности
всегда будет boolean.
27

28. Битовые целочисленные операторы

Оператор
Результат
~
Битовый унарный не
&
Битовый и
|
Битовый или
^
Битовый исключающий или (XOR)
>>
Сдвиг вправо
>>>
Сдвиг вправо с заполнением нулями
<<
Сдвиг влево
&=
Битовый и с присваиванием
|=
Битовый или с присваиванием
^=
Битовый ислючающий или с присваиванием
>>=
Сдвиг вправо с присваиванием
>>>=
Сдвиг вправо с присваиванием с заполнением нулями
28

29.

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

30. Вещественные литералы

Тип
Суффикс
Пример
Пример
float
F или f
-123.412F
-1.23412e+2F
double
D или d
123412.34123D
1.2341234123e+5D
Вещественные литералы без суффикса (по
умолчанию) или с суффиксом D или d имеют
тип double и могут использоваться для
инициализации переменных типа double.
Вещественные литералы с cуффиксом F или f
имеют тип float и могут быть использованы для
инициализации переменных типа float или типа
double. Значение литерала должно быть в
соответствующем диапазоне иначе произойдёт
ошибка компиляции.
30

31. Максимальные и минимальные по модулю значения

Тип
Размер
Минимальные по модулю значения
Максимальные по модулю значения
float
32 бита
2-149 ≈ ±1.40129846432481707e-45
(2-2-23)·2127 ≈ ±3.40282346638528860e+38
double
64 бита
2-1074 ≈ ±4.9406564584124654e-324
(2-2-52)·21023 ≈ ±1.7976931348623157e+308
31

32. Специальные значения

Значение
Размер
Infinity
Положительное значение по модулю больше
максимального значения по модулю
-Infinity
Отрицательное значение по модулю больше
максимального значения по модулю
0
Положительное значение по модулю меньше
минимального значения по модулю
-0
Отрицательное значение по модулю меньше
минимального значения по модулю
NaN
Не число - результат операций не имеющих
смысла
32

33. Специальные значения

public
public class
class SpecialValuesDemo
SpecialValuesDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
double
double max
max == Double.MAX_VALUE;
Double.MAX_VALUE;
double
double min
min == Double.MIN_VALUE;
Double.MIN_VALUE;
System.out.println("Maximum
System.out.println("Maximum double
double value
value approximately
approximately is:
is: "" ++ max);
max);
System.out.println("Minimum
System.out.println("Minimum positive
positive double
double value
value approximately
approximately is:
is: "" ++ min);
min);
System.out.println("Positive
infinity
is:
"
+
max
*
2);
System.out.println("Positive infinity is: " + max * 2);
System.out.println("Positive
System.out.println("Positive zero
zero is:
is: "" ++ min
min // 2);
2);
System.out.println("Negative
System.out.println("Negative infinity
infinity is:
is: "" ++ (-max
(-max ** 2));
2));
System.out.println("Negative
System.out.println("Negative zero
zero is:
is: "" ++ (-min
(-min // 2));
2));
}}
}}
System.out.println("Not
System.out.println("Not aa number:
number: "" ++ Math.sqrt(-1));
Math.sqrt(-1));
Maximum
Maximum double
double value
value approximately
approximately is:
is: 1.7976931348623157E308
1.7976931348623157E308
Minimum
Minimum positive
positive double
double value
value approximately
approximately is:
is: 4.9E-324
4.9E-324
Positive
Positive infinity
infinity is:
is: Infinity
Infinity
Positive
zero
is:
0.0
Positive zero is: 0.0
Negative
Negative infinity
infinity is:
is: -Infinity
-Infinity
Negative
Negative zero
zero is:
is: -0.0
-0.0
Not
Not aa number:
number: NaN
NaN
33

34. Преобразования

Допускается неявное преобразование float в double и явное преобразование double
в float. Допускается неявное преобразование любого целочисленного типа в float и
double и явное преобразование float и double в целочисленные типы. Неявное
преобразование long в float и double, а также неявное преобразование int в float
могут привести к потере точности.
34

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

public
public class
class IntDoubleConversionDemo
IntDoubleConversionDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
int
int xInt;
xInt;
double
double xDouble;
xDouble;
System.out.println("Implicit
System.out.println("Implicit conversion
conversion int
int to
to double
double ...");
...");
xInt
xInt == 120;
120;
xDouble
xDouble == xInt;
xInt;
System.out.println("xInt
System.out.println("xInt variable's
variable's value:
value: "" ++ xInt);
xInt);
System.out.println("xDouble
System.out.println("xDouble variable's
variable's value:
value: "" ++ xDouble);
xDouble);
System.out.println("\nNow
System.out.println("\nNow explicit
explicit conversion
conversion double
double to
to int
int ...");
...");
xDouble
xDouble == 3.8547;
3.8547;
xInt
xInt == (int)
(int) xDouble;
xDouble;
System.out.println("xDouble
System.out.println("xDouble variable's
variable's value:
value: "" ++ xDouble);
xDouble);
System.out.println("xInt
System.out.println("xInt variable's
variable's value:
value: "" ++ xInt);
xInt);
}}
}}
Implicit
Implicit conversion
conversion int
int to
to double
double ...
...
xInt
variable's
value:
120
xInt variable's value: 120
xDouble
xDouble variable's
variable's value:
value: 120.0
120.0
Now
Now explicit
explicit conversion
conversion double
double to
to int
int ...
...
xDouble
variable's
value:
3.8547
xDouble variable's value: 3.8547
xInt
xInt variable's
variable's value:
value: 33
35

36. Арифметические операторы

Оператор
Результат
Операция
Результат
+
Сложение (унарный плюс)
Math.sqrt(-1.0)
NaN
-
Вычитание (унарный минус)
0.0 / 0.0
NaN
*
Умножение
1.0 / 0.0
Infinity
Деление
-1.0 / 0.0
-Infinity
Модуль от деления
NaN + 1.0
NaN
++
Инкремент
Infinity + 1.0
Infinity
+=
Сложение с присваиванием
Infinity + Infinity
Infinity
-=
Вычитание с присваиванием
*=
Умножение с присваиванием
/=
Деление с присваиванием
%=
Модуль от деления с присваиванием
--
Декремент
/
%
Вещественная арифметика как и хранение
вещественных чисел не является точной.
Для точных финансовых вычислений
необходимо использовать тип BigDecimal.
Если оба операнда вещественные и хотя бы один из них double
то результат будет double в противном случае результат будет
float. Если один операнд вещественный а
другой
целочисленный то целочисленный операнд будет приведён к
типу вещественного операнда и результат будет типа
вещественного операнда.
36

37. Неточность вещественной арифметики

public
public class
class ImprecisionDemo
ImprecisionDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) {{
System.out.println(0.1);
System.out.println(0.1);
System.out.println(0.1
System.out.println(0.1 ++ 0.1);
0.1);
System.out.println(0.1
System.out.println(0.1 ++ 0.1
0.1 ++ 0.1);
0.1);
}}
}}
0.1
0.1
0.2
0.2
0.30000000000000004
0.30000000000000004
Такого вещественного значения как
0.1 не существует. Это связано с тем
как вещественные числа float и
double представляются в памяти.
Кроме того арифметика не является
точной.
37

38. Как хранятся числа с плавающей точкой

39. Пример хранения float 0.8125 = 0.5+0.25+0.0625

(-1)s × (1+m) × 2(e
0.8125 = (-1)0 × (1 +
bits:
31 30-23
binary: 0 01111110
decimal: 0 126
2e-127(1
2-1(1 +
2-1(1 +
2-1(1 +
- 127)
0.5 + 0.125) × 2-1
22-0
10100000000000000000000
5242880
+ m / 223) =
(0.5 + 0.125)) =
5242880/8388608) =
0.625) = 0.8125
Значение разряда в бинарной
записи может быть 0 или 1. Первая
1 не хранится в мантиссе так как
значение первого разряда всегда 1.
39

40. Пример хранения float 0.085

(-1)s × (1+m) × 2(e
0.085:
bits:
31
binary: 0
decimal: 0
30-23
01111011
123
- 127)
22-0
01011100001010001111011
3019899
2e-127(1 + m / 223) =
2-4(1 + (0.25 + 0.0625 + 0.03125 + ...)) =
2-4(1 + 3019899/8388608) =
11408507/134217728 =
0.085000000894069671630859375
40

41. Операторы сравнения и упорядоченности

Оператор
Результат
Операция
Результат
==
Равно
NaN > 1.0
false
!=
Не равно
NaN == 1.0
false
>
Больше
NaN < 1.0
false
<
Меньше
NaN == NaN false
>=
Больше или равно
0.0 == -0.0
<=
Меньше или равно
true
Операнды могут быть любых численных типов.
Результатом операции сравнения или упорядоченности
всегда будет boolean.
41

42. Операторы сравнения и неточность вещественной арифметики

public
public class
class NeverEndingDemo
NeverEndingDemo {{
public
public static
static void
void main(String[]
main(String[] args)
args) throws
throws InterruptedException{
InterruptedException{
for
for (double
(double xx == 0;
0; xx !=
!= 10;
10; xx +=
+= 0.1)
0.1) {{
}}
}}
}}
System.out.println(x);
System.out.println(x);
Thread.sleep(1000);
Thread.sleep(1000);
9.099999999999984
9.099999999999984
9.199999999999983
9.199999999999983
9.299999999999983
9.299999999999983
9.399999999999983
9.399999999999983
9.499999999999982
9.499999999999982
9.599999999999982
9.599999999999982
9.699999999999982
9.699999999999982
9.799999999999981
9.799999999999981
9.89999999999998
9.89999999999998
9.99999999999998
9.99999999999998
10.09999999999998
10.09999999999998
10.19999999999998
10.19999999999998
10.29999999999998
10.29999999999998
10.399999999999979
10.399999999999979
10.499999999999979
10.499999999999979
10.599999999999978
10.599999999999978
...
...
42

English Русский Правила