🔥 Расскажи про Statement и PreparedStatement

Statement и PreparedStatement — интерфейсы JDBC для выполнения SQL-запросов в Java. Они позволяют взаимодействовать с базой данных, но имеют различия в способе работы и безопасности.

Statement:

- Используется для выполнения простых SQL-запросов без параметров.
- Запросы передаются в виде строковых литералов.
- Подвержен риску SQL-инъекций, так как параметры вставляются путем конкатенации строк.

Пример использования Statement:

Statement statement = connection.createStatement();
String sql = "SELECT * FROM users WHERE id = " + userId; // НЕБЕЗОПАСНО: возможна SQL-инъекция
ResultSet resultSet = statement.executeQuery(sql);

PreparedStatement:

- Предназначен для подготовленных (параметризованных) запросов.
- Использует параметры вместо прямой вставки значений в запрос.
- Предотвращает SQL-инъекции, так как параметры обрабатываются безопасно.
- Может повышать производительность при многократном выполнении схожих запросов.

Пример использования PreparedStatement:

String sql = "SELECT * FROM users WHERE id = ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, userId); // Устанавливаем значение параметра
ResultSet resultSet = preparedStatement.executeQuery();

Ключевые отличия:

- Безопасность: PreparedStatement защищает от SQL-инъекций, автоматически экранируя специальные символы в параметрах.
- Производительность: Подготовленные запросы компилируются один раз и могут выполняться многократно с разными параметрами.
- Удобство: Упрощает работу с запросами, содержащими параметры, без необходимости ручной обработки строк.

Использование PreparedStatement рекомендуется для всех операций с базой данных, где необходимо передавать параметры. Это обеспечивает безопасность приложения и удобство разработки.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Как использовать JUnit для написания тестов?

JUnit — это популярный фреймворк для модульного тестирования в Java. Он позволяет писать и запускать автоматические тесты для проверки корректности кода.

Шаги для использования JUnit:

1. Добавить зависимость:

При использовании Maven в файле pom.xml:

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

2. Создать тестовый класс:

import org.junit.Test;
import static org.junit.Assert.*;

public class CalculatorTest {
    // Тест метода сложения
    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result); // Ожидаем, что 2 + 3 = 5
    }
}

3. Написать тестовые методы:

- Использовать аннотацию @Test перед методами.
- Применять методы утверждений, такие как assertEquals, для проверки результатов.

4. Запустить тесты:

- В среде разработки (например, IntelliJ IDEA) или с помощью команды mvn test для Maven-проекта.

Пример основного класса:

public class Calculator {
    // Метод для сложения двух чисел
    public int add(int a, int b) {
        return a + b;
    }
}

JUnit облегчает процесс тестирования, позволяя быстро обнаруживать и исправлять ошибки в коде.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Объясни принцип работы очереди (Queue)

Очередь (Queue) в Java — это структура данных, работающая по принципу «первым пришел — первым вышел» (FIFO). Она используется для хранения элементов, где первый добавленный элемент становится первым извлекаемым.

Интерфейс Queue расширяет Collection и реализуется такими классами, как LinkedList, PriorityQueue и ArrayDeque.

Пример использования очереди:

Queue<String> queue = new LinkedList<>();

queue.add("First");    // Добавляем элемент в очередь
queue.add("Second");
queue.add("Third");

String head = queue.poll(); // Извлекаем и удаляем первый элемент ("First")
System.out.println(head);

head = queue.peek();        // Получаем первый элемент без удаления ("Second")
System.out.println(head);

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

- add(E e) или offer(E e) — добавляет элемент в конец очереди.
- poll() — удаляет и возвращает первый элемент; возвращает null, если очередь пуста.
- peek() — возвращает первый элемент без удаления; возвращает null, если очередь пуста.

Очереди полезны для управления задачами в порядке их поступления, например, при обработке запросов или заданий в многопоточных приложениях.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Как использовать FileVisitor для обхода файловой системы?

FileVisitor — интерфейс в Java из пакета java.nio.file, который позволяет обходить файловую систему рекурсивно. Его можно использовать вместе с методом Files.walkFileTree() для прохода по файлам и каталогам.

Пример реализации FileVisitor:

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;

// Класс для обхода файловой системы
public class MyFileVisitor extends SimpleFileVisitor<Path> {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
        System.out.println("Visited file: " + file.toString()); // Обрабатываем файл
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
        System.out.println("Entering directory: " + dir.toString()); // Входим в каталог
        return FileVisitResult.CONTINUE;
    }
}

// Использование FileVisitor
Path startPath = Paths.get("/start/directory");
Files.walkFileTree(startPath, new MyFileVisitor());

В этом примере класс MyFileVisitor переопределяет методы для обработки файлов и каталогов. Метод visitFile() вызывается для каждого файла, а preVisitDirectory() — перед посещением каталога.

Метод Files.walkFileTree() начинает обход с заданного пути, используя предоставленный FileVisitor.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Как сериализовать и десериализовать объекты в XML с JAXB?

JAXB (Java Architecture for XML Binding) позволяет преобразовывать объекты Java в XML и обратно.

Сериализация объекта в XML:

Сначала необходимо отметить класс аннотациями JAXB:

import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlElement;

@XmlRootElement // Указывает корневой элемент XML
public class Person {
    private String name;
    private int age;

    public Person() {} // Обязательный конструктор по умолчанию

    @XmlElement // Указывает элемент XML
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    @XmlElement
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

Для сериализации:

Person person = new Person();
person.setName("Alice");
person.setAge(30);

JAXBContext context = JAXBContext.newInstance(Person.class);
Marshaller marshaller = context.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
marshaller.marshal(person, new File("person.xml")); // Сериализуем объект в файл

Десериализация объекта из XML:

JAXBContext context = JAXBContext.newInstance(Person.class);
Unmarshaller unmarshaller = context.createUnmarshaller();
Person person = (Person) unmarshaller.unmarshal(new File("person.xml")); // Десериализуем объект из файла

JAXB упрощает работу с XML, автоматизируя процесс преобразования объектов.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

Подписывайся на наши новые каналы!

👩‍💻 Git
🖥 SQL
👩‍💻 QA

🔥 Что такое SSL/TLS и как его использовать в Java?

SSL (Secure Sockets Layer) и его преемник TLS (Transport Layer Security) — протоколы, обеспечивающие шифрование и безопасность передачи данных между клиентом и сервером по сети. Они гарантируют конфиденциальность, целостность и аутентификацию информации.

В Java для работы с SSL/TLS используется пакет javax.net.ssl. Основными классами для установления защищенных соединений являются SSLSocket, SSLServerSocket, SSLContext и HttpsURLConnection.

Пример создания SSL-сервера:

import javax.net.ssl.*;

public class SSLServerExample {
    public static void main(String[] args) throws Exception {
        // Создаем SSL контекст с протоколом TLS
        SSLContext context = SSLContext.getInstance("TLS");
        context.init(null, null, null); // Инициализация контекста

        // Получаем фабрику серверных сокетов
        SSLServerSocketFactory ssf = context.getServerSocketFactory();
        SSLServerSocket sss = (SSLServerSocket) ssf.createServerSocket(8443); // Создаем серверный сокет на порту 8443

        SSLSocket socket = (SSLSocket) sss.accept(); // Ожидаем подключения клиента

        // Дальнейшая обработка соединения...
    }
}

Пример создания SSL-клиента:

import javax.net.ssl.*;

public class SSLClientExample {
    public static void main(String[] args) throws Exception {
        // Создаем SSL контекст с протоколом TLS
        SSLContext context = SSLContext.getInstance("TLS");
        context.init(null, null, null); // Инициализация контекста

        // Получаем фабрику клиентских сокетов
        SSLSocketFactory ssf = context.getSocketFactory();
        SSLSocket socket = (SSLSocket) ssf.createSocket("localhost", 8443); // Подключаемся к серверу

        // Инициируем рукопожатие SSL/TLS
        socket.startHandshake();

        // Дальнейшая обработка соединения...
    }
}

Использование HttpsURLConnection:

import javax.net.ssl.HttpsURLConnection;
import java.net.URL;

public class HttpsConnectionExample {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://example.com"); // URL ресурса

        HttpsURLConnection conn = (HttpsURLConnection) url.openConnection(); // Открываем соединение

        conn.setRequestMethod("GET"); // Устанавливаем метод запроса

        int responseCode = conn.getResponseCode(); // Получаем код ответа

        // Чтение и обработка ответа...
    }
}

Для настройки сертификатов и ключей используется KeyStore и TrustManager. Это позволяет задать собственные хранилища сертификатов для аутентификации.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Что такое CI/CD и зачем оно нужно?

CI/CD (Continuous Integration/Continuous Delivery) — это практика автоматизации процессов интеграции, тестирования и доставки кода в продакшен. Она включает в себя непрерывную интеграцию, где изменения кода регулярно объединяются и проверяются, и непрерывную доставку или развертывание, где проверенный код автоматически поставляется в рабочую среду.

Основные преимущества CI/CD:

- Быстрая доставка функциональности: Автоматизация позволяет быстрее выпускать новые версии и исправления.
- Повышение качества кода: Регулярные тесты в процессе интеграции помогают выявлять ошибки на ранних этапах.
- Снижение рисков: Автоматизированные процессы уменьшают вероятность человеческих ошибок при ручном развертывании.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Что такое асинхронное программирование и в чем его преимущества?

Асинхронное программирование позволяет выполнять операции без блокирования основного потока, что повышает производительность и отзывчивость приложений. В Java это реализуется с помощью API, таких как CompletableFuture, которые позволяют запускать задачи в фоновом режиме.

Пример использования CompletableFuture:

// Импортируем необходимый класс
import java.util.concurrent.CompletableFuture;

// Асинхронное выполнение задачи
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // Длительная операция
    return "Результат";
});

// Обработка результата по завершении задачи
future.thenAccept(result -> {
    System.out.println("Получено: " + result);
});

Преимущества асинхронного программирования:

- Повышенная производительность: Не блокирует потоки во время ожидания выполнения задач.
- Улучшенная масштабируемость: Позволяет обрабатывать множество запросов без создания большого количества потоков.
- Лучший пользовательский опыт: Обеспечивает отзывчивость приложений, особенно важных в интерфейсах пользователя.

Асинхронность особенно полезна при выполнении операций ввода-вывода, сетевых запросов и при работе с базами данных, где время отклика может быть значительным.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Как отследить работу Garbage Collector?

Для отслеживания работы Garbage Collector (GC) в Java используются различные методы.

1. Включение логирования GC при запуске JVM:

Добавление специальных флагов при запуске приложения позволяет получить подробную информацию о работе GC.

Для Java 9 и выше:

java -Xlog:gc* -jar YourApp.jar

Для Java 8 и ниже:

java -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCDateStamps -jar YourApp.jar

2. Использование JVisualVM:

JVisualVM — встроенный в JDK инструмент для мониторинга приложений Java в реальном времени.

Шаги использования:

1. Запустить jvisualvm из каталога bin JDK.
2. Найти запущенный процесс приложения.
3. Перейти на вкладку "Монитор" для наблюдения за памятью и GC.

3. Применение Java Mission Control (JMC):

JMC предоставляет расширенные возможности мониторинга и профилирования.

Использование:

1. Запустить jmc из каталога bin JDK.
2. Подключиться к нужной JVM.
3. Анализировать данные о GC.

4. Программный доступ к метрикам GC:

Использование платформенных MBean для получения информации о сборках мусора.

Пример:

import java.lang.management.*;
import java.util.List;

List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();

for (GarbageCollectorMXBean gcBean : gcBeans) {
    System.out.println("Name: " + gcBean.getName()); // Имя сборщика мусора
    System.out.println("Total Collections: " + gcBean.getCollectionCount()); // Общее количество сборок
    System.out.println("Total Collection Time: " + gcBean.getCollectionTime() + " ms"); // Общее время сборок
}

Этот код выводит статистику о каждом сборщике мусора в приложении.

5. Использование сторонних инструментов:

Такие как VisualVM плагины, GCViewer или профилировщики типа YourKit, которые предоставляют детальный анализ GC.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Что такое перегрузка и переопределение методов?

Перегрузка и переопределение методов — это механизмы полиморфизма в Java.

Перегрузка методов происходит, когда в одном классе создаются методы с одинаковым именем, но разными параметрами (типом или количеством).

public class Calculator {
    // Метод для сложения двух чисел
    public int add(int a, int b) {
        return a + b;
    }

    // Перегруженный метод для сложения трех чисел
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

Переопределение методов используется при наследовании, когда подкласс предоставляет свою реализацию метода, определенного в суперклассе.

public class Animal {
    // Метод из суперкласса
    public void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    // Переопределенный метод в подклассе
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

Перегрузка методов позволяет создать несколько вариантов одного метода для разных ситуаций. Переопределение позволяет изменить или расширить поведение наследуемого метода.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Что такое Generics и как они применяются в коллекциях?

Generics (обобщения) в Java позволяют создавать классы и методы с параметризованными типами, обеспечивая безопасность типов во время компиляции и устраняя необходимость явного приведения типов.

В коллекциях Generics используются для указания типа объектов, которые могут храниться в коллекции. Это предотвращает добавление элементов неподходящего типа и обнаруживает ошибки на этапе компиляции.

// Создание списка строк с использованием Generics
List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");

// list.add(123); // Ошибка компиляции: нельзя добавить Integer в List<String>

Без использования Generics:

// Создание списка без Generics (не рекомендуется)
List list = new ArrayList();
list.add("Hello");
list.add(123); // Компилируется, но может привести к ошибкам во время выполнения

// Извлечение элемента требует приведения типа
String str = (String) list.get(0);

Generics повышают безопасность и читаемость кода, делая его более устойчивым к ошибкам. В коллекциях их использование является стандартной практикой.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Что такое сериализация и десериализация объектов?

Сериализация и десериализация объектов в Java — это процессы преобразования объектов в поток байтов и обратно. Это позволяет сохранять состояние объекта или передавать его по сети.

Сериализация — преобразование объекта в поток байтов. Класс должен реализовать интерфейс Serializable.

import java.io.Serializable;

public class Person implements Serializable {
    private String name;
    private int age;
    
    // Конструктор, геттеры и сеттеры
}

Сохранение объекта в файл:

Person person = new Person("Alice", 30);
FileOutputStream fileOut = new FileOutputStream("person.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(person);
out.close();
fileOut.close();

Десериализация — восстановление объекта из потока байтов.

Загрузка объекта из файла:

FileInputStream fileIn = new FileInputStream("person.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
Person person = (Person) in.readObject();
in.close();
fileIn.close();

Сериализация полезна для сохранения состояния объектов, кэширования и передачи данных между приложениями.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Объясни использование ключевого слова synchronized

Ключевое слово synchronized в Java используется для управления доступом к разделяемым ресурсам в многопоточной среде. Оно гарантирует, что только один поток может выполнить синхронизированный блок кода или метод в данный момент времени, предотвращая проблемы конкурентного доступа.

Синхронизированный метод:

public class Counter {
    private int count = 0;

    // Синхронизированный метод увеличивает счетчик
    public synchronized void increment() {
        count++;
    }

    // Получает текущее значение счетчика
    public int getCount() {
        return count;
    }
}

В этом примере метод increment() синхронизирован, поэтому несколько потоков не смогут одновременно изменить значение count.

Синхронизированный блок:

public void increment() {
    // Синхронизация на объекте this
    synchronized(this) {
        count++;
    }
}

Синхронизированный блок позволяет указать объект монитора для синхронизации, предоставляя более гибкий контроль.

Синхронизация на классах:

public static synchronized void syncClassMethod() {
    // Синхронизация на уровне класса
}

public void syncOnClass() {
    // Синхронизация на классе
    synchronized(MyClass.class) {
        // Код
    }
}

Использование synchronized помогает предотвращать состояния гонки и обеспечивает целостность данных при одновременном доступе из нескольких потоков.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Как работает связанный список (LinkedList)?

Связанный список (LinkedList) в Java — это реализация интерфейса List, основанная на двусвязном списке. Каждый элемент содержит ссылки на предыдущий и следующий элементы, что позволяет эффективно вставлять и удалять элементы в любой позиции списка.

Основные особенности LinkedList:

- Быстрая вставка и удаление элементов в начале, конце и середине списка.
- Медленный доступ по индексу, поскольку требуется последовательный перебор элементов до нужной позиции.
- Дублирующие элементы допускаются, и порядок вставки сохраняется.

Пример использования LinkedList:

List<String> linkedList = new LinkedList<>();

// Добавление элементов
linkedList.add("Apple");
linkedList.add("Banana");
linkedList.add("Cherry");

// Вставка элемента в начало списка
linkedList.add(0, "Mango");

// Удаление элемента
linkedList.remove("Banana");

// Итерация по списку
for(String fruit : linkedList) {
    System.out.println(fruit);
}

В этом примере демонстрируется создание связанного списка, добавление и удаление элементов, а также перебор с помощью цикла. LinkedList особенно полезен, когда необходимы частые операции вставки и удаления, и доступ по индексу не является критичным.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Что такое паттерн Factory и как его использовать?

Паттерн "Factory" (Фабрика) позволяет создавать объекты без указания точных классов, обеспечивая гибкость и расширяемость кода.

Пример:

// Интерфейс продукта
public interface Shape {
    void draw();
}

// Конкретные продукты
public class Circle implements Shape {
    public void draw() { System.out.println("Drawing Circle"); }
}

public class Square implements Shape {
    public void draw() { System.out.println("Drawing Square"); }
}

// Фабрика
public class ShapeFactory {
    public Shape getShape(String shapeType) {
        // Создаем объект на основе типа
        if("CIRCLE".equalsIgnoreCase(shapeType)){
            return new Circle();
        } else if("SQUARE".equalsIgnoreCase(shapeType)){
            return new Square();
        }
        return null;
    }
}

Использование:

public class FactoryDemo {
    public static void main(String[] args) {
        ShapeFactory factory = new ShapeFactory();

        // Получаем и используем объект Circle
        Shape shape1 = factory.getShape("CIRCLE");
        shape1.draw();

        // Получаем и используем объект Square
        Shape shape2 = factory.getShape("SQUARE");
        shape2.draw();
    }
}

Паттерн Factory снижает связанность кода и упрощает добавление новых типов объектов, делая систему более гибкой и удобной для расширения.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

👇 Другие направления для подготовки тут:

👩‍💻 Frontend
👩‍💻 Python
👩‍💻 Go
👩‍💻 C/C++
👩‍💻 C#
👩‍💻 PHP
👩‍💻 QA
🖥 SQL
👩‍💻 Git

🔥 Что такое UDP и как его использовать в Java?

UDP (User Datagram Protocol) — это протокол транспортного уровня, обеспечивающий обмен датаграммами без установления соединения. Он не гарантирует надежную доставку сообщений, что делает его быстрым и эффективным для приложений, требующих низкой задержки.

В Java для работы с UDP используются классы DatagramSocket и DatagramPacket.

Отправка данных с помощью UDP:

try {
    // Создание сокета
    DatagramSocket socket = new DatagramSocket();
    // Данные для отправки
    String message = "Hello, UDP!";
    byte[] buffer = message.getBytes();
    // Адрес назначения
    InetAddress address = InetAddress.getByName("localhost");
    // Порт назначения
    int port = 4445;
    // Создание пакета
    DatagramPacket packet = new DatagramPacket(buffer, buffer.length, address, port);
    // Отправка пакета
    socket.send(packet);
    // Закрытие сокета
    socket.close();
} catch (IOException e) {
    // Обработка исключений
    e.printStackTrace();
}

Прием данных через UDP:

try {
    // Создание сокета на порту 4445
    DatagramSocket socket = new DatagramSocket(4445);
    byte[] buffer = new byte[256];
    // Создание пакета для приема данных
    DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
    // Ожидание данных
    socket.receive(packet);
    // Преобразование данных в строку
    String received = new String(packet.getData(), 0, packet.getLength());
    System.out.println("Received: " + received);
    // Закрытие сокета
    socket.close();
} catch (IOException e) {
    // Обработка исключений
    e.printStackTrace();
}

UDP часто используется в приложениях, где важна скорость и допускаются потери данных, например, в потоковой передаче мультимедиа или онлайн-играх.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈

🔥 Что такое StAX и как его использовать для чтения XML?

StAX (Streaming API for XML) — это API для обработки XML в Java, основанное на потоковой модели. Оно позволяет эффективно читать и записывать XML-файлы, обрабатывая данные по мере их чтения, что снижает использование памяти по сравнению с моделями DOM и SAX.

Для чтения XML с помощью StAX используется интерфейс XMLEventReader. Ниже приведен пример чтения XML-файла:

import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.events.XMLEvent;
import java.io.FileReader;

public class StAXParserExample {
    public static void main(String[] args) throws Exception {
        // Создание фабрики и чтение XML-файла
        XMLInputFactory factory = XMLInputFactory.newInstance();
        XMLEventReader eventReader = factory.createXMLEventReader(new FileReader("data.xml"));

        // Проход по событиям XML
        while (eventReader.hasNext()) {
            XMLEvent event = eventReader.nextEvent();

            // Обработка начала элемента
            if (event.isStartElement()) {
                String elementName = event.asStartElement().getName().getLocalPart();
                System.out.println("Start Element: " + elementName);
            }

            // Обработка текста внутри элемента
            else if (event.isCharacters()) {
                String data = event.asCharacters().getData().trim();
                if (!data.isEmpty()) {
                    System.out.println("Data: " + data);
                }
            }

            // Обработка конца элемента
            else if (event.isEndElement()) {
                String elementName = event.asEndElement().getName().getLocalPart();
                System.out.println("End Element: " + elementName);
            }
        }
    }
}

Этот код демонстрирует базовое чтение XML-файла с использованием StAX. Создается XMLEventReader, который позволяет последовательно проходить по событиям XML, таким как начало элемента, текст и конец элемента.

Ставь 👍, если было полезно!
Еще больше ответов для подготовки к собеседованиям на сайте 👈