Java for Beginner

Что выведет код?

public class ConcatenationExample {
    public static void main(String[] args) {
        int x = 5;
        int y = 10;
        String str1 = "Hello";
        String str2 = "World";

        String result = str1 + x + y + str2 + (x + y) + str1.length() + (x * y);
        
        System.out.println(result);
    }
}

#Tasks

158 viewsДен, 08:43

Java for Beginner

Варианты ответа:

Anonymous Quiz

79%

Hello510World15550

Hello510World15105Hello

14%

Hello510World1510150

Hello510World1510150Hello

14 voters156 viewsДен, 08:48

Java for Beginner

Почему не любят тестировщиков?🤪

https://t.me/Java_for_beginner_dev

#Mems

164 viewsДен, 10:24

Java for Beginner

Терминальные методы Stream API

Терминальные методы завершают цепочку операций со стримами, возвращая результат или выполняя действие.

forEach:

List<String> list = Arrays.asList("a", "b", "c");
list.stream()
    .forEach(System.out::println); // a, b, c

collect:

List<String> list = Arrays.asList("a", "b", "c");
List<String> result = list.stream()
                          .collect(Collectors.toList());

reduce:

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream()
              .reduce(0, (a, b) -> a + b);

toArray:

List<String> list = Arrays.asList("a", "b", "c");
String[] array = list.stream()
                     .toArray(String[]::new);

findFirst:

List<String> list = Arrays.asList("a", "b", "c");
Optional<String> first = list.stream()
                             .findFirst();

findAny:

List<String> list = Arrays.asList("a", "b", "c");
Optional<String> any = list.stream()
                           .findAny();

count:

List<String> list = Arrays.asList("a", "b", "c");
long count = list.stream()
                 .count();

anyMatch:

List<String> list = Arrays.asList("a", "b", "c");
boolean anyMatch = list.stream()
                       .anyMatch(s -> s.equals("a"));

allMatch:

List<String> list = Arrays.asList("a", "b", "c");
boolean allMatch = list.stream()
                       .allMatch(s -> s.length() == 1);

noneMatch:

List<String> list = Arrays.asList("a", "b", "c");
boolean noneMatch = list.stream()
                        .noneMatch(s -> s.equals("d"));

Продвинутые методы и примеры использования Stream API

groupingBy:

List<String> list = Arrays.asList("a", "ab", "abc", "abcd");
Map<Integer, List<String>> groupedByLength = list.stream()
                                                 .collect(Collectors.groupingBy(String::length));

partitioningBy:

List<String> list = Arrays.asList("a", "ab", "abc", "abcd");
Map<Boolean, List<String>> partitionedByLength = list.stream()
                                                     .collect(Collectors.partitioningBy(s -> s.length() > 2));

mapping:

List<String> list = Arrays.asList("a", "ab", "abc", "abcd");
List<Integer> lengths = list.stream()
                            .collect(Collectors.mapping(String::length, Collectors.toList()));

joining:

List<String> list = Arrays.asList("a", "b", "c");
String joined = list.stream()
                    .collect(Collectors.joining(", "));

Примеры использования Stream API

Фильтрация и преобразование списка строк:

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
List<String> result = list.stream()
                          .filter(s -> s.startsWith("a"))
                          .map(String::toUpperCase)
                          .collect(Collectors.toList());

Группировка чисел по четности:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Map<Boolean, List<Integer>> evenOddMap = numbers.stream()
                                                .collect(Collectors.partitioningBy(n -> n % 2 == 0));

Подсчет элементов в списке:

List<String> list = Arrays.asList("a", "b", "c", "a", "b", "c");
Map<String, Long> frequencyMap = list.stream()
                                     .collect(Collectors.groupingBy(s -> s, Collectors.counting()));

Нахождение максимального значения в списке:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> maxNumber = numbers.stream()
                                     .max(Integer::compare);

#Java #Training #Stream #Medium

158 viewsДен, 13:38

Java for Beginner

Многопоточность

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

Параллелизм и конкурентность

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

Основные понятия многопоточности

Поток (Thread): наименьшая единица выполнения. Каждый поток выполняет свою задачу независимо.
Процесс: программа, выполняющаяся в отдельной среде. Каждый процесс может содержать несколько потоков.

Создание потоков

В Java создание потоков может быть реализовано двумя способами: наследованием класса Thread и реализацией интерфейса Runnable.

Наследование класса Thread

Создание класса, наследующего Thread:

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread is running");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // Запуск потока
    }
}

Реализация интерфейса Runnable

Создание класса, реализующего Runnable:

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable is running");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start(); // Запуск потока
    }
}

Методы класса Thread

start(): запускает поток, вызывая метод run().
run(): содержит код, который выполнится в новом потоке.
sleep(long millis): приостанавливает выполнение потока на заданное количество миллисекунд.

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(1000); // Поток спит 1 секунду
            System.out.println("Thread woke up");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

join(): ожидает завершения выполнения потока.

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {
            thread.join(); // Ожидание завершения потока
            System.out.println("Thread has finished");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

isAlive(): возвращает true, если поток выполняется, иначе false.

MyThread thread = new MyThread();
thread.start();
System.out.println(thread.isAlive()); // true, если поток выполняется

Приоритеты потоков

Каждый поток в Java имеет приоритет, который влияет на порядок планирования потоков. Приоритеты варьируются от Thread.MIN_PRIORITY (1) до Thread.MAX_PRIORITY (10). Поток с более высоким приоритетом будет запланирован раньше, чем поток с более низким приоритетом.

public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(getName() + " is running");
    }

    public static void main(String[] args) {
        MyThread thread1 = new MyThread("Thread 1");
        MyThread thread2 = new MyThread("Thread 2");

        thread1.setPriority(Thread.MIN_PRIORITY);
        thread2.setPriority(Thread.MAX_PRIORITY);

        thread1.start();
        thread2.start();
    }
}

#Java #Training #Multithreading #Medium

144 viewsДен, 05:17

Java for Beginner

Что выведет код?

import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("apple");
        set.add("cherry");
        set.add(null);
        set.add("banana");

        int result = set.size() + (set.contains(null) ? 1 : 0) + (set.contains("apple") ? 1 : 0);
        
        System.out.println(result);
    }
}

#Tasks

139 viewsДен, 08:28

Java for Beginner

Варианты ответа:

Anonymous Quiz

10%

80%

10%

10 voters139 viewsДен, 08:33

Java for Beginner

Если одиноко, вставь autoplay в свою страницу и жди гостей🫣

https://t.me/Java_for_beginner_dev

#Mems

160 viewsДен, 10:09

Java for Beginner

Использование synchronized в многопоточности

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

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

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

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

public class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("Final count: " + counter.getCount()); // 2000
    }
}

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

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

public class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

public class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("Final count: " + counter.getCount()); // 2000
    }
}

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

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

public class StaticCounter {
    private static int count = 0;

    public static synchronized void increment() {
        count++;
    }

    public static synchronized int getCount() {
        return count;
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            StaticCounter.increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("Final count: " + StaticCounter.getCount()); // 2000
    }
}

132 viewsДен, 12:35

Java for Beginner

Mutex и Lock

В Java Lock предоставляется в пакете java.util.concurrent.locks. Это более мощный инструмент синхронизации, чем synchronized, предлагающий больше возможностей, таких как попытка захвата блокировки без ожидания, прерывание во время ожидания блокировки и использование условных переменных.

Интерфейс Lock

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

lock(): Захватывает блокировку.
unlock(): Освобождает блокировку.
tryLock(): Попытка захвата блокировки без ожидания.
lockInterruptibly(): Захват блокировки с возможностью прерывания.

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

ReentrantLock — это реализация интерфейса Lock, позволяющая потоку захватить блокировку несколько раз.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

public class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("Final count: " + counter.getCount()); // 2000
    }
}

Использование tryLock()

Метод tryLock() пытается захватить блокировку немедленно, возвращая true, если это удалось, и false в противном случае.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        if (lock.tryLock()) {
            try {
                count++;
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println("Unable to lock");
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

public class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("Final count: " + counter.getCount()); // 2000
    }
}

136 viewsДен, 12:53

Java for Beginner

Условные переменные

Condition — это интерфейс, предоставляющий средства для блокировки потоков до тех пор, пока они не будут сигнализировать другим потокам. Это более гибкая альтернатива методу wait() и notify() в синхронизированных блоках.

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BoundedBuffer {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    private final Object[] items = new Object[100];
    private int putptr, takeptr, count;

    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) {
                notFull.await();
            }
            items[putptr] = x;
            if (++putptr == items.length) putptr = 0;
            count++;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                notEmpty.await();
            }
            Object x = items[takeptr];
            if (++takeptr == items.length) takeptr = 0;
            count--;
            notFull.signal();
            return x;
        } finally {
            lock.unlock();
        }
    }
}

#Java #Training #Multithreading #Medium

145 viewsДен, 13:24

Java for Beginner

Многопоточность в Java: wait и notify

В Java методы wait(), notify(), и notifyAll() используются для управления потоками в многопоточной среде. Они позволяют потокам координировать свои действия при доступе к общим ресурсам, предоставляя механизм для ожидания и уведомления. Эти методы определены в классе Object и должны вызываться из синхронизированного контекста.

Метод wait()

Метод wait() заставляет текущий поток ждать до тех пор, пока другой поток не вызовет метод notify() или notifyAll() для этого объекта. Поток, вызвавший wait(), освобождает монитор и переходит в состояние ожидания.

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

public class WaitNotifyExample {
    private final Object lock = new Object();
    private boolean condition = false;

    public void doWait() {
        synchronized (lock) {
            while (!condition) {
                try {
                    System.out.println("Waiting...");
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Condition met!");
        }
    }

    public void doNotify() {
        synchronized (lock) {
            condition = true;
            lock.notify();
            System.out.println("Notified!");
        }
    }

    public static void main(String[] args) {
        WaitNotifyExample example = new WaitNotifyExample();

        Thread waiter = new Thread(example::doWait);
        Thread notifier = new Thread(example::doNotify);

        waiter.start();
        try {
            Thread.sleep(1000); // Задержка для демонстрации ожидания
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        notifier.start();
    }
}

Метод notify()

Метод notify() пробуждает один из потоков, ожидающих этого объекта. Выбор потока, который будет пробужден, не определяется, поэтому для пробуждения всех ожидающих потоков используется метод notifyAll().

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

public class WaitNotifyExample {
    private final Object lock = new Object();
    private boolean condition = false;

    public void doWait() {
        synchronized (lock) {
            while (!condition) {
                try {
                    System.out.println("Waiting...");
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Condition met!");
        }
    }

    public void doNotify() {
        synchronized (lock) {
            condition = true;
            lock.notify();
            System.out.println("Notified!");
        }
    }

    public static void main(String[] args) {
        WaitNotifyExample example = new WaitNotifyExample();

        Thread waiter = new Thread(example::doWait);
        Thread notifier = new Thread(example::doNotify);

        waiter.start();
        try {
            Thread.sleep(1000); // Задержка для демонстрации ожидания
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        notifier.start();
    }
}

#Java #Training #Multithreading #Medium

136 viewsДен, 05:42

Java for Beginner

Что выведет код?

public class ArrayChallenge {
    public static void main(String[] args) {
        int[][] array = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (i == j || i + j == array.length - 1) {
                    sum += array[i][j];
                }
            }
        }

        System.out.println(sum);
    }
}

#Tasks

146 viewsДен, 08:48

Java for Beginner

Варианты ответа:

Anonymous Quiz

18%

55%

18%

11 voters142 viewsДен, 08:53

Java for Beginner

Ты 🫵 знаешь что делать!🤪

https://t.me/Java_for_beginner_dev

#Mems

144 viewsДен, 10:38

Java for Beginner

This media is not supported in your browser

VIEW IN TELEGRAM

Напоминаю!🫡

Скорее всего, если магнитные бури не сотрут нас с лица земли, в воскресение (16:00 МСК) мы продолжим дописывать наше консольное TODO-приложение.

Приходите, будет интересно)😉

Можно будет и просто пообщаться) 🍻

147 viewsДен, edited 12:28

Java for Beginner

Продвинутые аспекты wait и notify

Метод notifyAll()

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

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

public class WaitNotifyExample {
    private final Object lock = new Object();
    private boolean condition = false;

    public void doWait() {
        synchronized (lock) {
            while (!condition) {
                try {
                    System.out.println(Thread.currentThread().getName() + " is waiting...");
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + " condition met!");
        }
    }

    public void doNotifyAll() {
        synchronized (lock) {
            condition = true;
            lock.notifyAll();
            System.out.println("All notified!");
        }
    }

    public static void main(String[] args) {
        WaitNotifyExample example = new WaitNotifyExample();

        Thread waiter1 = new Thread(example::doWait, "Waiter1");
        Thread waiter2 = new Thread(example::doWait, "Waiter2");
        Thread notifier = new Thread(example::doNotifyAll);

        waiter1.start();
        waiter2.start();
        try {
            Thread.sleep(1000); // Задержка для демонстрации ожидания
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        notifier.start();
    }
}

Реальный пример: производитель-потребитель

Классическая задача, иллюстрирующая использование wait() и notify(), — это проблема "Производитель-потребитель". В этой задаче один или несколько производителей производят данные и добавляют их в общий буфер, а один или несколько потребителей извлекают данные из буфера.

import java.util.LinkedList;
import java.util.Queue;

class Buffer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int maxSize;
    private final Object lock = new Object();

    public Buffer(int maxSize) {
        this.maxSize = maxSize;
    }

    public void produce(int value) throws InterruptedException {
        synchronized (lock) {
            while (queue.size() == maxSize) {
                System.out.println("Buffer is full. Producer is waiting...");
                lock.wait();
            }
            queue.add(value);
            System.out.println("Produced: " + value);
            lock.notifyAll();
        }
    }

    public void consume() throws InterruptedException {
        synchronized (lock) {
            while (queue.isEmpty()) {
                System.out.println("Buffer is empty. Consumer is waiting...");
                lock.wait();
            }
            int value = queue.poll();
            System.out.println("Consumed: " + value);
            lock.notifyAll();
        }
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        Buffer buffer = new Buffer(5);

        Thread producer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    buffer.produce(i);
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    buffer.consume();
                    Thread.sleep(150);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        producer.start();
        consumer.start();
    }
}

#Java #Training #Multithreading #Medium

164 viewsДен, 13:44

Java for Beginner

Всем доброго солнечного утра!

Хотелось бы чтобы каждый подписчик ответил, что именно из контента ему больше нравится, а что не совсем)) Не стесняйтесь, сделаем канал лучше вместе! Итак что Вам нравится и чего надо побольше?

Anonymous Poll

Всего более чем достаточно, можно и поменьше)))

Я напишу свой вариант в комментариях!

13 voters165 viewsДен, 02:22

Java for Beginner

Мы научим Вас производить впечатление на HR😂😎

https://t.me/Java_for_beginner_dev

#Mems

165 viewsДен, 08:19

Java for Beginner

https://t.me/Java_for_beginner_dev

#MyMems

158 viewsДен, edited 07:38

Java for Beginner

Напоминаю!

Сегодня в 16:00 по МСК, мы вновь соберемся онлайн и продолжим дописывать наше консольное TODO-приложение.

Приходите, будет интересно)😉

178 viewsДен, 07:40

About

Blog

Apps

Platform