Почему булев примитивный размер Java не определяется?

Я почти уверен, что это сработает:

.card {
    width: 100px;
    height: 150px;
    float: left;
}

.attack, .defence {
    width: 100px;
    height: 75px;
    clear: right;
}

/* Play with height and padding-top of .defence to
get the text to the very bottom */
.attack-top .card .attack {
    float: left;
}
.attack-top .card .defence {
    float: right;
    height: Wpx;
    padding-top: Xpx;
}


/* Play with height and padding-top of .attack to
get the text to the very bottom */
.defence-top .card .attack {
    float: right;
    height: Ypx;
    padding-top: Zpx;
}
.defence-top .card .defence {
    float: left;
}

В вашем описании отсутствуют некоторые детали, поэтому я постараюсь дополнить свои предположения, и вы можете сообщить мне, верны они или нет.

• Вы сказали «когда карта находится в определенных областях». Я предполагаю, что эти области могут быть представлены различными содержащими классами ( .attack-top и .defence-top , но переименуйте, как считаете нужным).
• Я при условии, что .card имеет ширину 100 пикселей и высоту 150 пикселей. Если эти значения ширины и высоты неверны, укажите правильные значения и сделайте соответствующие пересчеты. Если .card не имеет фиксированной ширины / высоты, он все равно может работать, но я менее уверен, и вы не сможете заставить нижний текст переместиться в самый низ карточка (чуть ниже верхнего текста).

Одно логическое значение где-то в иерархии наследования может использовать до 8 байтов! Это связано с заполнением. Более подробную информацию можно найти в Сколько памяти используется моим Java-объектом? :

Возвращаясь к вопросу о том, как много логического потребляет, да потребляют хотя бы один байт, но из-за правила выравнивания это может потреблять много Больше. ИМХО интереснее знайте, что логическое [] будет потреблять один байт на запись, а не один бит, плюс некоторые накладные расходы из-за выравнивания и для поле размера массива. Есть алгоритмы графа, где большие поля биты полезны, и вы должны быть знайте, что если вы используете логическое значение [], вы нужно почти ровно в 8 раз больше памяти, чем действительно необходимо (1 байт вместо 1 бита).

ЦП работают с определенной длиной типа данных. В случае 32-битных процессоров они имеют длину 32 бита и, следовательно, то, что вы называете int в Java. Все, что ниже или выше, должно быть заполнено или разделено на эту длину, прежде чем ЦП сможет обработать это. Это не займет много времени,

Логическое отображение было выполнено с учетом 32-битного ЦП. Значение int имеет 32 бита, поэтому его можно обработать за одну операцию.

Вот решение из Питера Норвига Java IAQ: Часто задаваемые вопросы для измерения размера (с некоторой неточностью):

static Runtime runtime = Runtime.getRuntime();
...
long start, end;
Object obj;
runtime.gc();
start = runtime.freememory();
obj = new Object(); // Or whatever you want to look at
end =  runtime.freememory();
System.out.println("That took " + (start-end) + " bytes.");

5-е издание Java in a Nutshell (O'Reilly) говорит, что булевый примитивный тип равен 1 байту. Это может быть неправильно, основываясь на том, что показывает исследование кучи. Интересно, есть ли у большинства JVM проблемы с выделением для переменных менее одного байта?