Сколько байт занимает int java
Перейти к содержимому

Сколько байт занимает int java

  • автор:

Реальный размер byte в java heap

Я запутался с тем сколько в действительности занимает переменная типа byte в java heap, в одном источнике написано что 1 байт, в другом что 4 байта как и int, в третьем источнике написано что он может увеличиваться до 8 байт, в четвертом что он хоть и занимает 4 байта, но при этом к примеру массив из 20 элементов типа byte будет весить 20 байт в оперативке. Так сколько в дейстивительности занимает переменная типа byte в java heap?

Отслеживать
задан 13 мая 2018 в 22:39
cvxbcvbsd fsddfgdfg cvxbcvbsd fsddfgdfg
125 12 12 бронзовых знаков
А почему именно в хипе? Почему не на стеке, например?
– user181100
13 мая 2018 в 23:42
Зависит от jvm.
14 мая 2018 в 0:44

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Размер объекта в куче зависит от множества факторов — реализации JVM, её разрядности, использования компактных указателей, выравнивания объектов и т.д. и т.п.

Самый простой и быстрый способ посмотреть сколько объект Byte занимает в вашем случае — запустить входящую в JDK утилиту jmap, найти строку java.lang.Byte и разделить значение в колонке bytes на значение в колонке instances

Программный путь чуть сложнее. С ним поможет пакет java.lang.instrument. Для начала нам нужен класс агента:

import java.lang.instrument.Instrumentation; public class ObjectSizeFetcher < private static Instrumentation instrumentation; public static void premain(String args, Instrumentation inst) < instrumentation = inst; >public static long getObjectSize(Object o) < return instrumentation.getObjectSize(o); >> 
$ javac ObjectSizeFetcher 

Потом создаём файл MANIFEST.MF и добавляем в него строку

Premain-Class: ObjectSizeFetcher 

А после упаковываем класс и манифест в jar

$ jar cfm ObjectSizeFetcherAgent.jar MANIFEST.MF ObjectSizeFetcher.class 

Класс для теста:

public class Main < public static void main(String[] args) throws Exception < Byte b = new Byte("1"); System.out.println(ObjectSizeFetcher.getObjectSize(b)); >> 

Компилируем и запускаем c предварительно созданным агентом

$ javac Main.java $ java -javaagent:ObjectSizeFetcherAgent.jar Main 

Код для примера с агентом взят отсюда.

Java Переполнение целых чисел

Для начала рассмотрим пример переполнения целых чисел на примере примитивного типа byte. Почему byte ? Потому что он занимает 1 байт и проще для восприятия:

System.out.println("[" + Byte.MIN_VALUE +" , " + Byte.MAX_VALUE + "]"); System.out.println("Byte.SIZE = " + Byte.SIZE); byte b = 120; b += 19; System.out.println(b);

Вывод на консоль:
[-128 , 127]
Byte.SIZE = 8
-117

Ключевой момент в этом коде, почему вывелось «-117» ?
Числа в ПК хранятся целыми байтами (например примитивный тип byte занимает 1 байт, int — 4 байта). От того, сколько байтов занимает число, зависит количество разрядов числа. Мы знаем, что 1 байт = 8 бит; у примитивного типа byte — 8 разрядов(Byte.SIZE) , у типа int — 4*8 = 32 разряда.
Целые типы (byte, int) знаковые, т.е. могут быть, положительными и отрицательными. ПК не может запомнить минус => изменяется старший бит (1 — число отрицательное, 0 — положительное).
Пример:
Переведем числа 120,19 и -117 в двоичную систему:
120(10) = 0111 1000
19(10) = 0001 0011
-117(10)= 1000 1011

Т.к. у нас старший бит отвечает за знак, то остается 2 7 — 1 символов для положительной части, и 2 8 для отрицательной.
Складывая 120 и 19 мы получаем для 8 разрядом число -117

Переменные в Java

Часто Вы можете услышать такое определение переменной:

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

Помните, как в школе было: y = x + 1

И в зависимости от того, какие значения принимает переменная x, меняется значение переменной y.

Если x = 1, тогда x+ 1 =2

Если x = 2, тогда x +1 = 3

Если х = 1.5 , тогда x + 1 =2.5

В Java переменные играют такую же роль, как и в приведенном примере со школы y = x + 1. Они выполняют роль контейнера для разных значений, которые можно подставить в переменную. В приведённом примере — в переменную x.

Типы переменных в Java. Объявление переменной

В Java можно указать, какие именно значения может принимать переменная.

Для этого все переменные сгруппировали в 4 группы:

  1. Целочисленные (к ним относятся byte, short, int, long)
  2. С плавающей точкой (к ним относятся float, double)
  3. Символы (char)
  4. Логические (boolean)

Variables Java_Vertex Academy

Примечание: Итого 8 типов переменных (byte, short, int, long, float, double, char, boolean). Многоуважаемый Брюс Эккель выделяет еще и 9-й тип – так называемый тип void («пустое» значение). Но в этой статье мы рассмотрим 8 типов, как это обычно принято. Что же такое тип void мы разберёмся в теме, посвященной методам в Java.

Теперь давайте рассмотрим каждую группу переменных. И начнём с целочисленных.

Целочисленные: byte, short, int, long

Variables Vertex Academy

Как видно из таблички, byte, short, int, long относятся к целочисленным, то есть к целым числам. Например, 1, 9, 1278, -5, -107 и т.д.

  1. byte может принимать значения от -128 до 127 и при этом занимает 1 байт памяти
  2. short принимает значения от -32768 до 32767 и занимает 2 байта памяти
  3. int от -2147483648 до 2147483647 и занимает 4 байта памяти
  4. long от -9223372036854775808 до 9223372036854775807 и занимает 8 байтов памяти

«Ну, хорошо», — скажете Вы. «Если byte, short, int и long отвечают все за целые числа, как мне понять какой именно тип нужно выбирать? » Помните детские задачки по математике, которые сейчас будут как нельзя кстати для объяснения за что отвечают byte, short, int, long.

Задача 1: Apples_3

У Димы 3 яблока, у Ани 2 яблока. Сколько яблок у Димы и Ани вместе?

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

Значит, если бы мы писали код в Java, который бы предполагал решение данной задачи, мы бы использовали для переменных целочисленный тип. Остается понять только какой именно мы бы использовали: byte, short, int или long?

Всегда необходимо отталкиваться от контекста.

  1. Если мы знаем точно, что при решении данной задачи, даже если будут меняться значения, например, у Димы 50 яблок, у Ани 30, но в сумме это будет не больше 127 яблок, то можем смело использовать тип byte
  2. Если же мы знаем, что могут поменять условия задачи и у Димы может быть, например, 10 000 яблок, а у Ани, например, 7 000 яблок, то уже тип byte мы использовать не можем. Поскольку это явно выходит за пределы допустимых значений в byte – не более 127. Значит, могли бы использовать тип short, у которого максимально допустимое значение 32767
  1. Если же предположить, что у Димы и у Ани может быть даже больше, чем 32767 яблок. Ну, например, у них яблоневые сады по всей Украине. Тогда необходимо использовать тип int. Кстати, int – это сокращенно от английского integer (целое число).
  2. Ну, а если предположить, что Дима и Аня – это «яблочные магнаты» и им принадлежат все яблоневые сады в мире, то тогда число может быть намного больше, чем даже максимальное значение int 2147483647. И тогда необходимо использовать тип long.

Однако чаще всего при написании программ на Java, Вы будете использовать тип int. Это самый распространенный целочисленный тип. Более того, тип int в Java является типом «по умолчанию» для целочисленных типов. Что это значит, Вы узнаете на практике.

Прежде, чем использовать переменную, её необходимо объявить . А объявляются переменные так.

Announcement int Vertex Academy

А вот и примеры объявления переменных:

И здесь сразу же хочется сказать о том, что переменные, когда их название состоит из 2 и более слов, пишутся слитно и как бы «горбиками» как у верблюда. Такой стиль написания слов называется CamelStyle (от англ. camel — «верблюд»).

CamelStyle Vertex Academy

Видите, названия примеров переменных состоят из 2 и более слов и пишутся слитно. Причем первое слово пишется с маленькой буквы, а во всех последующих словах первая буква большая. Теперь Вы знаете — это CamelStyle, стиль написания названий. Он иногда называется CamelCase. Мы об этом даже статью написали ��

Ну что ж, самое время понять за что отвечают переменные с плавающей точкой.

С плавающей точкой: float, double

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

Задача 2: Apples Float Vertex Academy

У Димы 3,5 яблока, у Ани 2,5 яблока. Сколько яблок у Димы и Ани вместе?

Как видите, в задаче речь идёт уже не о целых яблоках. Уже речь идёт о дробных числах. А значит мы уже не можем использовать целочисленный тип: нам не подойдет ни byte, ни short, ни int, ни long. Запомните: как только речь идет о дробных числах, значит, речь идет о float и ли double. Примеры дробных чисел: 1.0, 1.8, 3.141562, 9.0, 12.579, 1278.0, -5.0, — 9.4, -107.0, -107.356 и т.д.

Float Double_Vertex Academy

Как видно из таблички:

  1. float может принимать значения от -3.4Е +38 до 3.4Е +38 и при этом занимает 4 байта памяти
  2. double принимает значения от -1.7E + 308 до 1.7Е + 308 и занимает 8 байт памяти

Запомните:

  • дробные числа пишутся не через запятую, как мы привыкли со школы, а через точку. Например, 1,5 — это неправильно. Правильно 1.5
  • float определяет значение одинарной точности. Это значит, что переменные данного типа удобны, когда требуется дробная часть без особой точности. Например, для денежных сумм.
  • double обеспечивает двойную точность и это видно из названия (double — двойная).

Прежде, чем использовать переменную, её необходимо объявить . А объявляются переменные float и double по такому же принципу.

Announcement float Vertex Academy

А вот и примеры объявления переменных:

float money; // объявили переменную money типа float

float wage; // объявили переменную wage типа float

float c; // объявили переменную c типа float

double stat; //объявили переменную stat типа double

Символы: char

Char_Vertex Academy

В Java для char используется кодировка Unicode. Как видно из таблички, диапазон допустимых значений char от 0 до 65536 и при этом занимает 2 байта памяти. Отрицательных значений не существует. На самом деле переменная типа char хранит не сам символ, а его числовой код из таблички Unicode, по этому мы можем проводить целочисленные операции над символами.

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

Announcement char Vertex Academy

Примеры объявления переменных:

char y; //объявили переменную y типа char

char f; //объявили переменную f типа char

Логические: boolean

Boolean Vertex Academy

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

Только у славян возможен такой разговор:

— Да нет, наверное.

Это то, что очень удивляет иностранцев, когда они учат, например, украинский или русский язык. Так все-таки да или все-таки нет?

Так вот в языке программирования Java всё очень точно:

  • либо true (с английского — «истина»)
  • либо false (с английского — «ложь)

Boolean Picture Vertex Academy

Чуть позже Вы поймете где применяется данный тип переменных, когда мы, например, дойдём до темы конструкции ветвления. А пока просто запомните, что есть такой тип. Пусть это будет пока «черной лошадкой» для Вас.

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

Announcement boolean Vertex Academy

Примеры объявления переменных:

boolean check1; //объявили переменную check1 типа boolean

boolean check2; //объявили переменную check2 типа boolean

Ну вот, теперь Вы знаете за что отвечают эти типы переменных:

Variables Java_Vertex Academy

Что ещё Вы должны знать?

1. Вы должны знать, что эти типы переменных относятся к так называемым примитивным типам переменных. Поэтому если услышите «примитивные типы данных» , «примитивы» или «primitives», знайте, речь идёт о 8 типах переменных — byte, short, int, long, float, double, char, boolean.

2. Есть еще один тип переменных — тип String . О нём мы поговорим в статье «Как присвоить значение переменной»

3. В Java очень важно правильно оформлять код . Да-да, не только писать работающие программы, но ещё и правильно оформленные. Существует целый свод правил, который называется Code Conventions в Java. Так что можете смело скачивать и постепенно изучать. А сейчас мы рассмотрим только часть Code Conventions, а именно правила написания названий переменных. Итак, запоминаем.

Variables Rules Vertex Academy
5 правил выбора названий для переменных:

Правило №1 — переменные пишутся только латинскими буквами. Никакой кириллицы.

Например:

Правило №2 – имя переменной, по возможности, должно быть «говорящим»

Например:

int s; // так можно называть переменную, но когда кода много и все переменные имеют не говорящие названия, код очень тяжело читать

int size; // этот вариант более «говорящий», чем первый вариант int s; поскольку понятно из названия, что переменная отвечает за размер чего-то

Правило №3 — с чего может/не может начинаться имя переменной

Может начинаться с :

  1. Любых латинских букв
  2. $ или _

Не может начинаться с:

Ниже приводим несколько примеров — правильных и неправильных.

Правильно:

  • int square;
  • int $money;
  • int width;
  • int boxSize;
  • double sum;
  • double sumJune;

Неправильно:

  • int 2square;
  • int 101dalmatians;

Правило №4 – название переменной, состоящее из 2 и более слов, пишется в CamelStyle

Что такое CamelStyle мы с Вами уже обсудили в этой статьей чуть выше.

Правило №5 – нельзя использовать в названиях переменных эти 54 слова:

abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends, false, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, null, package, private, protected, public, return, short, static, strictfp, String, super, switch, synchronized, this, throw, throws, transient, true, try, void, volatile, while

Эти 54 слова имеют особое значение при написании кода на Java . Постепенно Вы поймёте где используется каждое слово. Причём после прочтения этой статьи, из 54 слов Вам уже станут знакомы те слова, которые мы выделили синим:

abstract, assert, boolean , break, byte , case, catch, char , class, const, continue, default, do, double , else, enum, extends, false , final, finally, float , for, goto, if, implements, import, instanceof, int , interface, long , native, new, null, package, private, protected, public, return, short , static, strictfp, String , super, switch, synchronized, this, throw, throws, transient, true , try, void, volatile, while

ПОДЫТОЖИМ:

Всего 4 группы переменных:

  1. Целочисленные (к ним относятся byte, short, int, long)
  2. С плавающей точкой (к ним относятся float, double)
  3. Символы (char)
  4. Логические (boolean)

Variables Java_Vertex Academy

Эти 8 типов переменных (byte, short, int, long, float, double, char, boolean) относятся к там называемым примитивным типам переменных.

Прежде чем использовать переменную, её необходимо объявить:

Announcement Vertex Academy

5 правил выбора названий переменных:

  1. Переменные пишутся только латинскими буквами. Никакой кириллицы.
  2. Имя переменной, по возможности, должно быть «говорящим»
  3. Если переменная состоит из 2 и более слов, пишется в CamelStyle (другое название — CamelCase)
  4. Есть 54 слова, которые нельзя использовать в названиях переменных
  5. Имя переменной:
  • может начинаться с любых латинских букв, $ или _
  • не может начинаться с цифр

Также есть еще один тип переменных — тип String, о котором мы поговорим в статье «Как присвоить значение переменной в Java»

Надеемся, что наша статья была Вам полезна. Также есть возможность записаться на наши курсы по Java в Киеве. Обучаем с нуля.

По всем вопросам звоните:

+38 050 205 77 99

+38 098 205 77 99

Или читайте информацию по нашим курсам Java c нуля у нас на сайте.

  • ← Что такое CamelCase или CamelStyle?
  • Как создать первую веб-страницу →

Сколько байт занимает int java

Decker

Просмотр профиля

19.12.2011, 22:24

Группа: Главные администраторы
Сообщений: 14349
Регистрация: 12.10.2007
Из: Twilight Zone
Пользователь №: 1

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

Integer vs int

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

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

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

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

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

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

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

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

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

  • 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 очень интересна и обширна, когда я начинал писать эту статью, то думал что уложусь в пару примеров с выводами. Но чем дальше и глубже копаешь, тем больше и интересней становится. Вообще, знать как выделяется память для объектов очень полезная вещь, так как поможет Вам сэкономить память, предотвратить подобные проблемы или оптимизировать вашу программу в местах, где это казалось невозможным. Конечно, места где можно использовать такие оптимизации — очень редки, но все же… Надеюсь статья была Вам интересной.

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

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