В каком формате числа хранятся в двоичной системе

Форматы хранения чисел в двоичной системе

Основы двоичного представления

Все числа в компьютере хранятся в двоичной системе (база 2) с использованием битов (0 и 1).

1. Целые числа

Беззнаковые целые (Unsigned)

Десятичное    Двоичное
0              00000000
1              00000001
5              00000101
255            11111111

Для 8-битного беззнакового: 0 до 255

Знаковые целые (Signed) — дополнительный код

Это стандарт в Java и большинстве языков:

Десятичное    Дополнительный код (8 бит)
+127           01111111
+5             00000101
+0             00000000
-1             11111111
-5             11111011
-128           10000000

Правило для -X: инверсия(X) + 1

2. Типы данных в Java

byte (8 бит, знаковый)

byte max = 127;    // 01111111
byte min = -128;   // 10000000
byte negOne = -1;  // 11111111

String binary = Integer.toBinaryString(127 & 0xFF);

short (16 бит, знаковый)

short max = 32767;      // 0111111111111111
short min = -32768;     // 1000000000000000

int (32 бита, знаковый)

int max = 2147483647;   // 01111111...111111
int min = -2147483648;  // 10000000...000000

String binary = Integer.toBinaryString(42);  // 101010

long (64 бита, знаковый)

long max = 9223372036854775807L;
long min = -9223372036854775808L;

3. Числа с плавающей точкой

float (32 бита) — IEEE 754

Структура:
[знак: 1][экспонента: 8][мантисса: 23]

Пример: 5.5
5 = 101, 0.5 = 0.1
5.5 = 1.011 * 2^2

float f = 5.5f;
int bits = Float.floatToIntBits(f);
String binary = Integer.toBinaryString(bits);

double (64 бита) — IEEE 754

Структура:
[знак: 1][экспонента: 11][мантисса: 52]

double d = 5.5;
long bits = Double.doubleToLongBits(d);

4. Побитовые операции

int a = 5;    // 0000 0101
int b = 3;    // 0000 0011

int and = a & b;     // 0000 0001 = 1
int or = a | b;      // 0000 0111 = 7
int xor = a ^ b;     // 0000 0110 = 6
int not = ~a;        // 1111 1010 = -6

int leftShift = a << 1;    // 0000 1010 = 10
int rightShift = a >> 1;   // 0000 0010 = 2

5. Проверка битов

int num = 5;  // 0000 0101

// Проверка наличия бита
boolean hasBit0 = (num & (1 << 0)) != 0;  // true
boolean hasBit1 = (num & (1 << 1)) != 0;  // false

// Установка бита
int setBit = num | (1 << 1);  // 0000 0111 = 7

// Удаление бита
int clearBit = num & ~(1 << 0);  // 0000 0100 = 4

// Инверсия бита
int toggleBit = num ^ (1 << 1);  // 0000 0111 = 7

6. Специальные значения IEEE 754

float posInf = Float.POSITIVE_INFINITY;
float negInf = Float.NEGATIVE_INFINITY;
float nan = Float.NaN;

float x = 1.0f / 0.0f;  // Infinity
System.out.println(Float.isInfinite(x));  // true
System.out.println(Float.isNaN(x));       // false

7. Важные моменты

// Дополнительный код эффективно представляет отрицательные
int negOne = -1;  // все единицы в двоичном

// Переполнение
int max = Integer.MAX_VALUE;
int overflow = max + 1;  // переполнение: становится минусом

// Потеря точности с float
float f = 0.1f + 0.2f;  // 0.30000004 вместо 0.3
double d = 0.1 + 0.2;   // 0.30000000000000004

Заключение

Целые числа в Java хранятся в дополнительном коде (Two Complement), что позволяет эффективно представлять положительные и отрицательные значения. Числа с плавающей точкой используют стандарт IEEE 754 с отдельными полями для знака, экспоненты и мантиссы. Побитовые операции позволяют работать с отдельными битами для оптимизации и специализированных вычислений.