⌨️ DecimalFormat: сложные шаблоны для чисел

DecimalFormat из пакета java.text — мощный инструмент для форматирования чисел в сложных шаблонах. Он поддерживает различные настройки, включая разделители, округление, количество знаков после запятой и даже локализацию.

🔍 Простой пример: форматирование числа с фиксированным количеством знаков после запятой.

import java.text.DecimalFormat;

public class DecimalFormatExample {
    public static void main(String[] args) {
        DecimalFormat df = new DecimalFormat("#.00");
        System.out.println(df.format(123.456)); // Вывод: 123.46
        System.out.println(df.format(78));      // Вывод: 78.00
    }
}

🔗 Ключевые символы шаблона:
# — необязательный знак (только значащие цифры).
0 — обязательный знак (добавляются нули, если цифр меньше).
, — разделитель тысяч.
. — десятичный разделитель.

📌 Сложный пример: форматирование с тысячными разделителями и символами валюты.

DecimalFormat df = new DecimalFormat("¤#,##0.00");
System.out.println(df.format(1234567.89)); 
// Вывод: ₽1 234 567,89

🔍 Локализация:
С помощью DecimalFormatSymbols можно изменить разделители и символы.

import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Locale;

DecimalFormatSymbols symbols = new DecimalFormatSymbols(Locale.FRANCE);
symbols.setDecimalSeparator(',');
symbols.setGroupingSeparator('\'');
DecimalFormat df = new DecimalFormat("#,##0.00", symbols);
System.out.println(df.format(1234567.89)); // Вывод: 1'234'567,89

✨ Когда использовать?
1️⃣ Для форматирования чисел в финансовых и аналитических приложениях.
2️⃣ Когда требуется гибкость с шаблонами или поддержка локализации.
3️⃣ Для генерации отчетов или красивого вывода данных.

#Java #DecimalFormat

⌨️ Парсинг и форматирование дат с DateTimeFormatter

DateTimeFormatter из пакета java.time — это удобный инструмент для форматирования и парсинга дат и времени. Он гибкий, лаконичный и поддерживает локализацию.

🔍 Форматирование даты:

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class DateFormattingExample {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy");

        String formattedDate = date.format(formatter);
        System.out.println("Formatted date: " + formattedDate); // Formatted date: 05-01-2025
    }
}

🔗 Парсинг строки в дату:

String dateString = "05-01-2025";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy");

LocalDate date = LocalDate.parse(dateString, formatter);
System.out.println("Parsed date: " + date); // Parsed date: 2025-01-05

✨ Предустановленные форматы:
Для стандартных форматов можно использовать готовые константы:
- DateTimeFormatter.ISO_DATE — 2025-01-05
- DateTimeFormatter.RFC_1123_DATE_TIME — Fri, 20 Dec 2024 00:00:00 GMT

📌 Пример с локализацией:

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Locale;

public class LocalizedDateTimeExample {
    public static void main(String[] args) {
        LocalDateTime dateTime = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("EEEE, dd MMMM yyyy", Locale.FRENCH);

        String formatted = dateTime.format(formatter);
        System.out.println(formatted); // dimanche, 05 janvier 2025
    }
}

💡 Когда использовать?
1️⃣ Для вывода дат в красивом формате.
2️⃣ Для парсинга пользовательского ввода.
3️⃣ В приложениях с поддержкой нескольких языков.

#Java #DateTimeFormatter

⌨️ Создание классов на лету через ASM

ASM — мощная библиотека для работы с байт-кодом, позволяющая генерировать классы на лету. Это инструмент низкого уровня для полной работы с JVM-классами.

📌 Пример создания класса "Greeter" с методом `greet`:

import org.objectweb.asm.*;

import static org.objectweb.asm.Opcodes.*;

public class ASMExample {
    public static void main(String[] args) throws Exception {
        // Создаём ClassWriter
        ClassWriter cw = new ClassWriter(0);
        cw.visit(V1_8, ACC_PUBLIC, "Greeter", null, "java/lang/Object", null);

        // Генерируем метод greet()
        MethodVisitor mv = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "greet", "()V", null, null);
        mv.visitCode();
        mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        mv.visitLdcInsn("Привет, ASM!");
        mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        mv.visitInsn(RETURN);
        mv.visitMaxs(2, 0);
        mv.visitEnd();

        cw.visitEnd();

        // Загружаем класс
        byte[] classBytes = cw.toByteArray();
        ClassLoader loader = new ClassLoader() {
            public Class<?> defineClass(String name, byte[] b) {
                return super.defineClass(name, b, 0, b.length);
            }
        };
        Class<?> greeterClass = loader.defineClass("Greeter", classBytes);

        // Вызываем метод greet
        greeterClass.getMethod("greet").invoke(null);
    }
}

🔗 Как работает:
1️⃣ Генерируется класс Greeter.
2️⃣ Метод greet выводит строку "Привет, ASM!".
3️⃣ Загружается и выполняется новый класс через кастомный ClassLoader.

✨ Когда использовать ASM?
- Для динамического создания классов или методов.
- В инструментах профилирования или анализа.
- Для оптимизации байт-кода в runtime.

💡 Совет: ASM даёт полный контроль над байт-кодом, но для большинства задач лучше использовать более высокоуровневые инструменты, такие как ByteBuddy или Javassist.

#Java #ASM

⌨️ Record: минимализм с максимальной пользой

Record — это компактный способ создания классов для хранения данных. Они появились в Java 16 и позволяют минимизировать код, генерируя за вас:
- Конструктор,
- Геттеры,
- Методы toString, equals и hashCode.

📌 Пример создания Record:

public record Person(String name, int age) { }

Этот код создаёт immutable класс с полями name и age. Использовать его просто:

Person person = new Person("Alice", 25);
System.out.println(person.name()); // Alice
System.out.println(person);        // Person[name=Alice, age=25]

🔗 Особенности Record:
1️⃣ Поля всегда final и неизменяемы.
2️⃣ Record нельзя наследовать или быть родителем.
3️⃣ Можно добавлять свои методы и проверки.

📌 Пример добавления логики:

public record Person(String name, int age) {
    public Person {
        if (age < 0) {
            throw new IllegalArgumentException("Возраст не может быть отрицательным.");
        }
    }
}

✨ Когда использовать?
- DTO, VO, ключи в коллекциях, и везде, где важна простота и неизменяемость.

#Java #record

⌨️ WatchService: мониторинг изменений файловой системы

WatchService из java.nio.file — это инструмент для отслеживания изменений в файловой системе. С его помощью можно отслеживать создание, изменение и удаление файлов или папок в указанном каталоге.

🔍 Почему WatchService?
1️⃣ Лёгкий способ мониторинга изменений без ручных проверок.
2️⃣ Эффективно работает в реальном времени.
3️⃣ Удобно для отслеживания логов, конфигурационных файлов или загрузок.

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

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

public class WatchServiceExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        Path path = Paths.get("watched_directory");

        // Создаём WatchService
        try (WatchService watchService = FileSystems.getDefault().newWatchService()) {
            // Регистрируем каталог для мониторинга
            path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, 
                          StandardWatchEventKinds.ENTRY_MODIFY, 
                          StandardWatchEventKinds.ENTRY_DELETE);
            System.out.println("Мониторинг изменений в каталоге: " + path);

            while (true) {
                WatchKey key = watchService.take(); // Блокирует поток до события

                for (WatchEvent<?> event : key.pollEvents()) {
                    WatchEvent.Kind<?> kind = event.kind();
                    Path fileName = (Path) event.context();

                    System.out.println("Событие: " + kind + " для файла: " + fileName);
                }

                // Сбрасываем ключ, чтобы продолжать мониторинг
                boolean valid = key.reset();
                if (!valid) {
                    break; // Если ключ недействителен, выходим из цикла
                }
            }
        }
    }
}

🔗 Как это работает:
1️⃣ Регистрируйте каталог с указанием типов событий (ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE).
2️⃣ Обрабатывайте события через WatchKey и список pollEvents().
3️⃣ Вызывайте key.reset() после обработки событий, чтобы продолжить мониторинг.

💡 Совет: Убедитесь, что ваш код учитывает, что WatchService отслеживает только верхний уровень каталога (не вложенные папки).

#Java #WatchService #nio

⌨️ Memory-mapped buffer: эффективная работа с файлами

Memory-mapped buffer — это механизм, предоставляемый Java NIO, который позволяет отображать файл в памяти, так что его содержимое становится доступным для чтения и записи как массив байтов. Это позволяет работать с файлами напрямую через память, что часто значительно увеличивает производительность операций ввода-вывода (I/O).

🔍 Почему это быстрее?
1️⃣ Файл загружается в память через виртуальную память ОС.
2️⃣ Операции чтения/записи проходят без необходимости копирования данных между потоками.
3️⃣ Доступ к данным осуществляется так же, как и в обычном массиве.

📌 Пример чтения файла:

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class MemoryMappedBufferExample {
    public static void main(String[] args) throws IOException {
        try (RandomAccessFile file = new RandomAccessFile("example.txt", "r");
             FileChannel channel = file.getChannel()) {

            // Сопоставляем файл с памятью
            MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());

            // Читаем данные из буфера
            for (int i = 0; i < buffer.limit(); i++) {
                System.out.print((char) buffer.get());
            }
        }
    }
}

🔗 Ключевые моменты:
1️⃣ Режимы READ_ONLY, READ_WRITE, PRIVATE определяют доступ к файлу.
2️⃣ Объём сопоставления ограничен размером доступной памяти.
3️⃣ Подходит для работы с большими файлами (до гигабайтов).

✨ Когда использовать?
- Для высокопроизводительного чтения/записи данных.
- При обработке больших логов или бинарных файлов.
- Когда нужно работать с файлами как с массивами.

#Java #MemoryMappedBuffer #nio

⌨️ Анализ производительности через Java Flight Recorder (JFR)

Java Flight Recorder (JFR) — мощный инструмент для мониторинга и анализа работы приложений на JVM. Он позволяет выявлять узкие места производительности, управлять ресурсами и находить проблемы в реальном времени.

📌 Особенности JFR:
1️⃣ Сбор подробной информации о работе JVM: GC, использование потоков, IO, задержки.
2️⃣ Минимальная нагрузка на приложение во время работы.
3️⃣ Удобная интеграция с инструментами анализа, такими как Java Mission Control.

📌 Основные сценарии использования:
✔️ Диагностика задержек и утечек памяти.
✔️ Мониторинг производительности потоков и GC.
✔️ Отслеживание аномалий в нагрузке или пропускной способности.

📌 Как включить JFR:
1️⃣ При запуске приложения:

java -XX:StartFlightRecording=name=MyApp,filename=recording.jfr

2️⃣ Запуск с указанием продолжительности записи:

java -XX:StartFlightRecording=duration=60s,filename=recording.jfr

3️⃣ Анализ файла recording.jfr через Java Mission Control (JMC).

💡 Совет: JFR встроен в JDK 11+ и не требует дополнительных установок. Используйте его для быстрого анализа проблем и повышения производительности.

#Java #JFR #Производительность #Оптимизация

🖥 Parallel Streams: когда это действительно ускоряет

Parallel Streams — это мощный инструмент в Java, который позволяет выполнять операции со стримами параллельно, используя несколько потоков. Однако параллельность не всегда улучшает производительность.

📌 Когда Parallel Streams полезны:
1️⃣ Большие объёмы данных. При обработке сотен тысяч или миллионов элементов параллельность помогает распределить нагрузку.
2️⃣ Тяжёлые вычисления. Если каждая операция над элементом занимает значительное время.
3️⃣ Многоядерные процессоры. Выигрыш заметен, если система поддерживает многопоточность.

📌 Пример: подсчёт простых чисел параллельно

import java.util.stream.LongStream;

public class ParallelStreamExample {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();

        // Подсчёт простых чисел от 1 до 10_000_000
        long count = LongStream.rangeClosed(1, 10_000_000)
                .parallel() // Параллельный стрим
                .filter(ParallelStreamExample::isPrime)
                .count();

        long end = System.currentTimeMillis();
        System.out.println("Количество простых чисел: " + count);
        System.out.println("Время выполнения: " + (end - start) + " мс");
    }

    private static boolean isPrime(long n) {
        if (n <= 1) return false;
        for (long i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) return false;
        }
        return true;
    }
}

🔗 Что делает код:
1️⃣ Параллельный стрим (parallel) делит диапазон на подзадачи.
2️⃣ Функция isPrime проверяет, является ли число простым.
3️⃣ Элементы обрабатываются в нескольких потоках.

📌 Когда НЕ стоит использовать Parallel Streams:
✔️ Небольшие объёмы данных. Создание потоков может занять больше времени, чем выполнение задачи.
✔️ Лёгкие операции. Например, простое суммирование чисел.
✔️ Синхронизация или shared-state. Параллельные операции, изменяющие общий объект, могут привести к ошибкам.

✨ Совет: Перед использованием параллельных стримов измерьте производительность и убедитесь, что прирост скорости оправдывает сложность.

#Java #Streams #ParallelStreams #Оптимизация

⌨️ Инструменты рефлексии для работы с приватными полями

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

📌 Пример: доступ к приватному полю

import java.lang.reflect.Field;

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        // Класс с приватным полем
        class Person {
            private String name = "John Doe";
        }

        // Создаём объект
        Person person = new Person();

        // Получаем поле через Reflection
        Field field = Person.class.getDeclaredField("name");
        field.setAccessible(true); // Делаем поле доступным

        // Читаем значение приватного поля
        String name = (String) field.get(person);
        System.out.println("Имя до изменения: " + name);

        // Изменяем значение поля
        field.set(person, "Alice");
        System.out.println("Имя после изменения: " + field.get(person));
    }
}

🔗 Как работает:
1️⃣ getDeclaredField получает доступ к приватному полю.
2️⃣ setAccessible(true) отключает проверку модификаторов доступа.
3️⃣ С помощью get и set мы читаем и изменяем значение поля.


📌 Доступ к приватным полям через MethodHandles
MethodHandles также позволяют работать с приватными полями, но более безопасно:

import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;

public class VarHandleExample {
    public static void main(String[] args) throws Throwable {
        class Person {
            private String name = "John Doe";
        }

        Person person = new Person();

        // Получаем VarHandle для поля name
        VarHandle varHandle = MethodHandles.privateLookupIn(Person.class, MethodHandles.lookup())
                .findVarHandle(Person.class, "name", String.class);

        // Читаем значение поля
        System.out.println("Имя до изменения: " + varHandle.get(person));

        // Изменяем значение
        varHandle.set(person, "Alice");
        System.out.println("Имя после изменения: " + varHandle.get(person));
    }
}

🔗 Как работает:
1️⃣ MethodHandles.privateLookupIn позволяет получить доступ к приватному полю.
2️⃣ findVarHandle создаёт безопасный VarHandle для работы с полем.
3️⃣ get и set работают аналогично традиционной рефлексии, но более эффективно.

✨ Когда использовать рефлексию для приватных полей?
- Для инструментов, которые требуют динамического анализа или изменения классов.
- В тестировании для проверки внутренних состояний объектов.

💡 Совет: Используйте рефлексию ответственно, так как она может нарушать инкапсуляцию и снижать производительность. Если есть возможность, замените её на более безопасные подходы.

#Java #Reflection

⌨️ Чем абстрактный класс отличается от интерфейса? В каких случаях следует использовать абстрактный класс, а в каких интерфейс?

✔️ В Java класс может одновременно реализовать несколько интерфейсов, но наследоваться только от одного класса.

✔️ Абстрактные классы используются только тогда, когда присутствует тип отношений «is a» (является). Интерфейсы могут реализоваться классами, которые не связаны друг с другом.

✔️ Абстрактный класс - средство, позволяющее избежать написания повторяющегося кода, инструмент для частичной реализации поведения. Интерфейс - это средство выражения семантики класса, контракт, описывающий возможности. Все методы интерфейса неявно объявляются как public abstract или (начиная с Java 8) default - методами с реализацией по-умолчанию, а поля - public static final.

✔️ Интерфейсы позволяют создавать структуры типов без иерархии.

✔️ Наследуясь от абстрактного, класс «растворяет» собственную индивидуальность. Реализуя интерфейс, он расширяет собственную функциональность.

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

#java #interface #abstract

⌨️ Может ли статический метод быть переопределён?

В Java статические методы нельзя переопределить в строгом смысле этого слова, поскольку они связаны с классом, а не с объектом. Однако их можно скрыть (hide).

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

Такое скрытие не является переопределением, потому что оно не зависит от объекта, а определяется на уровне класса.

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

Пример:

class Parent {
    static void staticMethod() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    static void staticMethod() {
        System.out.println("Child");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Child();
        parent.staticMethod(); // Parent
    }
}

Почему статические методы нельзя переопределить?

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

#java #static #override

⌨️ Что такое "статический класс"?

Это вложенный класс, объявленный с использованием ключевого слова static. К классам верхнего уровня модификатор static неприменим.

Статический вложенный класс имеет несколько особенностей, отличающих его от обычных вложенных классов:

1️⃣ Нет привязки к экземпляру внешнего класса
Статический вложенный класс не связан с экземпляром внешнего класса. Это означает, что он может быть создан без необходимости создавать объект внешнего класса. В отличие от обычного вложенного класса, который всегда ассоциирован с экземпляром внешнего класса, статический вложенный класс может быть использован независимо.

2️⃣ Доступ к членам внешнего класса
Статический вложенный класс может обращаться только к статическим членам (поля и методы) внешнего класса. Он не имеет доступа к нестатическим членам внешнего класса, поскольку не существует привязки к экземпляру внешнего класса.

Пример:

public class OuterClass {
    private static int staticVar = 10;
    private int nonStaticVar = 20;

    static class StaticNestedClass {
        void display() {
            // Доступ к статическому полю внешнего класса
            System.out.println("Static variable from outer class: " + staticVar);
            
            // Ошибка компиляции: нестатическое поле нельзя использовать в статическом вложенном классе
            // System.out.println("Non-static variable from outer class: " + nonStaticVar); 
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // Создаем экземпляр статического вложенного класса
        OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
        nestedObject.display();
    }
}

Для чего используется:
✔️ Когда вложенный класс не должен иметь доступа к состоянию экземпляра внешнего класса.

✔️ Когда вложенный класс используется для представления логически связанного функционала, но не зависит от состояния внешнего объекта.

#java #static #class