# Целые числа в Java: теория и практика

## 1. Что такое целые числа и зачем они нужны

**Целое число** — это число без дробной части: ..., −3, −2, −1, 0, 1, 2, 3, ...

В программировании целые числа используются для:
- счёта объектов (количество учеников, итераций цикла);
- индексов массивов и коллекций;
- идентификаторов (номер заказа, ID пользователя);
- работы с денежными суммами в копейках/центах (чтобы избежать ошибок округления);
- битовых операций и работы с памятью.

> ⚠️ **Важно:** в Java нельзя хранить в целочисленной переменной дробное значение — компилятор выдаст ошибку или потребует явного приведения.

---

## 2. Примитивные целочисленные типы

В Java **4 примитивных целочисленных типа**, различающихся диапазоном и объёмом памяти:

| Тип | Размер | Диапазон | Применение |
|-----|--------|----------|------------|
| `byte` | 8 бит | от −128 до 127 | экономия памяти в массивах, работа с байтами |
| `short` | 16 бит | от −32 768 до 32 767 | редко, в основном в устаревшем коде |
| `int` | 32 бита | от −2 147 483 648 до 2 147 483 647 | **основной тип по умолчанию** |
| `long` | 64 бита | от −9.2·10¹⁸ до 9.2·10¹⁸ | большие числа, время в миллисекундах |

**Запомните:** по умолчанию любое целое литеральное число в Java имеет тип `int`. Чтобы получить `long`, добавьте суффикс `L`:

```java
int a = 2_000_000_000;      // ок
long b = 9_000_000_000L;    // без L будет ошибка компиляции
```

---

## 3. Объявление переменных и литералы

```java
byte  small  = 100;
short medium = 30_000;
int   normal = 1_000_000;
long  big    = 123_456_789_012L;

// Системы счисления:
int decimal = 255;         // 10-я
int hex     = 0xFF;        // 16-я  (префикс 0x)
int binary  = 0b1111_1111; // 2-я   (префикс 0b)
int octal   = 0377;        // 8-я   (ведущий 0)

// Подчёркивания для читаемости
int million = 1_000_000;
```

**Константы** (`final`) — значение нельзя изменить после инициализации:

```java
final int MAX_SCORE = 100;
// MAX_SCORE = 200; // ошибка компиляции
```

---

## 4. Ввод целых чисел (класс `Scanner`)

Самый простой способ — `java.util.Scanner`.

```java
import java.util.Scanner;

public class InputDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Введите целое число: ");
        int n = sc.nextInt();          // читает int

        System.out.print("Введите длинное число: ");
        long L = sc.nextLong();        // читает long

        System.out.print("Введите байт: ");
        byte b = sc.nextByte();

        System.out.println(String.format("Вы ввели: %d, %d, %d", n, L, b));
        sc.close();
    }
}
```

Для чтения из файла/строки можно использовать `Scanner(new File("input.txt"))` или `BufferedReader`.

---

## 5. Вывод целых чисел

```java
int x = 42;

// Если нужно вывести только число — подходит обычный println:
System.out.println(x);                       // 42

// Когда нужен текст или форматирование — String.format:
System.out.println(String.format("x = %d", x));

// Форматирование в разных системах счисления:
System.out.println(String.format("hex = %x, bin = %s",
        255, Integer.toBinaryString(255)));
// hex = ff, bin = 11111111

// Выравнивание и ширина поля:
System.out.println(String.format("|%5d|", 42));    // |   42|
System.out.println(String.format("|%-5d|", 42));   // |42   |
System.out.println(String.format("|%05d|", 42));   // |00042|
```

Часто используемые спецификаторы `String.format`:

| Спецификатор | Смысл |
|--------------|-------|
| `%d` | целое в 10-й системе |
| `%x` | 16-я система |
| `%o` | 8-я система |
| `%05d` | целое с ведущими нулями, ширина 5 |
| `%n` | перевод строки (переносимый) |

---

## 6. Основные операции

### 6.1 Арифметические

```java
int a = 17, b = 5;
System.out.println(a + b); // 22
System.out.println(a - b); // 12
System.out.println(a * b); // 85
System.out.println(a / b); // 3  — ЦЕЛОЧИСЛЕННОЕ деление
System.out.println(a % b); // 2  — остаток от деления
```

> ⚠️ Деление целых чисел **отбрасывает дробную часть**, а не округляет: `7 / 2 == 3`, `-7 / 2 == -3` (округление к нулю).

### 6.2 Операции присваивания

```java
int x = 10;
x += 5;   // x = 15
x -= 3;   // x = 12
x *= 2;   // x = 24
x /= 4;   // x = 6
x %= 4;   // x = 2
x++;      // x = 3
x--;      // x = 2
```

### 6.3 Сравнение

```java
int p = 5, q = 7;
boolean r1 = p == q;  // false
boolean r2 = p != q;  // true
boolean r3 = p <  q;  // true
boolean r4 = p >= q;  // false
```

### 6.4 Побитовые операции

```java
int m = 0b1100; // 12
int n = 0b1010; // 10
System.out.println(m & n);   // 8
System.out.println(m | n);   // 14
System.out.println(m ^ n);   // 6
System.out.println(~m);      // -13
System.out.println(m << 1);  // 24  (сдвиг влево = ×2)
System.out.println(m >> 1);  // 6   (сдвиг вправо)
System.out.println(m >>> 1); // 6   (беззнаковый сдвиг)
```

### 6.5 Приведение типов

**Автоматическое** (расширяющее) — от меньшего к большему:

```java
byte b = 100;
int  i = b;      // ок
long l = i;      // ок
```

**Явное** (сужающее) — от большего к меньшему, возможна потеря данных:

```java
int  big   = 300;
byte small = (byte) big;   // 300 % 256 = 44 (переполнение)
```

**Переполнение** — опасная ситуация: `int` не может выйти за пределы диапазона и «зацикливается»:

```java
int max = Integer.MAX_VALUE;
System.out.println(max + 1); // -2147483648
```

---

## 7. Критерии применимости целых чисел

Используйте целочисленный тип, если:

1. **Величина по своей природе дискретна** — количество, индекс, счётчик.
2. **Нужна точность без округлений** — деньги (лучше в копейках), ID, временные метки.
3. **Выполняются операции над целыми** — деление нацело, остаток, битовые сдвиги.
4. **Важна производительность** — целочисленная арифметика быстрее вещественной.
5. **Нужна экономия памяти** — например, `byte[]` для большого массива.

**Не используйте целые числа**, если:

- величина непрерывна (расстояние, температура, вес) — берите `double`/`float`;
- нужна высокая точность над дробными числами — `BigDecimal`.

**Выбор типа:**

- по умолчанию — `int`;
- если значения > 2·10⁹ или работа со временем в мс — `long`;
- для больших массивов малых чисел — `byte`/`short`;
- для чисел, не помещающихся ни в один примитив (> 9.2·10¹⁸) — `BigInteger`.

---

## 8. Классы стандартной библиотеки

### 8.1 Классы-обёртки: `Integer`, `Long`, `Short`, `Byte`

Каждому примитиву соответствует класс-обёртка. Нужен для:

- хранения в коллекциях (`ArrayList<Integer>`);
- использования полезных методов;
- `null`-значений (например, «значение отсутствует»).

```java
Integer obj = 42;        // автоупаковка (autoboxing)
int prim = obj;          // автораспаковка (unboxing)

// Полезные методы (там, где выводится только число — println):
System.out.println(Integer.MAX_VALUE);          // 2147483647
System.out.println(Integer.MIN_VALUE);          // -2147483648
System.out.println(Integer.parseInt("123"));    // 123
System.out.println(Integer.compare(3, 5));      // -1
System.out.println(Integer.max(3, 5));          // 5
System.out.println(Integer.sum(3, 5));          // 8
System.out.println(Integer.bitCount(7));        // 3
System.out.println(Integer.numberOfLeadingZeros(1)); // 31

// Там, где результат — строка — String.format:
System.out.println(String.format("%s", Integer.toBinaryString(10))); // 1010
System.out.println(String.format("%s", Integer.toHexString(255)));   // ff
```

> ⚠️ Сравнивайте объекты-обёртки через `.equals()`, а не `==`:
> ```java
> Integer a = 1000, b = 1000;
> System.out.println(a == b);        // false (разные объекты)
> System.out.println(a.equals(b));   // true
> ```
> Кэш `Integer` работает только для значений от −128 до 127, поэтому `Integer a = 100; Integer b = 100; a == b` даст `true`, но для 1000 — уже `false`.

### 8.2 `BigInteger` — для чисел произвольной длины

Когда `long` недостаточно (факториалы, криптография, длинная арифметика):

```java
import java.math.BigInteger;

BigInteger a = new BigInteger("123456789012345678901234567890");
BigInteger b = BigInteger.valueOf(987654321L);

System.out.println(a.add(b));       // сложение
System.out.println(a.subtract(b));  // вычитание
System.out.println(a.multiply(b));  // умножение
System.out.println(a.divide(b));    // деление
System.out.println(a.mod(b));       // остаток
System.out.println(a.pow(2));       // возведение в степень
System.out.println(a.gcd(b));       // НОД

// Факториал 100:
BigInteger fact = BigInteger.ONE;
for (int i = 2; i <= 100; i++)
    fact = fact.multiply(BigInteger.valueOf(i));
System.out.println(fact);
```

`BigInteger` **иммутабелен** — операции возвращают новый объект, а не меняют исходный.

### 8.3 `Math` — математические функции

Работает с `double`, но есть методы и для целых:

```java
System.out.println(Math.abs(-7));    // 7
System.out.println(Math.max(3, 8));  // 8
System.out.println(Math.min(3, 8));  // 3

// Math.pow / Math.sqrt возвращают double — для форматирования используем String.format:
System.out.println(String.format("%.1f", Math.pow(2, 10))); // 1024.0
System.out.println(String.format("%.1f", Math.sqrt(144)));  // 12.0
```

### 8.4 `Random` — генерация случайных чисел

```java
import java.util.Random;

Random rnd = new Random();
int r1 = rnd.nextInt();          // любое int
int r2 = rnd.nextInt(100);       // [0, 100)
int r3 = rnd.nextInt(50) + 1;    // [1, 50]

System.out.println(r2);
System.out.println(r3);

// Начиная с Java 17 — RandomGenerator:
// int r = java.util.random.RandomGenerator.getDefault().nextInt(1, 101);
```

---

## 9. Мини-пример: сумма цифр числа

```java
import java.util.Scanner;

public class SumDigits {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Введите целое число: ");
        long n = Math.abs(sc.nextLong());

        int sum = 0;
        while (n > 0) {
            sum += (int)(n % 10); // последняя цифра
            n /= 10;              // отбрасываем её
        }
        System.out.println(sum);
    }
}
```

Здесь задействованы: `long`, `%` и `/`, приведение типов, ввод/вывод, `Math.abs`.

---

## 10. Типичные ошибки

| Ошибка | Как избежать |
|--------|--------------|
| Деление нацело вместо дробного | Привести один операнд: `(double) a / b` |
| Переполнение `int` | Использовать `long` или `Math.addExact` (бросает исключение) |
| Сравнение обёрток через `==` | Использовать `.equals()` |
| Забыть `L` у большого литерала | `long x = 3000000000L;` |
| `NullPointerException` при распаковке | Проверять на `null` перед присваиванием в примитив |
| Потеря точности при `(int) longValue` | Проверять диапазон или использовать `Math.toIntExact` |

```java
// Безопасные операции (Java 8+):
int sum = Math.addExact(1_000_000_000, 1_000_000_000); // ArithmeticException
int prod = Math.multiplyExact(100_000, 100_000);       // исключение
```

---

## 11. Итоги

- В Java 4 примитивных целочисленных типа; основной — `int`, для больших значений — `long`.
- По умолчанию целые литералы — `int`, для `long` нужен суффикс `L`.
- Деление целых **отбрасывает** дробную часть, остаток даёт `%`.
- Для чисел > 9.2·10¹⁸ используйте `BigInteger`.
- Для коллекций и `null` — классы-обёртки (`Integer`, `Long`, ...).
- Всегда проверяйте возможность **переполнения** и корректность приведения типов.