Что происходит в префиксной форме инкремента

Префиксная форма инкремента (++prefix)

Базовое объяснение

Префиксный инкремент (++prefix) и постфиксный инкремент (postfix++) работают по-разному:

int a = 5;
int result1 = ++a;  // префиксный инкремент
// ++a: a становится 6, затем возвращает 6
System.out.println(result1);  // 6
System.out.println(a);        // 6

int b = 5;
int result2 = b++;  // постфиксный инкремент
// b++: возвращает 5, затем b становится 6
System.out.println(result2);  // 5
System.out.println(b);        // 6

Префиксный инкремент: ++prefix

Префиксный инкремент сначала увеличивает значение, потом возвращает новое значение:

public class PrefixIncrementDemo {
    public static void main(String[] args) {
        int x = 10;
        
        // Префиксный инкремент
        int y = ++x;
        
        // Это происходит в следующем порядке:
        // 1. x увеличивается: x = 11
        // 2. новое значение x (11) присваивается y
        // 3. y = 11
        
        System.out.println("x = " + x);  // 11
        System.out.println("y = " + y);  // 11
    }
}

Постфиксный инкремент: postfix++

Постфиксный инкремент сначала возвращает текущее значение, потом увеличивает переменную:

public class PostfixIncrementDemo {
    public static void main(String[] args) {
        int x = 10;
        
        // Постфиксный инкремент
        int y = x++;
        
        // Это происходит в следующем порядке:
        // 1. текущее значение x (10) сохраняется во временную переменную
        // 2. x увеличивается: x = 11
        // 3. временное значение (10) присваивается y
        // 4. y = 10
        
        System.out.println("x = " + x);  // 11
        System.out.println("y = " + y);  // 10
    }
}

Внутренняя реализация

Компилятор Java преобразует эти операции так:

// Префиксный инкремент: ++x
int result = ++x;
// Компилируется в:
int result;
x = x + 1;
result = x;  // возвращает новое значение

// Постфиксный инкремент: x++
int result = x++;
// Компилируется в:
int result;
int temp = x;  // сохраняем старое значение
x = x + 1;    // увеличиваем
result = temp;  // возвращаем старое значение

Постфиксный требует создание временной переменной для хранения старого значения!

Производительность

Для примитивов разница минимальна, но для объектов она заметна:

public class PerformanceComparison {
    public static void main(String[] args) {
        // Тест 1: Примитивные типы
        long start = System.nanoTime();
        int counter = 0;
        for (int i = 0; i < 100_000_000; i++) {
            ++counter;  // префиксный
        }
        System.out.println("Префикс (примитив): " + (System.nanoTime() - start));
        
        counter = 0;
        start = System.nanoTime();
        for (int i = 0; i < 100_000_000; i++) {
            counter++;  // постфиксный
        }
        System.out.println("Постфикс (примитив): " + (System.nanoTime() - start));
        
        // Для примитивов JIT компилятор оптимизирует обе версии
    }
}

Итераторы и коллекции

Разница проявляется более ярко с итераторами:

public class IteratorDemo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        
        // ✅ ХОРОШО - префиксный инкремент
        Iterator<Integer> it1 = list.iterator();
        while (it1.hasNext()) {
            ++counter;  // нет создания временного объекта
        }
        
        // ❌ МЕНЕЕ ЭФФЕКТИВНО - постфиксный инкремент
        Iterator<Integer> it2 = list.iterator();
        while (it2.hasNext()) {
            counter++;  // создаёт временный объект для хранения старого значения
        }
    }
}

В цикле for

В обычном цикле for разница минимальна:

// Оба варианта одинаково эффективны для примитивов
for (int i = 0; i < 1000; i++) {
    // использование i
}

for (int i = 0; i < 1000; ++i) {
    // использование i
}

// JIT компилятор оптимизирует обе версии одинаково

С обёртками (Integer, Long и т.д.)

С обёртками (wrapper classes) разница более заметна:

public class WrapperIncrementDemo {
    public static void main(String[] args) {
        Integer a = 5;
        Integer b = 5;
        
        // Префиксный инкремент
        Integer result1 = ++a;
        // 1. Unbox: a становится примитивом 5
        // 2. Инкремент: 5 -> 6
        // 3. Box: результат 6 упаковывается в Integer
        // 4. Присваивание: result1 = new Integer(6)
        
        // Постфиксный инкремент
        Integer result2 = b++;
        // 1. Unbox: b становится примитивом 5
        // 2. Создание временной переменной: temp = 5
        // 3. Инкремент: 5 -> 6
        // 4. Box: результат 6 упаковывается в Integer
        // 5. Box: результат 5 (из temp) упаковывается в Integer
        // 6. Присваивание: result2 = new Integer(5)
        
        // Постфиксный создаёт ДОПОЛНИТЕЛЬНЫЙ объект Integer!
    }
}

Лучшие практики

// ✅ ЛУЧШАЯ ПРАКТИКА - используй префиксный инкремент
for (int i = 0; i < 1000; ++i) {
    // код
}

// ❌ ИЗБЕГАЙ постфиксного когда результат не нужен
for (int i = 0; i < 1000; i++) {  // неоптимально
    // код
}

// ✅ Если нужно старое значение - используй постфиксный
int oldValue = x++;  // нужно старое значение

// ✅ Если нужно новое значение - используй префиксный
int newValue = ++x;  // нужно новое значение

// ✅ В Collections используй префиксный
List<String> items = new ArrayList<>();
for (int i = 0; i < items.size(); ++i) {  // лучше
    String item = items.get(i);
}

Вывод

Префиксный инкремент (++x) увеличивает значение и возвращает новое значение. Постфиксный инкремент (x++) сначала возвращает текущее значение, потом увеличивает переменную, создавая при этом временную переменную. Для примитивов разница минимальна благодаря JIT оптимизации, но префиксный инкремент является хорошей практикой по привычке и производительности с обёртками.