Сколько byte в long?

Размер типа long в Java

Прямой ответ

В типе long ровно 8 байт (64 бита).

Проверка в коде

public class LongSize {
    public static void main(String[] args) {
        // Способ 1: через Long.BYTES константа
        System.out.println(Long.BYTES); // 8
        
        // Способ 2: через вычисление
        long value = 0L;
        System.out.println(value.getClass().getName()); // java.lang.Long
        
        // Способ 3: через диапазон
        System.out.println(Long.MIN_VALUE); // -9223372036854775808
        System.out.println(Long.MAX_VALUE); // 9223372036854775807
        
        // 2^64 = 18446744073709551616 значений
        // С учётом знака: -(2^63) до (2^63 - 1)
    }
}

Структура long в памяти

64 бита = 8 байт

Младший бит (LSB)                          Старший бит (MSB)
v                                                           v
0 0 0 0 0 0 0 0 | 0 0 0 0 0 0 0 0 | ... | 0 0 0 0 0 0 0 0
└─────────────┘   └─────────────┘       └─────────────┘
   Байт 0           Байт 1                 Байт 7

Примеры значений

public class LongExamples {
    public static void main(String[] args) {
        // Минимальное значение (-2^63)
        long minValue = Long.MIN_VALUE;
        System.out.println(minValue); // -9223372036854775808
        
        // Максимальное значение (2^63 - 1)
        long maxValue = Long.MAX_VALUE;
        System.out.println(maxValue); // 9223372036854775807
        
        // Переполнение
        long overflow = maxValue + 1;
        System.out.println(overflow); // -9223372036854775808 (MIN_VALUE)
        // Это называется wraparound
        
        // Недополнение
        long underflow = minValue - 1;
        System.out.println(underflow); // 9223372036854775807 (MAX_VALUE)
    }
}

Сравнение с другими примитивными типами

public class PrimitiveTypeSizes {
    public static void main(String[] args) {
        System.out.println("byte: " + Byte.BYTES + " bytes");           // 1 byte
        System.out.println("short: " + Short.BYTES + " bytes");         // 2 bytes
        System.out.println("int: " + Integer.BYTES + " bytes");         // 4 bytes
        System.out.println("long: " + Long.BYTES + " bytes");           // 8 bytes
        System.out.println("float: " + Float.BYTES + " bytes");         // 4 bytes
        System.out.println("double: " + Double.BYTES + " bytes");       // 8 bytes
        System.out.println("boolean: " + Byte.BYTES + " bytes (min)");  // зависит от JVM
        System.out.println("char: " + Character.BYTES + " bytes");      // 2 bytes
    }
}

// Вывод:
// byte: 1 bytes
// short: 2 bytes
// int: 4 bytes
// long: 8 bytes
// float: 4 bytes
// double: 8 bytes
// boolean: 1 bytes (минимум)
// char: 2 bytes

Практическое применение

1. Выбор типа для ID

// Для базы данных с миллионами записей
public class User {
    // int достаточно: 2^31 = 2 млрд
    private int id; // Хватит на 2 млрд пользователей
    
    // Для UUID лучше String
    private String uuid; // Глобально уникальный
}

// Для timestamp'ов
public class Event {
    // long необходим: миллисекунды с 1970 года
    private long timestamp = System.currentTimeMillis();
    
    // Без long:
    // int максимум: ~24.8 дней (68 лет)
    // Переполнится в год 1970 + (2^31)/1000/86400 = ~68 лет
}

2. Битовые операции

public class BitOperations {
    public static void main(String[] args) {
        long value = 1L; // 0000...0001 (63 нулей справа)
        
        // Сдвиг влево
        long shiftLeft = value << 32; // 0000...0001 0000...0000 (32 нуля)
        System.out.println(shiftLeft); // 4294967296
        
        // Сдвиг вправо
        long shiftRight = shiftLeft >> 16; // сдвиг на 16 позиций
        System.out.println(shiftRight); // 65536
        
        // Все 64 бита установлены
        long allOnes = 0xFFFFFFFFFFFFFFFFL;
        System.out.println(allOnes); // -1 (в two's complement)
        
        // Первые 32 бита установлены
        long mask = 0xFFFFFFFF00000000L;
    }
}

3. Работа с большими числами

public class LargeNumbers {
    public static void main(String[] args) {
        // long подходит для финансовых операций
        long balanceCents = 999999999999L; // 9,999,999,999.99 руб
        
        // Но для ещё больших чисел используйте BigDecimal
        java.math.BigDecimal balance = 
            new java.math.BigDecimal("999999999999.99");
        
        // Для ещё больших целых чисел
        java.math.BigInteger huge = 
            new java.math.BigInteger("123456789012345678901234567890");
    }
}

Факты о long

1. 64-битный знаковый тип — от -2^63 до 2^63-1
2. Суффикс L — нужен при инициализации (1L, 0L)
3. Поведение при переполнении — wraparound (как в C)
4. Поточно-безопасность — присвоение атомарно, но обновление не atomically
5. Alignment в памяти — может выравниваться на 8 байт

public class LongDetails {
    public static void main(String[] args) {
        // ВАЖНО: обновление long НЕ atomically!
        long nonAtomicLong = 0L; // 2 операции по 32 бита
        
        // Для потокобезопасной работы используйте:
        java.util.concurrent.atomic.AtomicLong atomicLong = 
            new java.util.concurrent.atomic.AtomicLong(0);
        
        atomicLong.incrementAndGet(); // Atomically
    }
}

Заключение

long — это 8 байт, содержащих 64 бита данных. Это стандартный размер для:

• Больших целых чисел
• Timestamp'ов
• ID'шек в больших системах
• Битовых операций с большими масками

Выбор между int и long зависит от диапазона значений, который вам нужен.