Какие данные мы рискуем потерять при явных приведениях java
Перейти к содержимому

Какие данные мы рискуем потерять при явных приведениях java

  • автор:

Какие данные мы рискуем потерять при явных приведениях java

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

int a = 4; byte b = a; // ! Ошибка

В данном коде мы столкнемся с ошибкой. Хотя и тип byte, и тип int представляют целые числа. Более того, значение переменной a, которое присваивается переменной типа byte, вполне укладывается в диапазон значений для типа byte (от -128 до 127). Тем не менее мы сталкиваемся с ошибкой на этапе компиляции. Поскольку в данном случае мы пытаемся присвоить некоторые данные, которые занимают 4 байта, переменной, которая занимает всего один байт.

Тем не менее в программе может потребоваться, чтобы подобное преобразование было выполнено. В этом случае необходимо использовать операцию преобразования типов (операция () ):

int a = 4; byte b = (byte)a; // преобразование типов: от типа int к типу byte System.out.println(b); // 4

Операция преобразования типов предполагает указание в скобках того типа, к которому надо преобразовать значение. Например, в случае операции (byte)a , идет преобразование данных типа int в тип byte. В итоге мы получим значение типа byte.

Явные и неявные преобразования

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

Автоматические преобразования

Преобразования типов в языке Java

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

Автоматически без каких-либо проблем производятся расширяющие преобразования (widening) — они расширяют представление объекта в памяти. Например:

byte b = 7; int d = b; // преобразование от byte к int

В данном случае значение типа byte, которое занимает в памяти 1 байт, расширяется до типа int, которое занимает 4 байта.

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

byte -> short -> int -> long

short -> float -> double

Автоматические преобразования с потерей точности

Некоторые преобразования могут производиться автоматически между типами данных одинаковой разрядности или даже от типа данных с большей разрядностью к типа с меньшей разрядностью. Это следующие цепочки преобразований: int -> float , long -> float и long -> double . Они производятся без ошибок, но при преобразовании мы можем столкнуться с потерей информации.

int a = 2147483647; float b = a; // от типа int к типу float System.out.println(b); // 2.14748365E9
Явные преобразования

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

long a = 4; int b = (int) a;

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

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

int a = 5; byte b = (byte) a; System.out.println(b); // 5

Число 5 вполне укладывается в диапазон значений типа byte, поэтому после преобразования переменная b будет равна 5. Но что будет в следующем случае:

int a = 258; byte b = (byte) a; System.out.println(b); // 2

Результатом будет число 2. В данном случае число 258 вне диапазона для типа byte (от -128 до 127), поэтому произойдет усечение значения. Почему результатом будет именно число 2?

Число a, которое равно 258, в двоичном системе будет равно 00000000 00000000 00000001 00000010 . Значения типа byte занимают в памяти только 8 бит. Поэтому двоичное представление числа int усекается до 8 правых разрядов, то есть 00000010 , что в десятичной системе дает число 2.

Усечение рациональных чисел до целых

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

double a = 56.9898; int b = (int)a;

Здесь значение числа b будет равно 56, несмотря на то, что число 57 было бы ближе к 56.9898. Чтобы избежать подобных казусов, надо применять функцию округления, которая есть в математической библиотеке Java:

double a = 56.9898; int b = (int)Math.round(a);

Преобразования при операциях

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

  • если один из операндов операции относится к типу double , то и второй операнд преобразуется к типу double
  • если предыдущее условие не соблюдено, а один из операндов операции относится к типу float , то и второй операнд преобразуется к типу float
  • если предыдущие условия не соблюдены, один из операндов операции относится к типу long , то и второй операнд преобразуется к типу long
  • иначе все операнды операции преобразуются к типу int
int a = 3; double b = 4.6; double c = a+b;

Так как в операции участвует значение типа double, то и другое значение приводится к типу double и сумма двух значений a+b будет представлять тип double.

byte a = 3; short b = 4; byte c = (byte)(a+b);

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

Если в операциях участвуют данные типа char, то они преобразуются в int:

int d = 'a' + 5; System.out.println(d); // 102

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

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

int i = 11; byte b = 22; i = b;

В Java существует два типа преобразований — автоматическое преобразование (неявное) и приведение типов (явное преобразование).

Два типа преобразования в Java фото

1. Автоматическое преобразование типов Java

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

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

  • оба типа должны быть совместимы
  • длина целевого типа должна быть больше длины исходного типа

В этом случае происходит преобразование с расширением.

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

Схема совместимых преобразований для примитивных типов в Java фото

Сплошные линии обозначают преобразования, выполняемые без потери данных. Штриховые линии говорят о том, что при преобразовании может произойти потеря точности.

Например, тип данных int всегда достаточно велик, чтобы хранить все допустимые значения типа byte , поэтому никакие операторы явного приведения типов в данном случае не требуются. С точки зрения расширяющего преобразования числовые типы данных, в том числе целочисленные и с плавающей точкой, совместимы друг с другом. В то же время не существует автоматических преобразований числовых типов в тип char или boolean . Типы char и boolean также не совместимы друг с другом.

Стоит немного пояснить почему, к примеру тип byte не преобразуется автоматически (не явно) в тип char, хотя тип byte имеет ширину 8 бит, а char — 16. То же самое касается и преобразования типа short в char . Это происходит потому, что byte и short знаковые типы данных, а char беззнаковый. Поэтому в данном случае требуется использовать явное приведение типов, поскольку компилятору надо явно указать, что вы знаете чего хотите и как будет обрабатываться знаковый бит типов byte и short при преобразовании к типу char .

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

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

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

Чтобы выполнить преобразование двух несовместимых типов данных, нужно воспользоваться приведением типов. Приведение — это всего лишь явное преобразование типов. Общая форма приведения типов имеет следующий вид:

(целевой_тип) значение

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

Например, в следующем фрагменте кода тип int приводится к типу byte :

int i = 11; byte b = 22; b = (byte) i;

Рассмотрим пример преобразования значений с плавающей точкой в целые числа. В этом примере дробная часть значения с плавающей точкой просто отбрасывается (операция усечения):

double d = 3.89; int a = (int) d; //Результат будет 3

При приведении более емкого целого типа к менее емкому старшие биты просто отбрасываются:

int i = 323; byte b = (byte) i; //Результат будет 67

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

double d = 389889877779.89; short s = (short) d; //Результат будет -1

3. Автоматическое продвижение типов в выражениях

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

В языке Java действуют следующие правила:

  1. Если один операнд имеет тип double , другой тоже преобразуется к типу double .
  2. Иначе, если один операнд имеет тип float , другой тоже преобразуется к типу float .
  3. Иначе, если один операнд имеет тип long , другой тоже преобразуется к типу long .
  4. Иначе оба операнда преобразуются к типу int .
  5. В выражениях совмещенного присваивания (+=,-=,*=,/=) нет необходимости делать приведение.

При умножении переменной b1 ( byte ) на 2 ( int ) результат будет типа int . Поэтому при попытке присвоить результат в переменную b2 ( byte ) возникнет ошибка компиляции. Но при использовании совмещенной операции присваивания (*=), такой проблемы не возникнет:

byte b1 = 1; byte b2 = 2 * b1; //Ошибка компиляции int i1 = 2 * b1; b2 *= 2;

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

Маленькие хитрости Java

Я уже достаточно много лет занимаюсь разработкой на java и повидал довольно много чужого кода. Как это не странно, но постоянно от одного проекта к другому я вижу одни и те же проблемы. Этот топик — попытка ликбеза в наиболее часто используемых конструкциях языка. Часть описанного — это довольно банальные вещи, тем не менее, как показывает мой опыт, все эти банальности до сих пор актуальны. Надеюсь, статья пригодится многим java программистам. Итак, поехали:

new vs valueOf
//медленно Integer i = new Integer(100); Long l = new Long(100); String s = new String("A"); //быстро Integer i = Integer.valueOf(100); Long l = 100L;//это тоже самое что Long.valueOf(100L); String s = "A";

Старайтесь всегда использовать метод valueOf вместо конструктора в стандартных классах оболочках примитивных типов, кроме случаев, когда вам нужно конкретно выделить память под новое значение. Это связано с тем, что все они, кроме чисел с плавающей точкой, от Byte до Long имеют кеш. По умолчанию этот кеш содержит значения от -128 до 127. Следовательно, если ваше значение попадает в этот диапазон, то значение вернется из кеша. Значение из кеша достается в 3.5 раза быстрее чем при использовании конструктора + экономия памяти. Помимо этого, наиболее часто используемые значения могут также быть закэшированы компилятором и виртуальной машиной. В случае, если ваше приложение очень часто использует целые типы, можно увеличить кеш для Integer через системное свойство «java.lang.Integer.IntegerCache.high», а так же через параметр виртуальной машины -XX:AutoBoxCacheMax=.

+ vs append
//медленно String[] fields = new String[] ; String s = ""; for (int i = 0; i < fields.length; i++) < s = s + fields[i]; >return s; //быстро String[] fields = new String[] ; StringBuilder s = new StringBuilder(); for (int i = 0; i < fields.length; i++) < s.append(fields[i]); >return s.toString();

Никогда не используйте операции конкатенации (оператор +) строки в цикле, особенно если таких операций у вас много, это может очень существенно снизить производительность. Все это происходит потому, что в приведенном выше примере «s = s + fileds[i]» выполняется целых 3 операции: создается StringBuilder на основе строки s, вызывается метод конкатенации append, после конкатенации вызывается метод toString (выглядит так: s = new StringBuilder(s).append(fields[i]).toString();). Целых 3 операции вместо одной! Помимо этого каждый результат s + fileds[i] будет занимать память в куче, как отдельная строка.

StringBuilder vs StringBuffer

Всегда ипользуйте StringBuilder, кроме случаев, когда вам необходимо использовать конкретно StringBuffer, так как в StringBuilder нету синхронизированных методов в отличие от StringBuffer и следовательно производительность будет выше, хоть и не значительно.

instanceOf

Старайтесь как можно реже использовать оператор instanceOf. Это один из самых медленных java операторов и подходить к его использованию нужно осторожно. Имейте в виду — чаще всего наличие этого оператора в коде означает непонимание принципов ООП, нежели попытка реализовать некий паттерн. Почти всегда полиморфизм способен помочь избавится от этого оператора.
P. S. Многие в комментариях аппелируют к «Это один из самых медленных java операторов». Это действительно так. Конечно, не совсем корректно сравнивать операторы языка по производительности, так как они выполняют абсолютно разные задачи, но, тем не менее, механизм работы instanceOf гораздо сложнее, например, оператора ‘*’.

Generics
//плохо List a = new ArrayList(); //хорошо List a = new ArrayList();

Всегда старайтесь типизировать ваши коллекции, методы и классы. Это избавляет сразу от 2-х потенциальных проблем: приведение типов и ошибок выполнения. Также назначение таких коллекций легче воспринимать. Особенно часто этим пренебрегают мои американо-индусские коллеги. Если же ваша коллекция должна содержать обьекты разных типов — используйте , а еще лучше тогда зная общий класс/интерфейс для всех обьектов вам не прийдется делать приведение типов и применять оператор instanceOf.

Interface for Consts
//плохо interface A < public static final String A = "a"; >//хорошо final class A

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

Override

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

null vs empty

Всегда старайтесь в методах вашей бизнес логики возвращать пустые коллекции вместо null значений, это избавляет от лишних null-проверок и делает код чище. Для этого в классе Collections есть несколько замечательных методов:

Collections.emptyList(); Collections.emptyMap(); Collections.emptySet();

В комментариях просят уточнить вариант применения. Типичный случай:

 Set docs = getDocuments(plan); for (Document doc : docs) < sendMessage(doc.getOwner()); >public static Set getDocuments(Plan plan) < //some logic if (isDoSomethingOk() && hasAccessToDocuments(user)) < return plan.getDocuments(); >return Collections.emptySet(); > 

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

Преобразование чисел
//медленно int a = 12; String s = a + ""; //быстро int a = 12; String s = String.valueOf(a); 

Ситуация очень схожа с конкатенацией строк.

Выводы

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

Какие данные мы рискуем потерять при явных приведениях java

Открою вам страшную тайну. -27008 — это в бинарном представлении 11111111111111111001011010000000 а число 1001011010000000, которое вы в статье отразили картинкой — это честные 38528

WriturX [Andrij] Уровень 16
27 января 2022
Есть кому интересно 耰 — Мучить, терзать, нервировать. Совпадение? Не думаю.
25 января 2022

Можете объяснить, почему лонг в дабл преобразуется автоматически, а наоборот — нет и нужно кастить. Но для обоих типов, при этом, выделяется 64 бита.

Artem Sokolov Уровень 26
6 января 2022
Жаль, не рассказали о примерах в жизни где это может понадобиться.
AmpCult Уровень 24
18 марта 2021

Диапазон char должен быть от 0 до 65535, а значит общее количество значений 65536 = 2^16 или 2 байта, но в первой таблице указан диапазон от 0 до 65536. Можно пояснительную бригаду? Буду очень благодарен.

Никита Уровень 15
10 марта 2021
Разве недостаточно выделить под булевые значения 1 бит? Всего же 2 значения — 1 и 0
Just me Уровень 41
23 февраля 2021

Помогите понять, какие именно первые 16 бит были взяты из числа типа int при приведении к типу short ?

Евгений Уровень 38
1 февраля 2021

Во второй лекции 10-го уровня указан совершенно другой диапазон значений и размеров в байтах. Как так вышло?

Константин Уровень 22
15 января 2021

видимо должен быть «char»

Андрей Вишняков Уровень 16
6 января 2021

Очень удивлен, что логической переменной присвоили целых 8 бит или байт, а если не в массиве (не удивлюсь, если массивный тру не будет равен обычному ��) то целый инт! Хотелось бы понять зачем сделали так, ведь булеан — эта основа всего программирования и делать его больше одного бита лично я не вижу смысл. Тру 1, фальш 0. Откуда 8 и 32?

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *