Размер байта в памяти - Java
Как будто вы пытаетесь получить доступ к объекту, который является null. Рассмотрим ниже пример:
TypeA objA;
. В это время вы только что объявили этот объект, но не инициализировали или не инициализировали. И всякий раз, когда вы пытаетесь получить доступ к каким-либо свойствам или методам в нем, он будет генерировать NullPointerException, что имеет смысл.
См. Также этот пример:
String a = null;
System.out.println(a.toString()); // NullPointerException will be thrown
10 ответов
Хорошо, было большое обсуждение и не много кода:)
Вот быстрый сравнительный тест. Это имеет нормальные протесты когда дело доходит до такого рода вещи - тестирование памяти имеет причуды из-за JITting и т.д., но с соответственно большими количествами это полезно так или иначе. Это имеет два типа, каждого с 80 участниками - LotsOfBytes имеет 80 байтов, LotsOfInts имеет 80 ints. Мы создаем многие из них, удостоверьтесь, что они не GC'd и проверяют использование памяти:
class LotsOfBytes
{
byte a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af;
byte b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf;
byte c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf;
byte d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df;
byte e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef;
}
class LotsOfInts
{
int a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af;
int b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf;
int c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf;
int d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df;
int e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef;
}
public class Test
{
private static final int SIZE = 1000000;
public static void main(String[] args) throws Exception
{
LotsOfBytes[] first = new LotsOfBytes[SIZE];
LotsOfInts[] second = new LotsOfInts[SIZE];
System.gc();
long startMem = getMemory();
for (int i=0; i < SIZE; i++)
{
first[i] = new LotsOfBytes();
}
System.gc();
long endMem = getMemory();
System.out.println ("Size for LotsOfBytes: " + (endMem-startMem));
System.out.println ("Average size: " + ((endMem-startMem) / ((double)SIZE)));
System.gc();
startMem = getMemory();
for (int i=0; i < SIZE; i++)
{
second[i] = new LotsOfInts();
}
System.gc();
endMem = getMemory();
System.out.println ("Size for LotsOfInts: " + (endMem-startMem));
System.out.println ("Average size: " + ((endMem-startMem) / ((double)SIZE)));
// Make sure nothing gets collected
long total = 0;
for (int i=0; i < SIZE; i++)
{
total += first[i].a0 + second[i].a0;
}
System.out.println(total);
}
private static long getMemory()
{
Runtime runtime = Runtime.getRuntime();
return runtime.totalMemory() - runtime.freeMemory();
}
}
Вывод на моем поле:
Size for LotsOfBytes: 88811688
Average size: 88.811688
Size for LotsOfInts: 327076360
Average size: 327.07636
0
Так, очевидно, существуют немного служебные - 8 байтов взглядами его, хотя так или иначе только 7 для LotsOfInts (? как я сказал, существуют причуды здесь) - но дело в том, что поля байта, кажется, упаковываются в для LotsOfBytes, таким образом, что только четверти требуется (после служебного удаления) столько же памяти сколько LotsOfInts.
Java никогда не является реализацией или конкретной платформой (по крайней мере, до , размеры типа примитива затронуты). Они типы примитивов, как всегда гарантируют, останутся такими же, неважно, какая платформа Вы идете. Это отличается от (и считался улучшением на), C и C++, где некоторые типы примитивов были конкретной платформой.
, Так как это быстрее для базовой операционной системы для обращения четыре (или восемь в 64-разрядной системе) байты за один раз, JVM может выделить больше байтов для хранения примитивного байта, но можно все еще только сохранить значения от-128 до 127 в нем.
Да, переменная байта в Java - на самом деле 4 байта в памяти. Однако это не сохраняется для массивов. Устройство хранения данных массива байтов 20 байтов - на самом деле только 20 байтов в памяти.
Это вызвано тем, что Язык Байт-кода Java только знает два типа целого числа: ints и longs. Таким образом, это должно обработать все числа внутренне как любой тип, и эти типы составляют 4 и 8 байтов в памяти.
Однако Java знает массивы с каждым форматом целого числа. Таким образом, устройство хранения данных коротких массивов - на самом деле два байта за запись и один байт за запись для массивов байтов.
причина, почему я продолжаю говорить "устройство хранения данных", состоит в том, что массив является также объектом в Java, и каждый объект требует нескольких байтов устройства хранения данных самостоятельно, независимо от устройства хранения данных, которого требуют переменные экземпляра или устройство хранения данных массива в случае массивов.
Разоблачающее осуществление должно работать javap на некотором коде, который делает простые вещи с байтами и ints. Вы будете видеть байт-коды, которые ожидают международные параметры, воздействующие на байты и байт-коды, вставляемые для принуждения от одного до другого.
Примечание, хотя это массивы байтов не хранится как массивы 4-байтовых значений, таким образом, массив байтов с 1024 длинами будет использовать 1k памяти (Игнорирующий любые издержки).
Это зависит от того, как JVM применяет дополнение и т.д. Массив байтов будет (в любой нормальной системе) быть упакованным в 1-byte-per-element, но класс с четырехбайтовыми полями мог или быть плотно упакован или дополнен на границы слова - это является зависящим от реализации.
То, что Вам сказали, точно правильно. Спецификация Байт-кода Java только имеет 4-байтовые типы и 8-байтовые типы.
байт, символ, интервал, короткий, булев, плавание все хранится в 4 байтах каждый.
двойной и длинный хранятся в 8 байтах.
Однако код байта является только половиной истории. Существует также JVM, которая является определенной для реализации. Существует достаточно информации в Байт-коде Java, чтобы решить, что переменная была объявлена как байт. Конструктор JVM может решать использовать только байт, хотя я думаю, что это очень маловероятно.
Вы могли всегда использовать longs и упаковывать данные в себе для увеличения эффективности. Тогда Вы всегда можете gaurentee, Вы будете использовать все 4 байта.
байт = 8 битов = один байт определяется Спецификацией Java.
то, в каком количестве нуждается память массив байтов, не определено Спецификацией, ни определяется, в каком количестве нуждаются сложные объекты.
Для JVM Sun я зарегистрировал правила: https://www.sdn.sap.com/irj/sdn/weblogs? блог =/pub/wlg/5163
Посмотрите мой MonitoringTools на моем сайте (www.csd.uoc.gr / ~ andreou)
class X {
byte b1, b2, b3...;
}
long memoryUsed = MemoryMeasurer.measure(new X());
(Это может использоваться для более сложных объектов/графов объектов также)
В 1,6 JDK Sun, кажется, что байт действительно берет единственный байт (в более старых версиях, интервал ~ байт с точки зрения памяти). Но обратите внимание, что даже в более старых версиях, байт [] был также упакован к одному байту за запись.
Так или иначе, дело в том, что нет никакой потребности в сложных тестах как Jon Skeet выше, это только дает оценки. Мы можем непосредственно измерить размер объекта!
Прочитывая вышеупомянутые комментарии, кажется, что мое заключение станет неожиданностью для многих (это - также удивление мне), таким образом, это повторение ценности:
- старый размер (интервал) == размер (байт) для переменных не содержит больше , по крайней мере, в Java 6 Sun.
Вместо этого размер (байт) == 1 байт (!!)