Easy Java

Хороший айтишник ≠ хороший руководитель И это причина, почему большинство застревают в своем развитии. 📊 Управление — это отдельный навык. В канале Апазиди АйТи показывают, как его развить в реальном IT. ▪️управленческие ошибки, которые тихо ломают карьеру ▪️почему созвоны — признак слабой системы ▪️как строить команды без постоянного контроля Читай тут: 👉 https://t.me/+Jcx__bY56BwwN2Uy

Доступ к ChatGPT за 5 минут без VPN с помощью Cloudflare Коротка, но годная статья по реализации программы, которая позволяет запускать ChatGPT без VPN! Статья вышла буквально 2 дня назад, потому еще долго будет сохранять свою актуальность, юзайте! ⛓ Читать статью ➡️ Easy Java | #Викторина

90% айтишников проваливают рост в тимлиды ещё до старта Они читают книжки, смотрят курсы — а потом ломаются на первом конфликте с командой или бизнесом В канале Артём Харченков | IT Инсайты: — Разборы реальных ситуаций из жизни тимлида — Как выглядят правильные решения глазами тимлида — Чем отличается сильный айтишник от тимлида Подписывайся, если хочешь понимать, как устроено тимлидство изнутри: @teamlead_insights

👩‍💻 Что такое Collectors.partitioningBy() и зачем он нужен? Collectors.partitioningBy() — это коллектор из Java Stream API, который разделяет элементы потока на две группы (true/false) на основе заданного предиката, возвращая Map<Boolean, List<T>>. ⚡️ Пример:

import java.util.*;
import java.util.stream.*;
import java.util.function.Predicate;

public class PartitioningByExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // Разделение чисел на четные и нечетные
        Map<Boolean, List<Integer>> partitioned = numbers.stream()
            .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        
        System.out.println("Четные: " + partitioned.get(true));    // [2, 4, 6, 8, 10]
        System.out.println("Нечетные: " + partitioned.get(false)); // [1, 3, 5, 7, 9]
        
        // Строки по длине
        List<String> words = Arrays.asList("яблоко", "груша", "слива", "апельсин", "лимон");
        
        Map<Boolean, List<String>> byLength = words.stream()
            .collect(Collectors.partitioningBy(word -> word.length() > 5));
        
        System.out.println("\nКороткие слова (≤5 букв): " + byLength.get(false));
        System.out.println("Длинные слова (>5 букв): " + byLength.get(true));
        
        // С дополнительным коллектором - подсчет количества
        Map<Boolean, Long> countPartition = numbers.stream()
            .collect(Collectors.partitioningBy(
                n -> n > 5,
                Collectors.counting()
            ));
        
        System.out.println("\nЧисел ≤5: " + countPartition.get(false));
        System.out.println("Чисел >5: " + countPartition.get(true));
    }
}

👀 Особенно полезен для разделения данных на прошедшие/не прошедшие валидацию, категоризации на успешные/ошибочные операции, статистического анализа.

➡️ Easy Java | #Теория

👩‍💻 Викторина: что выведет код?

public class Main {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();
    
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                try { Thread.sleep(100); } catch (Exception e) {}
                synchronized (lock2) {
                    System.out.println("Thread 1");
                }
            }
        });
        
        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                try { Thread.sleep(100); } catch (Exception e) {}
                synchronized (lock1) {
                    System.out.println("Thread 2");
                }
            }
        });
        
        t1.start();
        t2.start();
        
        try {
            t1.join(500);
            t2.join(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Main finished");
    }
}

➡️ Easy Java | #Викторина

ИНТЕРНЕТ В РОССИИ — ВСЁ❌ С каждым днём всё больше любимых сайтов и приложений блокируются, а у кого-то работают только приложения «Белого списка» Оставляем инструкцию по обходу всех ограничений, в том числе «Белого списка» по ссылке — @strelkavpn

Самые хитрые и частые вопросы на собеседованиях В статье рассказано про 10 самых «каверзных» вопросах на собеседованих, где достаточно часто допускают ошибки. Есть и те, что больше похожи на головоломки или касаются нюансов, которые прочувствовать без практики очень тяжело. ⛓ Читать статью ➡️ Easy Java | #Статья

👩‍💻 Что такое DelayQueue в Java и зачем она нужна? DelayQueue — это потокобезопасная очередь из java.util.concurrent, где элементы становятся доступными только после истечения заданного времени задержки. Элементы должны реализовывать интерфейс Delayed.

Она удобна для отложенной обработки задач — таймеров, кэшей с TTL, планировщиков.

• Элементы выдаются только после задержки • Работает в многопоточном режиме • Идеальна для задач с таймаутами ⚡️ Пример:

import java.util.concurrent.*;

class Task implements Delayed {
    long start = System.currentTimeMillis() + 1000;
    public long getDelay(TimeUnit u) { return u.convert(start - System.currentTimeMillis(), TimeUnit.MILLISECONDS); }
    public int compareTo(Delayed o) { return Long.compare(getDelay(TimeUnit.MILLISECONDS), o.getDelay(TimeUnit.MILLISECONDS)); }
    public String toString() { return "Задача выполнена"; }
}

public class Main {
    public static void main(String[] args) throws Exception {
        DelayQueue<Task> q = new DelayQueue<>();
        q.put(new Task());
        System.out.println(q.take()); // ждём 1 сек
    }
}

👀 DelayQueue особенно полезна для отложенных задач, TTL-кэшей и планировщиков.

➡️ Easy Java | #Теория

🎭 #fsociety >> пробив данным нового уровня!

Мгновенные результаты для соло-осинтеров и корпоративный API 🔥 Если ты хотел создать своего бота для пробива — дешевле и быстрее API, чем у нас, ты не найдёшь.

⚜️ Для корпоративных клиентов: 🏆 API для пробива от $0,0049 за запрос! 🎯 Глубина поиска: до 500 слоёв утечек данных! 🥇 Скорость API: 25 RPS 📂 База на ~20.000.000.000 строк _________ ⚜️ Для соло-доксеров и деанонщиков:

🔰10 бесплатных запросов ежедневно 🔰+40% реферальная система 🔰Каждый реферал добавляет +3 запроса 🔰Тарифы или запросы на выбор 🔰Установка отзывов и репутации цели 🔰Мониторинг доксинга 🔰Telegram Radar 🔰OSINT-профиль цели через ИИ

_________ @fsociety_r0bot — оператор доступа к данным, которые скрыты от остальных. «Доступ — это форма власти, поэтому не теряй постоянную ссылку — fsociety.wiki» © MrRobot

👩‍💻 Викторина: что выведет код?

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            Singleton s1 = Singleton.getInstance();
            System.out.print("T1 ");
        });
        
        Thread t2 = new Thread(() -> {
            Singleton s2 = Singleton.getInstance();
            System.out.print("T2 ");
        });
        
        t1.start();
        t2.start();
        
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.print("Done");
    }
}

➡️ Easy Java | #Викторина

👩‍💻 Что такое Arrays.parallelSort() и зачем он нужен? Arrays.parallelSort() — это метод из класса java.util.Arrays, который сортирует массивы с использованием параллельных алгоритмов, задействуя несколько ядер процессора для ускорения сортировки больших объемов данных. ⚡️ Преимущества: – Значительно ускоряет сортировку больших массивов – Автоматически использует ForkJoinPool для параллельной обработки – Минимальные изменения кода по сравнению с обычной сортировкой Пример кода:

import java.util.*;
import java.util.concurrent.TimeUnit;

public class ParallelSortExample {
    public static void main(String[] args) {
        // Создаем большой массив случайных чисел
        int size = 10_000_000;
        int[] numbers = new int[size];
        Random random = new Random();
        
        for (int i = 0; i < size; i++) {
            numbers[i] = random.nextInt(1_000_000);
        }
        
        // Копируем массив для сравнения сортировок
        int[] numbersCopy = numbers.clone();
        
        System.out.println("Начата параллельная сортировка...");
        long startTime = System.nanoTime();
        Arrays.parallelSort(numbers);
        long parallelTime = System.nanoTime() - startTime;
        System.out.println("Параллельная сортировка заняла: " + 
                          TimeUnit.NANOSECONDS.toMillis(parallelTime) + " мс");
        
        System.out.println("Начата обычная сортировка...");
        startTime = System.nanoTime();
        Arrays.sort(numbersCopy);
        long sequentialTime = System.nanoTime() - startTime;
        System.out.println("Обычная сортировка заняла: " + 
                          TimeUnit.NANOSECONDS.toMillis(sequentialTime) + " мс");
        
        // Сортировка объектов
        String[] cities = {"Москва", "Санкт-Петербург", "Казань", 
                          "Екатеринбург", "Новосибирск", "Владивосток"};
        
        Arrays.parallelSort(cities);
        System.out.println("\nОтсортированные города: " + Arrays.toString(cities));
        
        // Сортировка с компаратором
        Arrays.parallelSort(cities, Comparator.comparingInt(String::length));
        System.out.println("Города по длине названия: " + Arrays.toString(cities));
    }
}

Особенности: – Работает с массивами примитивов и объектами – Автоматически выбирает алгоритм сортировки в зависимости от размера массива – Для небольших массивов может использовать последовательную сортировку – Поддерживает пользовательские компараторы для объектов

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

➡️ Easy Java | #Теория

👩‍💻 Викторина: что выведет код?

public class Main {
    static class Resource implements AutoCloseable {
        private String name;
        
        Resource(String name) { this.name = name; }
        
        void use() throws Exception {
            throw new Exception(name + " use exception");
        }
        
        @Override
        public void close() throws Exception {
            throw new Exception(name + " close exception");
        }
    }
    
    public static void main(String[] args) {
        try {
            try (Resource r1 = new Resource("1"); 
                 Resource r2 = new Resource("2")) {
                r1.use();
                r2.use();
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

➡️ Easy Java | #Викторина

NZT существует. В фильме «Области тьмы» герой выпивает NZT — и за день становится трейдером, мастером кунг-фу и полиглотом. Дело не в таблетке. А в состоянии. Химия не нужна. Когда ум чист, внимание собрано, и сомнений нет — ты уже на NZT. Ты замечаешь всё. Действуешь без разрывов. И мир отвечает тебе. Как включить режим NZT? Подписывайся на Мэверика. • входи в состояние всё «получается само». • мгновенно принимай лучшие решения. • считывай сложные связи там, где все видят хаос. • управляй фокусом и вероятностями событий. Твоя таблетка NZT. 👇 Мэверик. Ясность. Точность. ㅤ

Самые хитрые и частые вопросы на собеседованиях В статье рассказано про 10 самых «каверзных» вопросах на собеседованих, где достаточно часто допускают ошибки. Есть и те, что больше похожи на головоломки или касаются нюансов, которые прочувствовать без практики очень тяжело. ⛓ Читать статью ➡️ Easy Java | #Статья

👩‍💻 Что такое Files.walk() и зачем он нужен? Files.walk() — это метод из Java NIO (пакет java.nio.file), который рекурсивно обходит файловое дерево, начиная с указанной директории, и возвращает Stream с путями ко всем найденным файлам и папкам. Преимущества: – Простой рекурсивный обход файловой системы – Автоматическое управление ресурсами – Поддержка параллельной обработки – Фильтрация и преобразование прямо в потоке ⚡️ Пример кода:

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class FilesWalkExample {
    public static void main(String[] args) {
        Path startDir = Paths.get(".");
        
        try (Stream<Path> paths = Files.walk(startDir, 3)) {
            // Найти все .java файлы до глубины 3
            paths.filter(Files::isRegularFile)
                 .filter(p -> p.toString().endsWith(".java"))
                 .forEach(p -> System.out.println("Java файл: " + p));
                 
        } catch (IOException e) {
            System.err.println("Ошибка обхода: " + e.getMessage());
        }
        
        // Подсчет общего размера файлов
        try (Stream<Path> allPaths = Files.walk(startDir)) {
            long totalSize = allPaths.filter(Files::isRegularFile)
                                     .mapToLong(p -> {
                                         try {
                                             return Files.size(p);
                                         } catch (IOException e) {
                                             return 0;
                                         }
                                     })
                                     .sum();
            System.out.println("Общий размер: " + totalSize + " байт");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Особенности: – Возвращает Stream<Path> для ленивой обработки – Принимает параметр глубины поиска (максимальный уровень вложенности) – Автоматически закрывает ресурсы при использовании try-with-resources – Может выбрасывать IOException

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

➡️ Easy Java | #Теория