Ответ
Примитивные типы в Java имеют фиксированный, независимый от платформы размер, определенный спецификацией языка.
| Таблица размеров: | Тип | Размер | Диапазон значений |
|---|---|---|---|
byte |
1 байт | от -128 до 127 | |
short |
2 байта | от -32 768 до 32 767 | |
int |
4 байта | от -2³¹ до 2³¹-1 | |
long |
8 байт | от -2⁶³ до 2⁶³-1 | |
float |
4 байта | приблизительно ±3.4e+38F (IEEE 754) | |
double |
8 байт | приблизительно ±1.8e+308 (IEEE 754) | |
char |
2 байта | символы Unicode (от u0000 до uffff) |
|
boolean |
не определен | Обычно 1 байт, но зависит от JVM и контекста. |
Примеры и важные замечания:
int count = 100; // Занимает 4 байта в стеке или внутри объекта.
double sum = 123.45; // Занимает 8 байт.
boolean flag = true; // Фактический размер определяется JVM.- В массивах: Размер вычисляется как
(размер_элемента * количество) + заголовок_массива(обычно 12-16 байт). - Внутри объектов: Память может быть дополнена выравниванием (padding) для эффективного доступа процессора, поэтому общий размер объекта может быть немного больше суммы размеров его полей.
Ответ 18+ 🔞
А, ну вот, классика, блядь! Примитивные типы в Java. Ну что, думаешь, тут всё просто, как три копейки? Ёпта, щас разберёмся, но это пиздец как важно, если хочешь, чтобы твоя программа не жрала память, как голодный студент в столовой.
Смотри, в Java эти примитивы — они как фундамент, блядь. Размер у них жёстко прописан в спецификации, и он не зависит от того, на какой платформе ты эту хуйню запускаешь. На линуксе, на винде, на тостере — int всегда будет 4 байта. Это, можно сказать, святое, блядь.
| Таблица размеров, которую надо выжечь на подкорке: | Тип | Размер | Диапазон значений (вкратце, а то нихуя не понятно) |
|---|---|---|---|
byte |
1 байт | от -128 до 127 (маловато будет, но для мелких дел сойдёт) | |
short |
2 байта | от -32 768 до 32 767 (уже лучше, но всё равно тесновато) | |
int |
4 байта | от -2³¹ до 2³¹-1 (вот это наш золотой стандарт, ёпта!) | |
long |
8 байт | от -2⁶³ до 2⁶³-1 (охуеть, можно считать звёзды в галактике) | |
float |
4 байта | числа с плавающей точкой, ±3.4e+38F (но с точностью — беда, блядь) | |
double |
8 байт | тоже плавающая точка, но уже ±1.8e+308 (точнее, но всё равно не идеально) | |
char |
2 байта | символы Unicode (не просто буква, а целая сущность!) | |
boolean |
хз, честно | Обычно 1 байт, но JVM может его в коробочку спрятать, как захочет. |
Примеры, чтобы в голове отложилось:
int count = 100; // Твёрдые 4 байта. Куда денутся.
double sum = 123.45; // Целых 8 байт, жирный такой.
boolean flag = true; // А вот это загадка, ёпта. JVM сама решает, как его хранить.А теперь, внимание, ебаный рот, самое интересное!
- В массивах: Тут всё считается. Берёшь
размер_одного_элемента, хуяк наколичество, и прибавляешь сверху заголовок массива (это ещё 12-16 байт на организацию всей этой движухи). Так что массив из тысячиint— это не просто 4000 байт, а чуть больше, блядь. - Внутри объектов: Вот тут начинается цирк с выравниванием, или padding, ёпта. Процессор любит, когда данные аккуратненько лежат по определённым адресам. Поэтому JVM может натыкать между полями объекта пустых байтов, как пробок в бутылке. В итоге объект занимает места больше, чем просто сумма полей. Просто чтобы процессору было удобнее его жрать. Волшебство, блядь, да и только.
Короче, запомни: примитивы — это основа, размер фиксирован, но когда они собираются в кучки (массивы, объекты), там начинается своя магия с накладными расходами. Не забывай про это, когда будешь миллионы сущностей создавать, а потом удивляться, почему память кончилась.