Java | Фишки и трюки

⌨️ Код для реализации уникального идентификатора (UUID):

import java.util.UUID;

public class UniqueIdGenerator {

public static void main(String[] args) {
    // Генерация случайного уникального идентификатора
    UUID uuid = UUID.randomUUID();
    System.out.println("Уникальный идентификатор: " + uuid);
    
    // Преобразование уникального идентификатора в строку без тире
    String uuidString = uuid.toString().replace("-", "");
    System.out.println("Уникальный идентификатор без тире: " + uuidString);
}

Этот код генерирует случайный уникальный идентификатор (UUID) и выводит его значение в формате с и без использования тире. Уникальный идентификатор предоставляет уникальное значение, которое может быть использовано для идентификации объектов, сессий, операций и т. д. Это полезно, например, при создании уникального идентификатора для записи в базу данных или для генерации уникального имени файла.

Присоединяйтесь к нашему бесплатному курсу и начните увлекательное путешествие в мир Java! Изучайте основы, создавайте программы, разбирайтесь с методами и анализируйте ошибки в коде. Практика, упражнения и проверочные тесты помогут вам освоить навыки программирования. 🎓 Чему вы научитесь: — Создавать программы с использованием основных конструкций языка.  — Разделять код на методы для повторного использования.  — Анализировать ошибки в коде с использованием отладочной печати. 💼 Включено в курс: 29 уроков (видео и/или текст), 35 упражнений в тренажере, 95 проверочных тестов + дополнительные материалы. Вы с нами?😉

⌨️ Использование Stream API для работы с коллекциями данных.

import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");

        // Фильтрация элементов, начинающихся с буквы "a" и преобразование в верхний регистр
        fruits.stream()
                .filter(fruit -> fruit.startsWith("a"))
                .map(String::toUpperCase)
                .forEach(System.out::println);
        // Выведет "APPLE"
    }
}

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

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

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // Создание CompletableFuture объекта
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");

        // Добавление операций после выполнения асинхронной задачи
        CompletableFuture<String> result = future.thenApplyAsync(str -> str + " World")
                .thenApply(str -> str + "!");

        try {
            // Ожидание результата
            String message = result.get();
            System.out.println(message);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

🧑‍💻В данном примере мы создаем CompletableFuture объект future, который возвращает строку "Hello". Затем мы добавляем операции thenApplyAsync и thenApply, которые обрабатывают результат асинхронной задачи и добавляют к нему слова "World" и "!", соответственно. 🔎 После этого мы ожидаем результат, вызывая метод get(). Если выполнение асинхронной задачи еще не завершено, данный метод будет блокироваться до получения результата. 💁‍♂️ Таким образом, использование CompletableFuture позволяет нам эффективно работать с асинхронными задачами и упрощает обработку результатов. Это может быть особенно полезно в многопоточном или параллельном программировании.

Статья, которая 100% будет полезна Java разработчикам, планирующим перейти на виртуальные потоки! Говорим о важной фиче — виртуальных потоках Java 21. Именно благодаря ей синхронный код становится эффективным! Как это работает, какие есть подводные камни, и из-за чего ваше приложение может зависнуть: рассказали подробно и с наглядными примерами в материале. Познакомиться с ним можно по ссылке прямо сейчас

⌨️ Обработка исключений с помощью Try-With-Resources. Try-With-Resources - это новая конструкция языка, введенная в Java 7, которая облегчает работу с ресурсами такими как файлы или сокеты и сокращает количество кода, необходимого для обработки исключений. Вот пример использования Try-With-Resources для чтения содержимого файла:

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

💻В этом примере мы открываем BufferedReader внутри блока try с помощью конструктора FileReader. Затем мы можем безопасно читать файл внутри этого блока без необходимости явно закрывать ресурс. После завершения блока try автоматически вызывается метод close() объекта reader, который закрывает файл и освобождает связанные с ним ресурсы. Если возникнет исключение в блоке try, его можно будет обработать в блоке catch после завершения работы с ресурсом.

⌨️ Работа с коллекциями элементарных типов данных благодаря классам-оболочкам (Wrapper Classes)

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

public class WrapperExample {
    public static void main(String[] args) {
        // Создание списка оберток для целых чисел
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        // Использование методов класса-оболочки
        int sum = 0;
        for (int i = 0; i < numbers.size(); i++) {
            sum += numbers.get(i);
        }
        System.out.println("Сумма чисел: " + sum);
    }
}

✅ В этом примере создается список оберток numbers для целых чисел типа Integer. Затем мы добавляем в список несколько элементов и используем метод get() для получения элементов из списка. Значения оберток автоматически анбоксируются в примитивные типы данных int, и мы можем выполнять с ними операции, например, суммирование. Использование классов-оболочек позволяет работать с коллекциями элементарных типов данных и обеспечивает удобство и безопасность при работе с ними.

⌨️ Использования анонимных классов: Анонимный класс - это класс без имени, который объявляется и создается внутри другого класса или метода. Он удобен, когда требуется определить класс, который будет использоваться только один раз, и нет необходимости создавать отдельный класс.

public class Main {
    interface Greeting {
        void sayHello();
    }

    public static void main(String[] args) {
        Greeting greeting = new Greeting() {  // объявление и создание анонимного класса
            @Override
            public void sayHello() {
                System.out.println("Привет, мир!");
            }
        };

        greeting.sayHello();  // вызов метода sayHello у анонимного класса
    }
} 

✅В данном примере мы определили интерфейс Greeting, содержащий метод sayHello(). Затем, в методе main(), мы создали анонимный класс, реализующий интерфейс Greeting и переопределивший метод sayHello(). Затем мы вызываем метод sayHello() у объекта анонимного класса. 📝Таким образом, анонимные классы предоставляют удобный способ создания и использования классов "на лету", что может быть полезно, когда требуется определить классы, которые будут использоваться только в одном месте программы.

Представляем вашему вниманию Telegram-канал с уникальным увлекательным контентом для Java-разработчика 💪 Наша команда разработывает статического анализатора для Java, С#, С, С++ кода. Рассказываем о тонкостях этих языков, проверяем известные Open Source проекты и рассказываем об ошибках, которые в них кроются 🧐 Примеры Java-постов: - Немного о гигиене Java кода - Сразись с анализатором PVS-Studio в поиске ошибок в Java коде! Заглядывайте! Обещаем, скучно не будет 😉 Реклама. ООО "ПВС". ИНН 7105502635.

⌨️ Метод для глубокого копирования объектов. Это часто используется, когда нужно создать копию объекта, сохраняя его данные, но не связи с другими объектами. 📌 Вот пример метода для глубокого копирования:

import java.io.*;

public class DeepCopyExample {
    public static void main(String[] args) {
        Person person = new Person("John", 30);
        Person deepCopy = deepCopy(person);
        
        System.out.println("Original: " + person.getName() + ", " + person.getAge());
        System.out.println("Deep copy: " + deepCopy.getName() + ", " + deepCopy.getAge());
    }
    
    public static <T extends Serializable> T deepCopy(T object) {
        try {
            ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteOutputStream);
            objectOutputStream.writeObject(object);
            
            ByteArrayInputStream byteInputStream = new ByteArrayInputStream(byteOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteInputStream);
            T copy = (T) objectInputStream.readObject();
            
            return copy;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

class Person implements Serializable {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
}

✅ В этом примере мы создаем класс Person, который реализует интерфейс Serializable, чтобы объекты этого класса можно было сериализовать и десериализовать. Затем мы создаем метод deepCopy, который принимает объект и возвращает его глубокую копию. Мы используем ByteArrayOutputStream и ObjectOutputStream, чтобы записать объект в байтовый массив, а затем ByteArrayInputStream и ObjectInputStream, чтобы прочитать копию объекта из массива. В методе main мы создаем объект Person, затем создаем его глубокую копию с помощью метода deepCopy и выводим на экран значения оригинального и скопированного объекта.

⌨️ Использование интерфейса Callable вместе с классом Future для выполнения асинхронных задач и получения их результата:

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(1);

        Future<Integer> futureResult = executor.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                // Выполнение сложной вычислительной задачи
                int result = 0;
                for (int i = 0; i < 100; i++) {
                    result += i;
                    Thread.sleep(100);
                }
                return result;
            }
        });

        // Другие действия, выполняемые параллельно

        try {
            // Ожидание завершения асинхронной задачи и получение результата
            Integer result = futureResult.get();
            System.out.println("Результат: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        executor.shutdown();
    }
}

➡️В данном примере создается пул потоков размером 1, затем создается асинхронная задача с использованием интерфейса Callable, который возвращает результат типа Integer. Задача выполняет сложное вычисление с задержкой в 100 миллисекунд каждую итерацию. После создания задачи, она отправляется на выполнение в пул потоков. Далее, можно выполнять другие действия параллельно с ожиданием завершения задачи. Метод get() вызывается для ожидания завершения задачи и получения результата. Если задача еще не завершилась, вызов этого метода блокируется. Возможны исключения, такие как InterruptedException или ExecutionException, которые необходимо обработать. 💁‍♂️ Затем поток пул завершается вызовом shutdown().

Самый необычный канал про Java, подписывайся – https://t.me/java_secrets 📲 Будь в курсе последних тенденций, лучших практик и отраслевых секретов Java. Канал Секреты Java поможет тебе улучшить свой путь разработки Java.

⌨️ Параллельное выполнение задач с использованием ExecutorService ExecutorService - это интерфейс, который предоставляет удобный способ для управления параллельным выполнением задач. Он предоставляет пул потоков для выполнения задач и управляет их жизненным циклом:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        // Создание пула потоков
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // Подача задач на выполнение
        for (int i = 0; i < 10; i++) {
            executor.execute(new Task(i));
        }

        // Остановка пула потоков после выполнения задач
        executor.shutdown();
    }

    static class Task implements Runnable {
        private int taskId;

        public Task(int taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {
            System.out.println("Выполнение задачи " + taskId + " в потоке " +
                Thread.currentThread().getName());
        }
    }
}

🧑‍💻Этот код создает пул из 5 потоков и подает на выполнение 10 задач. Каждая задача выводит свой идентификатор и имя потока, в котором она выполняется. После выполнения всех задач пул потоков останавливается.

Ответ на вопрос и Яндекс Музыка ваша 60 дней бесплатно Яндекс Музыка для вас и 3-х ваших близких 60 дней бесплатно. Попробуйте сейчас! Попробовать #реклама 16+ music.yandex.ru О рекламодателе

💻 Как полезную фишку на Java можно рассмотреть использование лямбда-выражений для упрощения написания анонимных классов. Например, использование лямбда-выражения для выполнения операции над элементами коллекции:

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Использование лямбда-выражения для вывода каждого элемента в консоль
        numbers.forEach(n -> System.out.println(n));

        // Использование лямбда-выражения для умножения каждого элемента на 2
        numbers.replaceAll(n -> n * 2);
        System.out.println(numbers); // Вывод: [2, 4, 6, 8, 10]
    }
}

🔝 Использование лямбда-выражений делает код более компактным и удобочитаемым, особенно при работе с коллекциями и функциональными интерфейсами.

Ответьте на 1 вопрос и книги ваши на 30 дней за 0 рублей Доступ к Букмейту для вас и трех ваших близких на 30 дней бесплатно. Попробуйте! Получить предложение #реклама 16+ mrqz.me О рекламодателе

⌨️ Использование StringBuilder для эффективной конкатенации строк:

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10; i++) {
            sb.append("строка ").append(i).append("\n");
        }
        String result = sb.toString();
        System.out.println(result);
    }
}

📌 В этом примере используется StringBuilder для объединения 10 строк "строка i" в одну строку. Это более эффективно, чем использование оператора "+" или String.concat(), особенно при большом количестве операций конкатенации строк. StringBuilder предоставляет изменяемую последовательность символов и позволяет выполнять эффективные операции вставки, удаления и конкатенации строк.