Float java что это

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

Числа с плавающей точкой (или действительные числа) представлены типами float и double. Используются для хранения значений с точностью до определенного знака после десятичной точки.

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

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

Пример объявления типов с плавающей точкой:

double d1 = 3.45; float f1 = 34.456f;

Тип	Размер в байтах	Размер в битах	Возможные значения (от..до)	Значение по умолчанию
float	4	32	-3.4E+38..3.4E+38 (стандарт IEEE 754)	0.0
double	8	64	-1.7E+308..1.7E+308 (стандарт IEEE 754)	0.0

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

• Положительная бесконечность — результат деления положительного числа на 0. Представлены константами Double.POSITIVE_INFINITY и Float.POSITIVE_INFINITY .
• Отрицательная бесконечность — результат деления отрицательного числа на 0. Представлены константами Double.NEGATIVE_INFINITY и Float.NEGATIVE_INFINITY.
• NaN (не число) — вычисление 0/0 или извлечение квадратного корня из отрицательного числа. Представлены константами Double.NaN и Float.NAN .

Пример использования специальных чисел с плавающей точкой в арифметических выражениях:

public class Main < public static void main(String[] args) < int a = 7; double b = 0.0; double c = -0.0; double g = Double.NEGATIVE_INFINITY; System.out.println(a / b); System.out.println(a / c); System.out.println(b == c); System.out.println(g * 0); >>

Числа с плавающей точкой нельзя использовать в финансовых расчетах, где ошибки округления недопустимы. Например, в результате выполнения оператора System.out. println(2.0 — 1.1) будет выведено значение 0.8999999999999999, а не 0.9, как было бы логично предположить. Подобные ошибки связаны с внутренним двоичным представлением чисел. Как в десятичной системе счисления нельзя точно представить результат деления 1/3, так и в двоичной системе невозможно точно представить результат деления 1/10. Если же требуется исключить ошибки округления, то следует воспользоваться классом BigDecimal .

Презентацию с видео можно скачать на Patreon .

• Пробелы
• Идентификаторы
• Правила именования переменных
• Комментарии
• Разделители
• Ключевые слова
• Примитивные типы данных
• Тип данных char
• Типы byte, short, int, long
• Тип данных boolean
• Литералы
• Методы
• Переменные
• Прямой код и дополнительный код
• Преобразование и приведение примитивных типов
• Ввод с клавиатуры
• Задания

Типы данных с плавающей точкой: float и double — введение в Java 003 #

Для хранения дробных чисел в Java используют float и double. Правильное название — простые (примитивные) типы данных с плавающей точкой. Примитивные типы данных — byte, short, int, long, которые являются целыми числами, — мы рассматривали — здесь.

Float #

Давайте сразу рассмотрим практический пример:

public class TestFloat   public static void main(String[] args)   float a = 3.5f;  float b = 4.5F;  float c = (float) 5.5;  float d = a + b + c;  System.out.println("a+b+c: " + d);  > > 

Здесь использованы три способа объявления переменных типа float. Самое важное при работе с ними — избавится от “запятых”. Java — американский язык программирования, и в американсой математике дробь отделяется точкой.

Double #

Давайте отдельно рассмотрим пример деления с целыми и дробными числами. Сначала целые числа:

public class IntDiv   public static void main(String[] args)   int a, b, c;  a = 1;  b = 10;  c = a / b;  System.out.println(c);  > > 

При делении единицы на десять мы получаем ноль целых и, при использовании типа данных int, после и… больше ничего не будет. Деление единицы на десять даёт ноль.

- Сколько айфонов ценой в 1000€ я могу купить за 10€? - Ноль. За 10€ я куплю ноль айфонов. И за 999€ я куплю ровно ноль айфонов. 

Результат деления целых чисел (тип данных int) округляется до меньшего целого числа. #

public class IntDiv   public static void main(String[] args)   double a, b, c;  a = 1;  b = 10;  c = a / b;  System.out.println(c);  > > 

Но, если мы при инициализации переменных изменим их тип на double, то получим привычное нам 0.1.

Представьте, что вы купили десять метров ткани, и на костюм вам надо 7 метров. Сколько костюмов вы сошьёте из 10 метров? Один или полтора? В некоторых случаях нам абсолютно не нужны дробные (с плавающей точкой) числа, а в некоторых — целые.

На простейшем примере можно увидеть работу double ещё раз:

public class HalloDouble   public static void main(String[] args)   final double PI = 3.14;  // final - используется для "финализации" переменной,  // теперь переменной PI нельзя присвоить другое значение.  double r = 5.5;  double k = r * r;  double s = PI * r * r;  System.out.println(k);  // промежуточный результат  System.out.println(s);  > > 

Тип	Максимальное позитивное значение	Минимальное позитивное значение	Размер (бит)
float	3.4028234663852886E+038	1.4012984643248171E-045	32
double	1.7976931348623157E+308	4.9406564584124654E-324	64

Экспоненциальная запись #

Экспоненциальная запись — представление действительных чисел в виде мантиссы (дробной части логарифма числа) и порядка. Удобна при представлении очень больших и очень малых чисел, а также для унификации их написания.

1_000_000 - один миллион: 1,0Е+6 соответствует один умножить на десять в шестой степени. 

Что использовать нам в программе? Float или double #

У меня два ответа на этот вопрос.

Вариант один. Пока вы учитесь, используйте double. Он проще не требует буковок после цифры или дополнительного кастинга.

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

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

public class HalloDouble2   public static void main(String[] args)   double a = 2;  double b = 30;  double c = Math.pow(a, b);  System.out.println(c);  // Выводит на экран 1.073741824E9  > > 

Достаточно интересный вопрос: что происходит при пересечении разных типов данных? Что произойдёт, если тип переменных int встретится с double? Я подготовил программу без единой строчки комментария. Попробуйте предугадать то, что Java выведет на экран.

public class IntToDouble   public static void main(String[] args)    int var1 = 5;  int var2 = 2;  int var3 = var1 / var2;   double var4 = 5.0;  double var5 = 2.0;  double var6 = var4 / var5;  double var7 = var1 / var2;   double var25 = var1 / var4;   System.out.println("Int Var3 = " + var3);  System.out.println("double Var6 = " + var6);  System.out.println("double Var7 = " + var7);  System.out.println("double Var25 = " + var25);   int var11 = (int) (var1 / var4);   System.out.println("Int Var11 = "+ var11);  System.out.println("Магия " + 5.0/var2);  > > 

Результат работы IntToDouble:

1. Int Var3 = 2
2. double Var6 = 2.5
3. double Var7 = 2.0
4. double Var25 = 1.0
5. Int Var11 = 1
6. Магия = 2.5

Результат работы подтверждает, что int находится в пределах double и легко может использоваться в расчётах, где результатом будет число типа double. К сожалению, обратное невозможно. Мы должны преобразовать тип данных — произвести Casting. Пример кастования из нашего IntToDouble: int var11 = (int) (var1 / var4) , где int в скобках — и есть преобразование.

Помимо вычисления степени числа, математическая библиотека Java (Math) предлагает нам метод, который генерирует случайное число. Дотошный разработчик скажет, что это не случайное число, а псевдослучайное, но на нашем уровне обучения псевдослучайности достаточно для работы в Java.

Давайте, в качестве примера, сгенерируем число от 30 до 100:

 public static void main(String[] args)

Метод Math.random() представляет результат в виде дробных чисел типа double. Нам нужны целые числа, поэтому мы “кастуем” результат в нужный тип данных.

Метод Math.random() генерирует дробные числа между 0 и 1. Поэтому мы с помощью арифметики приводим случайное число между нулём и единицой в случайное число между 30 и 100. Попробуйте получить число между 1 и 50. Поэкспериментируйте с этим методом. Он нам понадобится не один раз.

Метод Math.random() является одним из многих подготовленных для вас методов, которые часто требуются при программировании. Возведение в степень, число PI, логарифмы и многое другое. Вы можете ознакомиться с официальной документацией к библиотеке Math — здесь

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

Домашнее задание #

1. Написать программу для вычисления площади круга.
2. Найти длину окружности.
3. Написать формулу вычисления стоимости Евро, если курс Евро к Доллару 1,1.
4. Найти соотношение площади Беларуси к площади Украины.
5. Найти, во сколько раз площадь Москвы больше площади Берлина.
6. Если клиент положил в банк 1000€ под 3,5%, какая сумма будет его ждать через семь лет?

Дополнительные материалы #

1. Полезная библиотека — Math
2. Конвенция java договор о правописании и синтаксисе
3. Округление чисел — https://geekbrains.ru/posts/java_round

Float java что это

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

Итак, рассмотрим систему встроенных базовых типов данных, которая используется для создания переменных в Java. А она представлена следующими типами.

boolean : хранит значение true или false

boolean isActive = false; boolean isAlive = true;

byte a = 3; byte b = 8;

short a = 3; short b = 8;

int a = 4; int b = 9;

long a = 5; long b = 10;

double x = 8.5; double y = 2.7;

float x = 8.5F; float y = 2.7F;

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

Целые числа

Все целочисленные литералы, например, числа 10, 4, -5, воспринимаются как значения типа int , однако мы можем присваивать целочисленные литералы другим целочисленным типам: byte , long , short . В этом случае Java автоматически осуществляет соответствующие преобразования:

byte a = 1; short b = 2; long c = 2121;

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

long num = 2147483649;

Здесь число 2147483649 является допустимым для типа long, но выходит за предельные значения для типа int. И так как все целочисленные значения по умолчанию расцениваются как значения типа int, то компилятор укажет нам на ошибку. Чтобы решить проблему, надо добавить к числу суффикс l или L , который указывает, что число представляет тип long:

long num = 2147483649L;

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

int num111 = 0x6F; // 16-теричная система, число 111 int num8 = 010; // 8-ричная система, число 8 int num13 = 0b1101; // 2-ичная система, число 13

Для задания шестнадцатеричного значения после символов 0x указывается число в шестнадцатеричном формате. Таким же образом восьмеричное значение указывается после символа 0 , а двоичное значение — после символов 0b .

Также целые числа поддерживают разделение разрядов числа с помощью знака подчеркивания:

int x = 123_456; int y = 234_567__789; System.out.println(x); // 123456 System.out.println(y); // 234567789

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

При присвоении переменной типа float дробного литерала с плавающей точкой, например, 3.1, 4.5 и т.д., Java автоматически рассматривает этот литерал как значение типа double . И чтобы указать, что данное значение должно рассматриваться как float , нам надо использовать суффикс f:

float fl = 30.6f; double db = 30.6;

И хотя в данном случае обе переменных имеют практически одно значения, но эти значения будут по-разному рассматриваться и будут занимать разное место в памяти.

Символы и строки

В качестве значения переменная символьного типа получает одиночный символ, заключенный в одинарные кавычки: char ch=’e’; . Кроме того, переменной символьного типа также можно присвоить целочисленное значение от 0 до 65535 . В этом случае переменная опять же будет хранить символ, а целочисленное значение будет указывать на номер символа в таблице символов Unicode (UTF-16). Например:

char ch=102; // символ 'f' System.out.println(ch);

Еще одной формой задания символьных переменных является шестнадцатеричная форма: переменная получает значение в шестнадцатеричной форме, которое следует после символов «\u». Например, char ch=’\u0066′; опять же будет хранить символ ‘f’.

Символьные переменные не стоит путать со строковыми, ‘a’ не идентично «a». Строковые переменные представляют объект String , который в отличие от char или int не является примитивным типом в Java:

String hello = "Hello. "; System.out.println(hello);

Кроме собственно символов, которые представляют буквы, цифры, знаки препинания, прочие символы, есть специальные наборы символов, которые называют управляющими последовательностями. Например, самая популярная последовательность — «\n». Она выполняет перенос на следующую строку. Например:

String text = "Hello \nworld"; System.out.println(text);

Результат выполнения данного кода:

Hello world

В данном случае последовательность \n будет сигналом, что необходимо сделать перевод на следующую строку.

Начиная с версии 15 Java поддерживает тестовые блоки (text blocks) — многострочный текст, облеченный в тройные кавычки. Рассмотрим, в чем их практическая польза. Например, выведем большой многострочный текст:

String text = "Вот мысль, которой весь я предан,\n"+ "Итог всего, что ум скопил.\n"+ "Лишь тот, кем бой за жизнь изведан,\n"+ "Жизнь и свободу заслужил."; System.out.println(text);

С помощью операции + мы можем присоединить к одному тексту другой, причем продолжение текста может располагаться на следующей строке. Чтобы при выводе текста происходил перенос на следующую строку, применяется последовательность \n.

Результат выполнения данного кода:

Вот мысль, которой весь я предан, Итог всего, что ум скопил. Лишь тот, кем бой за жизнь изведан, Жизнь и свободу заслужил.

Текстовые блоки, которые появились в JDK15, позволяют упростить написание многострочного текста:

String text = """ Вот мысль, которой весь я предан, Итог всего, что ум скопил. Лишь тот, кем бой за жизнь изведан, Жизнь и свободу заслужил. """; System.out.println(text);

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

Типы данных

Java — строго типизированный объектно-ориентированный язык программирования. Переменные и выражения имеют конкретный тип и каждый тип строго определен. Все операции присваивания проверяются на соответствия типов.

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

Целые числа

тип

размер (биты)

Диапазон значений определяется по формуле

Если значения выходят за пределы допустимого интервала, то такие значения преобразуются к соответствующим из интервала исходного типа. На рис. 1 продемонстрирована графическая интерпретация преобразования значений типа byte, которые выходят за пределы допустимого интервала.

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

byte x=127; System.out.println(++x);//-128

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

тип

размер (биты)

float f = 23.1f; double d = 24.4;

Символы

тип

размер (биты)

Данный тип используется для хранения одиночного символа. Символы в java представлены в кодировке Unicode

char ch1 = 'a';//символ 'a' char ch2 = 65;//соответствующий ASCII-коду 65 ('A') char ch3 = '\u03A9';//соответствует символу 'Ω'

Логические значения

тип

размер (биты)

Диапазон значений: true, false

boolean a = true; boolean b = false;

Литералы

Литерал — это представление операнда с постоянным значением

Целочисленные

0bN или 0BN

0xN или 0XN

Правила, применимые к целочисленным литералам

• Целочисленный литерал указывается как тип intпо умолчанию
• Когда значение присваивается к типу byte, short или char, то ошибки не происходит, если значение находится в интервале допустимых значений данного типа
• Для применения к типу long необходимо указать обозначение L или l (0x7L, 20L, 07L)
• Для разделения литералов используется знак подчеркивания ( int x=123_456_789; )

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

По основанию 10

По основанию 16

10.0E0 или 8250e-2

0xA.0p0 или 0XA5p-1

Правила, применимые к литералам с плавающей точкой

• По умолчанию литерал имеет тип double, а также можно указать и явно, добавив d или D ( double x=3.14D )
• Чтобы обозначить тип float, то нужно добавить f или F ( float x=3.14f )
• Для разделения литералов используется знак подчеркивания ( double d=0XA_5p-1 или 1_2_3.1_2_3)
• Литералы с экспоненциальной формой записи после p содержит степень числа два, на которое умножается заданное число. ( 0x0.Ap1 (16) = 0.625*2 )

Логические

Тип boolean может иметь только два значения: true, false

Символьные

Символы в Java — это символы из набора символов Юникод. Могут быть преобразованы в целые значения над которыми можно производить целочисленные операции.

Управляющая последовательность — это способ задания символа, который является специфичным или выходит за пределы ASC2

char s1 = 'A';char s2 = 'g';

Символьные литералы помещаются в одинарные кавычки. Символы указываются из кодировки ASC2

char s1 = '\'';char s2 = '\n';

В данном случае косая черта используется для указания специальных символов

char s1 = '\141';char s2 = '\u1212';

Так как количество символов в Unicode больше чем в ASC2, то для их указания используется числовой код как в восьмеричной форме, так и в шестнадцатеричной. (\ddd — восьмеричный, \uxxxx — шестнадцатеричный)