import java.util.*;

public class Task141024 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "orange"));
        list.add(1, "grape");
        list.set(2, "pear");
        
        for (Iterator<String> it = list.iterator(); it.hasNext();) {
            String fruit = it.next();
            if (fruit.equals("pear")) {
                it.remove();
            }
        }
        
        System.out.println(list);
    }
}

java -Xms2g -Xmx4g -XX:+UseG1GC -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintTenuringDistribution -XX:+PrintGCTimeStamps MyApp
Этот запуск включает G1 GC, устанавливает начальный размер кучи на 2 ГБ и максимальный на 4 ГБ, а также выводит подробные логи.

java -Xms1g -Xmx2g -XX:+UseG1GC -Xlog:gc:gc.log -XX:+PrintGCDetails MyApp
После выполнения мы можем открыть файл gc.log и проанализировать все события, связанные с GC, например, частоту минорных и мажорных сборок, продолжительность пауз и использование памяти.

public class GCExample {
    public static void main(String[] args) {
        for (int i = 0; i < 10_000_000; i++) {
            createObjects();
        }
    }

    private static void createObjects() {
        String[] strings = new String[1000];
        for (int i = 0; i < strings.length; i++) {
            strings[i] = new String("Object " + i);
        }
    }
}

java -Xms512m -Xmx1g -XX:+UseG1GC -XX:+PrintGCDetails -XX:+PrintGCDateStamps GCExample

StringBuilder sb = new StringBuilder("Hello, World!");
В данном примере переменная sb ссылается на объект типа StringBuilder. Пока существует ссылка sb, объект не может быть удален сборщиком мусора, даже если больше ни одна часть программы не обращается к нему.

import java.lang.ref.SoftReference;

public class SoftReferenceExample {
    public static void main(String[] args) {
        // Создаем сильную ссылку на объект
        String strongReference = new String("Hello, World!");
        
        // Создаем мягкую ссылку на объект
        SoftReference<String> softReference = new SoftReference<>(strongReference);
        
        // Убираем сильную ссылку
        strongReference = null;
        
        // Получаем объект из мягкой ссылки
        if (softReference.get() != null) {
            System.out.println("Object is still in memory: " + softReference.get());
        } else {
            System.out.println("Object has been collected by GC.");
        }
    }
}
Если памяти достаточно, вывод будет: Object is still in memory: Hello, World!. Но если память заканчивается, объект будет удален, и ссылка softReference.get() вернет null.

import java.lang.ref.WeakReference;

public class WeakReferenceExample {
    public static void main(String[] args) {
        // Создаем сильную ссылку на объект
        String strongReference = new String("Weak Reference Example");
        
        // Создаем слабую ссылку на объект
        WeakReference<String> weakReference = new WeakReference<>(strongReference);
        
        // Убираем сильную ссылку
        strongReference = null;
        
        // Вызываем сборщик мусора
        System.gc();
        
        // Проверяем наличие объекта в памяти
        if (weakReference.get() != null) {
            System.out.println("Object is still in memory: " + weakReference.get());
        } else {
            System.out.println("Object has been collected by GC.");
        }
    }
}

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;

public class PhantomReferenceExample {
    public static void main(String[] args) {
        String phantomReferenceString = new String("Phantom Reference Example");
        
        // Создаем очередь для фантомных ссылок
        ReferenceQueue<String> referenceQueue = new ReferenceQueue<>();
        
        // Создаем фантомную ссылку
        PhantomReference<String> phantomReference = new PhantomReference<>(phantomReferenceString, referenceQueue);
        
        // Удаляем сильную ссылку
        phantomReferenceString = null;
        
        // Вызываем сборщик мусора
        System.gc();
        
        // Проверяем, помещена ли фантомная ссылка в очередь
        Reference<? extends String> ref = referenceQueue.poll();
        if (ref != null) {
            System.out.println("Object has been collected and reference is in the queue.");
        } else {
            System.out.println("Object is not yet collected by GC.");
        }
    }
}
В этом примере вывод покажет, что фантомная ссылка была добавлена в очередь после удаления объекта. Это означает, что объект был удален из памяти, и теперь его можно использовать для выполнения дополнительных действий.

public class Task151024 {
    static Task151024 obj;

    public static void main(String[] args) {
        Task151024 m1 = new Task151024();
        Task151024 m2 = new Task151024();

        m1 = null;
        obj = m2;
        m2 = null;

        System.gc();
        System.out.println("Done");
    }

    @Override
    protected void finalize() {
        System.out.println("Object collected");
    }
}

import java.util.ArrayList;
import java.util.List;

public class MemoryLeakExample {
    private static List<Object> list = new ArrayList<>();
    
    public static void main(String[] args) {
        // Создаем утечку памяти, добавляя объекты в список, но никогда их не удаляя
        while (true) {
            list.add(new Object());
        }
    }
}
В этом примере список list продолжает расти, так как новые объекты постоянно добавляются, но никогда не удаляются. В итоге программа столкнется с OutOfMemoryError.

public class GradualMemoryLeak {
    private static List<String> cache = new ArrayList<>();
    
    public void addData() {
        for (int i = 0; i < 1000; i++) {
            cache.add("Data-" + i);
        }
    }
}
Если метод addData вызывается многократно без очистки списка cache, то список будет постоянно увеличиваться, вызывая утечку памяти.

public class StaticFieldMemoryLeak {
    private static List<Object> staticList = new ArrayList<>();
    
    public void addObject(Object obj) {
        staticList.add(obj);
    }
}
Здесь статическое поле staticList сохраняет все добавленные объекты, и они никогда не удаляются, что приводит к утечке памяти.

public class EventListenerMemoryLeak {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Example");
        JButton button = new JButton("Click Me");
        button.addActionListener(e -> System.out.println("Button clicked!"));

        frame.add(button);
        frame.setSize(200, 200);
        frame.setVisible(true);
        // Закрываем окно, но слушатель остается в памяти
        frame.dispose();
    }
}
В этом примере, если не удалить слушатели ActionListener перед dispose(), объект button и все связанные объекты будут продолжать удерживаться в памяти.

public class ThreadMemoryLeak {
    public void createThread() {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(10000);  // Ожидание в течение длительного времени
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread.start();
    }
}
Если потоки создаются многократно и не завершаются корректно, то их память будет постепенно заполняться.

jmap -dump:format=b,file=heap_dump.hprof <PID>

import java.io.*;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
            System.out.println(reader.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
В этом примере ресурс автоматически закрывается, даже если возникает исключение.

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;

// Компонент класса
@Component
class Engine {
    public void start() {
        System.out.println("Engine is starting...");
    }
}

// Компонент класса, где внедряется зависимость Engine
@Component
class Car {
    private final Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void drive() {
        engine.start();
        System.out.println("Car is driving...");
    }
}

// Конфигурация Spring Context
public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext("com.example");
        Car car = context.getBean(Car.class);
        car.drive();
    }
}
В этом примере Car зависит от компонента Engine, и Spring автоматически внедряет его в объект Car. Благодаря аннотации @Autowired, зависимости передаются автоматически, снижая связность классов и упрощая конфигурацию приложения.

import java.util.Arrays;

public class Task161024 {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 3, 1};
        
        Arrays.sort(arr, 1, 4);
        
        System.out.println(Arrays.toString(arr));
    }
}