PrepBro
← Назад к вопросам

Какие ограничения целого числа

1.8 Middle🔥 141 комментариев
#Docker, Kubernetes и DevOps#Основы Java

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI22 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

Ограничения целого числа (Integer Constraints)

В Java и базах данных целые числа имеют严格 ограничения по размеру, диапазону и представлению. Разработчик должен правильно выбирать типы данных, чтобы избежать переполнений, потери данных и security проблем.

1. Диапазоны целых типов данных в Java

Основные примитивные типы:

public class IntegerRanges {
    // byte: 8 бит, два дополнения (Two's Complement)
    public static final byte BYTE_MIN = Byte.MIN_VALUE;    // -128
    public static final byte BYTE_MAX = Byte.MAX_VALUE;    // 127
    
    // short: 16 бит
    public static final short SHORT_MIN = Short.MIN_VALUE;  // -32,768
    public static final short SHORT_MAX = Short.MAX_VALUE;  // 32,767
    
    // int: 32 бита (по умолчанию в Java)
    public static final int INT_MIN = Integer.MIN_VALUE;    // -2,147,483,648
    public static final int INT_MAX = Integer.MAX_VALUE;    // 2,147,483,647
    
    // long: 64 бита
    public static final long LONG_MIN = Long.MIN_VALUE;     // -9,223,372,036,854,775,808
    public static final long LONG_MAX = Long.MAX_VALUE;     // 9,223,372,036,854,775,807
    
    // BigInteger: неограниченный размер
    BigInteger huge = new BigInteger("99999999999999999999999999999");
}

Сравнение в таблице:

ТипРазмерМинимумМаксимум
byte8 бит-128127
short16 бит-32,76832,767
int32 бита-2,147,483,6482,147,483,647
long64 бита-9.2 × 10^189.2 × 10^18
BigIntegerНеограниченный∞∞

2. Integer Overflow (Переполнение целого числа)

Проблема: Когда число превышает максимальное значение, оно оборачивается

public class OverflowDemo {
    public static void main(String[] args) {
        // int overflow
        int max = Integer.MAX_VALUE;  // 2,147,483,647
        int overflow = max + 1;       // -2,147,483,648 (обернулось!)
        
        System.out.println("max: " + max);      // 2147483647
        System.out.println("overflow: " + overflow);  // -2147483648
        
        // long overflow
        long longMax = Long.MAX_VALUE;
        long longOverflow = longMax + 1;  // -9,223,372,036,854,775,808
    }
}

Почему это опасно:

// ❌ Критическая уязвимость в коде платежей
public long calculateTotal(int price, int quantity) {
    return price * quantity;  // Переполнение если числа большие!
    // price = 1,000,000
    // quantity = 5,000
    // Результат: -1,705,032,704 вместо 5,000,000,000
}

// ✅ Правильно
public long calculateTotal(long price, long quantity) {
    return price * quantity;
}

// ✅ Или с проверкой
public long calculateTotalSafe(int price, int quantity) {
    // Проверить переполнение
    if (price > 0 && quantity > Integer.MAX_VALUE / price) {
        throw new ArithmeticException("Overflow detected");
    }
    return (long) price * quantity;
}

Real world examples:

// Пример 1: Расчет дней до даты
public long daysSinceEpoch(LocalDate date) {
    // java.time использует long чтобы избежать overflow
    return ChronoUnit.DAYS.between(Instant.EPOCH, date.atStartOfDay(ZoneId.of("UTC")));
}

// Пример 2: Timestamp в миллисекундах
public long getCurrentTimeMillis() {
    // System.currentTimeMillis() возвращает long
    // int был бы переполнен через ~24 дня!
    return System.currentTimeMillis();
}

// Пример 3: Размер файла
public long getFileSizeBytes(File file) {
    // int был бы переполнен для файлов > 2GB
    return file.length();  // Возвращает long
}

3. Ограничения в базах данных

PostgreSQL/MySQL целые типы:

-- SMALLINT: 16 бит (-32,768 до 32,767)
CREATE TABLE age_table (
    age SMALLINT  -- Хорошо для возраста (0-150)
);

-- INTEGER: 32 бита (аналог Java int)
CREATE TABLE id_table (
    id INTEGER PRIMARY KEY  -- До 2 млрд записей
);

-- BIGINT: 64 бита (аналог Java long)
CREATE TABLE user_count (
    count BIGINT  -- Для больших чисел
);

-- SERIAL / BIGSERIAL: автоинкремент
CREATE TABLE users (
    id SERIAL PRIMARY KEY,      -- int auto-increment
    -- или
    id BIGSERIAL PRIMARY KEY    -- long auto-increment (для больших таблиц)
);

JPA маппинг:

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;  // BIGSERIAL в БД
    
    @Column(columnDefinition = "smallint")
    private Short age;  // SMALLINT в БД
    
    @Column(columnDefinition = "bigint")
    private Long totalSpent;  // BIGINT в БД
}

4. Выбор правильного типа для разных случаев

Случай 1: ID и Primary Keys

// ❌ Неправильно
public class User {
    @Id
    private int id;  // Max ~2 млрд записей
    // Если таблица растет быстро, переполнится!
}

// ✅ Правильно
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;  // Можно 9 * 10^18 записей
    
    // Или UUID (рекомендуется для распределённых систем)
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private UUID id;
}

Случай 2: Финансовые операции

// ❌ ОПАСНО
public class Account {
    private int balance;  // Максимум ~2 млрд копеек = 20 млн рублей
    // Какая-то операция переполнит счет!
}

// ✅ Правильно: Long + проверка переполнения
public class Account {
    private long balance;  // В копейках/центах
    
    public void deposit(long amount) {
        if (balance > Long.MAX_VALUE - amount) {
            throw new ArithmeticException("Balance overflow");
        }
        balance += amount;
    }
}

// ✅ Или BigDecimal (лучший вариант)
public class Account {
    @Column(precision = 19, scale = 2)  // DECIMAL(19,2)
    private BigDecimal balance;  // 99999999999999999.99
    
    public void deposit(BigDecimal amount) {
        balance = balance.add(amount);
    }
}

Случай 3: Счетчики

// ❌ Может переполниться
public class Counter {
    private int count = 0;
    
    public void increment() {
        count++;  // После 2 млрд инкрементов переполнится!
    }
}

// ✅ Правильно
public class Counter {
    private long count = 0;  // Переполнится через 290 млрд лет инкремента
    
    // Или AtomicLong для многопоточности
    private AtomicLong count = new AtomicLong(0);
}

// ✅ Или с проверкой
public void increment() {
    if (count >= Long.MAX_VALUE) {
        throw new ArithmeticException("Counter overflow");
    }
    count++;
}

5. Знаковые и беззнаковые числа

В Java нет встроенного типа для беззнаковых целых чисел (в отличие от C/C++)

// Java старается избежать беззнаковых:
// - Все операции знаковые
// - Биты кодируют знак в two's complement

// Но есть утилиты для работы с беззнаковыми:
public class UnsignedExample {
    public static void main(String[] args) {
        // Трактовать int как unsigned
        int value = -1;  // В памяти: 0xFFFFFFFF
        long unsigned = Integer.toUnsignedLong(value);  // 4,294,967,295
        
        System.out.println(unsigned);  // 4294967295
        
        // Обратно
        int back = (int) unsigned;
        System.out.println(back);  // -1
    }
}

6. Two's Complement представление

Как хранятся отрицательные числа:

public class TwosComplement {
    public static void main(String[] args) {
        // Для byte (8 бит):
        byte positiveOne = 1;     // 0000 0001
        byte negativeOne = -1;    // 1111 1111 (это -1 в two's complement)
        
        System.out.println(Integer.toBinaryString(positiveOne & 0xFF));  // 00000001
        System.out.println(Integer.toBinaryString(negativeOne & 0xFF));  // 11111111
        
        // Почему это важно:
        // 1. Вычитание реализуется как сложение с отрицательным числом
        // 2. Только один ноль (не +0 и -0)
        // 3. Диапазон асимметричен: -128...127 (для byte)
    }
}

7. Строговых проверок при разборе строк

public class ParseExample {
    public static void main(String[] args) {
        // ❌ Может выбросить NumberFormatException
        int value = Integer.parseInt("99999999999999999");  // Overflow!
        // Exception: For input string: "99999999999999999"
        
        // ✅ Правильно
        try {
            int value = Integer.parseInt("123");
            System.out.println(value);
        } catch (NumberFormatException e) {
            System.err.println("Invalid number format");
        }
        
        // ✅ С проверкой диапазона
        String input = "99999999999999999";
        try {
            long value = Long.parseLong(input);
            if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
                System.err.println("Out of int range");
            }
        } catch (NumberFormatException e) {
            System.err.println("Invalid format");
        }
        
        // ✅ Лучший вариант: BigInteger
        BigInteger big = new BigInteger(input);
    }
}

8. Bitwise операции и ограничения

public class BitwiseExample {
    public static void main(String[] args) {
        // Left shift может привести к overflow
        int value = 1 << 31;  // Становится Integer.MIN_VALUE (-2147483648)
        
        // Right shift vs Unsigned right shift
        int neg = -1;
        System.out.println(neg >> 1);   // -1 (знак сохраняется)
        System.out.println(neg >>> 1);  // 2147483647 (беззнаковый сдвиг)
    }
}

9. Тестирование ограничений

@Test
public void testIntegerOverflow() {
    int max = Integer.MAX_VALUE;
    int overflow = max + 1;
    
    // Проверить что произошел overflow
    assertTrue(overflow < max);
    assertEquals(Integer.MIN_VALUE, overflow);
}

@Test
public void testCalculateTotalWithOverflow() {
    // Должно выброситься исключение
    assertThrows(ArithmeticException.class, () -> {
        calculateTotalSafe(Integer.MAX_VALUE, 2);
    });
}

@Test
public void testParseInvalidNumber() {
    assertThrows(NumberFormatException.class, () -> {
        Integer.parseInt("not a number");
    });
    
    // Overflow при парсинге
    assertThrows(NumberFormatException.class, () -> {
        Integer.parseInt("99999999999999999");
    });
}

Best Practices

✅ 1. Выбирай правильный тип:
   - ID базы данных: Long (BIGSERIAL)
   - Финансовые суммы: BigDecimal
   - Счетчики: Long или AtomicLong
   - Возраст/статус: Enum или byte

✅ 2. Проверяй переполнение при математических операциях:
   if (a > Long.MAX_VALUE - b) {
       throw new ArithmeticException("Overflow");
   }

✅ 3. Будь аккуратен с parseLong/parseInt:
   try { ... } catch (NumberFormatException e) { ... }

✅ 4. Документируй ограничения в коде:
   /**
    * @param price должен быть > 0 и < Integer.MAX_VALUE
    */
   public void validatePrice(int price) { ... }

✅ 5. Используй статические проверки (linters):
   SpotBugs, IntelliJ IDEA warnings

На собеседовании

Покажи понимание:

  1. Диапазоны типов — знать INT_MAX, LONG_MAX
  2. Overflow поведение — как оно происходит и почему
  3. Выбор типа — когда использовать int/long/BigInteger
  4. Security — как overflow может привести к уязвимостям
  5. Database типы — SMALLINT, INTEGER, BIGINT в БД
  6. Practical примеры — финансовые операции, ID, счетчики
  7. Тестирование — как проверять граничные значения

Это покажет то, что ты пишешь надежный код, думая о граничных значениях.