Java for Beginner

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

import java.util.Stack;

public class StackChallenge {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(10);
        stack.push(20);
        stack.push(30);
        stack.push(40);
        stack.push(50);

        int sum = 0;

        while (!stack.isEmpty()) {
            int value = stack.pop();
            if (value % 20 == 0) {
                stack.push(value / 2);
            } else {
                sum += value;
            }
        }

        System.out.println("Sum: " + sum);
    }
}

#Tasks

196 viewsДен, 08:44

Java for Beginner

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

Anonymous Quiz

16 voters190 viewsДен, 08:48

Java for Beginner

Профессионал😎

https://t.me/Java_for_beginner_dev

#Mems

213 viewsДен, 10:34

Java for Beginner

Внутреннее устройство и методы Stack

Stack в Java наследует класс Vector, что означает, что он использует динамический массив для хранения своих элементов. Это позволяет Stack автоматически изменять свой размер по мере добавления или удаления элементов.

public class Stack<E> extends Vector<E> {
    public Stack() {
    }

    public E push(E item) {
        addElement(item);
        return item;
    }

    public synchronized E pop() {
        E obj;
        int len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

    public synchronized E peek() {
        int len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

    public boolean empty() {
        return size() == 0;
    }

    public synchronized int search(Object o) {
        int i = lastIndexOf(o);

        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }
}

Основные методы Stack

push(E item):
Добавляет элемент на вершину стека.
Возвращает добавленный элемент.

Stack<Integer> stack = new Stack<>();
stack.push(10); // Добавляет элемент 10 на вершину стека

pop():
Удаляет и возвращает элемент с вершины стека.
Бросает EmptyStackException, если стек пуст.

int element = stack.pop(); // Удаляет и возвращает элемент 10

peek():
Возвращает элемент с вершины стека без его удаления.
Бросает EmptyStackException, если стек пуст.

int topElement = stack.peek(); // Возвращает элемент 10, но не удаляет его

isEmpty():
Проверяет, пуст ли стек.
Возвращает true, если стек пуст, и false в противном случае.

boolean isEmpty = stack.isEmpty(); // Возвращает false, так как стек не пуст

search(Object o):
Ищет элемент в стеке и возвращает его позицию относительно вершины.
Возвращает -1, если элемент не найден.

int position = stack.search(10); // Возвращает 1, так как элемент 10 на вершине стека

#Java #Training #Medium #Stack

196 viewsДен, 13:43

Java for Beginner

PriorityQueue, принципы работы и внутреннее устройство

PriorityQueue — это класс из пакета java.util, который реализует интерфейс Queue. В отличие от обычной очереди (FIFO), PriorityQueue основана на приоритетах элементов. Приоритет определяется с помощью естественного порядка элементов или через предоставленный компаратор.

import java.util.PriorityQueue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();

        priorityQueue.add(4);
        priorityQueue.add(1);
        priorityQueue.add(3);

        while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.poll());
        }
    }
}

В этом примере PriorityQueue автоматически упорядочивает элементы, так что при удалении элементов они извлекаются в порядке возрастания: 1, 3, 4.

Принципы работы PriorityQueue

Естественный порядок или компаратор: Элементы могут упорядочиваться на основе их естественного порядка (если элементы реализуют интерфейс Comparable) или на основе компаратора, предоставленного при создании очереди.
Бинарная куча (Binary Heap): Внутренняя реализация PriorityQueue основана на бинарной куче, которая является частично упорядоченным двоичным деревом. Это позволяет эффективно добавлять элементы и извлекать минимальный элемент.
Время выполнения операций: Основные операции PriorityQueue (вставка, удаление минимального элемента) выполняются за логарифмическое время O(log n), где n — количество элементов в очереди.

Внутреннее устройство PriorityQueue

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

public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable {
    private static final int DEFAULT_INITIAL_CAPACITY = 11;
    private Object[] queue;
    private int size;
    private final Comparator<? super E> comparator;

    public PriorityQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    }

    public PriorityQueue(int initialCapacity) {
        this(initialCapacity, null);
    }

    public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.queue = new Object[initialCapacity];
        this.comparator = comparator;
    }

    // Основные методы: add, poll, offer, remove, etc.
}

Ссылки на полезные статьи (спасибо авторам за проделанную работу) :
https://www.baeldung.com/java-priorityqueue
https://sky.pro/media/ispolzovanie-priorityqueue-v-java/

#Java #Training #Medium #PriorityQueue

Baeldung

Guide to Java PriorityQueue | Baeldung

A quick and practical guide to Java's PriorityQueue.

179 viewsДен, 05:13

Java for Beginner

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

import java.util.PriorityQueue;

public class PriorityQueueChallenge {
    public static void main(String[] args) {
        PriorityQueue<String> pq = new PriorityQueue<>();
        pq.add("apple");
        pq.add("banana");
        pq.add("cherry");
        pq.add("date");
        pq.add("elderberry");

        StringBuilder result = new StringBuilder();

        while (!pq.isEmpty()) {
            String value = pq.poll();
            if (value.length() % 2 == 0) {
                pq.add(value.substring(1));
            } else {
                result.append(value.charAt(0));
            }
        }

        System.out.println("Result: " + result);
    }
}

#Tasks

196 viewsДен, 08:48

Java for Beginner

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

Anonymous Quiz

2 voters188 viewsДен, 08:48

Java for Beginner

У него не было шансов👻

https://t.me/Java_for_beginner_dev

#Mems

268 viewsДен, 10:24

Java for Beginner

Завтра в 17:00 по МСК, приглашаем всех на онлайн решение задач с Сodewars!

Решать задачи для Вас и вместе с Вами, будет @Alexander_Gors , за что ему сердечное спасибо! 🤝

Приходите и прокачивайте свои знания!

Ждем всех!

189 viewsДен, 10:54

Java for Beginner

Основные методы PriorityQueue и примеры использования

add(E e):
Добавляет элемент в очередь. Если элемент null, выбрасывает NullPointerException.

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(10);
pq.add(20);
pq.add(15);

offer(E e):
Добавляет элемент в очередь. Возвращает true, если элемент был успешно добавлен, и false в противном случае.

pq.offer(5);

poll():
Возвращает и удаляет элемент с наивысшим приоритетом (минимальный элемент). Возвращает null, если очередь пуста.

Integer top = pq.poll(); // Возвращает 5 и удаляет его из очереди

peek():
Возвращает элемент с наивысшим приоритетом, но не удаляет его. Возвращает null, если очередь пуста.

Integer top = pq.peek(); // Возвращает 10, но не удаляет его

remove(Object o):
Удаляет указанный элемент из очереди, если он присутствует. Возвращает true, если элемент был успешно удален, и false в противном случае.

boolean removed = pq.remove(15); // Удаляет элемент 15

contains(Object o):
Проверяет, присутствует ли указанный элемент в очереди. Возвращает true, если элемент найден, и false в противном случае.

boolean contains = pq.contains(20); // Проверяет наличие элемента 20

size():
Возвращает количество элементов в очереди.

int size = pq.size(); // Возвращает количество элементов в очереди

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

Реализация задачи с приоритетом:

import java.util.PriorityQueue;
import java.util.Comparator;

class Task {
    private String name;
    private int priority;

    public Task(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public String toString() {
        return name + ": " + priority;
    }
}

class TaskComparator implements Comparator<Task> {
    public int compare(Task t1, Task t2) {
        return Integer.compare(t1.getPriority(), t2.getPriority());
    }
}

public class TaskScheduler {
    public static void main(String[] args) {
        PriorityQueue<Task> taskQueue = new PriorityQueue<>(new TaskComparator());

        taskQueue.add(new Task("Task 1", 2));
        taskQueue.add(new Task("Task 2", 1));
        taskQueue.add(new Task("Task 3", 3));

        while (!taskQueue.isEmpty()) {
            System.out.println(taskQueue.poll());
        }
    }
}

Использование с Comparator для обратного порядка:

PriorityQueue<Integer> reversePQ = new PriorityQueue<>(Comparator.reverseOrder());

reversePQ.add(10);
reversePQ.add(20);
reversePQ.add(15);

while (!reversePQ.isEmpty()) {
    System.out.println(reversePQ.poll());
}

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

import java.util.PriorityQueue;

class Job implements Comparable<Job> {
    private String jobName;
    private int executionTime;

    public Job(String jobName, int executionTime) {
        this.jobName = jobName;
        this.executionTime = executionTime;
    }

    @Override
    public int compareTo(Job other) {
        return Integer.compare(this.executionTime, other.executionTime);
    }

    @Override
    public String toString() {
        return jobName + ": " + executionTime;
    }
}

public class JobScheduler {
    public static void main(String[] args) {
        PriorityQueue<Job> jobQueue = new PriorityQueue<>();

        jobQueue.add(new Job("Job 1", 30));
        jobQueue.add(new Job("Job 2", 10));
        jobQueue.add(new Job("Job 3", 20));

        while (!jobQueue.isEmpty()) {
            System.out.println(jobQueue.poll());
        }
    }
}

#Java #Training #Medium #PriorityQueue

194 viewsДен, 14:00

Java for Beginner

ArrayDeque, внутреннее устройство, особенности и преимущества

ArrayDeque — это реализация двусторонней очереди (deque) на основе массивов, предоставляемая в пакете java.util. Она представляет собой гибкую структуру данных, которая поддерживает вставку и удаление элементов с обеих сторон с амортизированным постоянным временем.

import java.util.ArrayDeque;

public class ArrayDequeExample {
    public static void main(String[] args) {
        ArrayDeque<Integer> deque = new ArrayDeque<>();

        deque.addFirst(1);
        deque.addLast(2);
        deque.addFirst(3);
        deque.addLast(4);

        while (!deque.isEmpty()) {
            System.out.println(deque.pollFirst());
        }
    }
}

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

Внутреннее устройство ArrayDeque

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

public class ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, Serializable {
    private transient E[] elements;
    private transient int head;
    private transient int tail;

    public ArrayDeque() {
        elements = (E[]) new Object[16];
    }

    public ArrayDeque(int initialCapacity) {
        elements = (E[]) new Object[initialCapacity];
    }

    // Основные методы: addFirst, addLast, pollFirst, pollLast, etc.
}

Особенности и преимущества

Циклический массив: Использование циклического массива позволяет избежать необходимости перемещения элементов при вставке и удалении с обеих сторон.
Амортизированное постоянное время: Вставка и удаление элементов с обеих сторон выполняются в амортизированное постоянное время O(1), за исключением случаев расширения массива.
Отсутствие блокировок: ArrayDeque не синхронизирована, что делает её быстрее по сравнению с синхронизированными структурами данных, такими как LinkedBlockingDeque.
Гибкость: Поддержка операций вставки и удаления с обеих сторон очереди предоставляет большую гибкость в использовании.

Преимущества использования ArrayDeque

Производительность: ArrayDeque обеспечивает более высокую производительность по сравнению с LinkedList для операций вставки и удаления элементов с обеих сторон.
Гибкость: Она поддерживает как стековые (push, pop), так и очередные (offer, poll) операции, что делает её универсальной для различных задач.
Эффективное использование памяти: Благодаря циклическому массиву ArrayDeque эффективно использует память, минимизируя количество операций по перемещению элементов.

import java.util.ArrayDeque;

public class ArrayDequeExample {
    public static void main(String[] args) {
        ArrayDeque<Integer> deque = new ArrayDeque<>();

        // Добавление элементов
        deque.addFirst(1);
        deque.addLast(2);
        deque.addFirst(3);
        deque.addLast(4);

        // Извлечение элементов
        System.out.println(deque.pollFirst()); // 3
        System.out.println(deque.pollLast());  // 4
        System.out.println(deque.pollFirst()); // 1
        System.out.println(deque.pollLast());  // 2
    }
}

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

Ссылки на полезные статьи (спасибо авторам за проделанную работу) :
https://www.baeldung.com/java-array-deque
https://metanit.com/java/tutorial/5.7.php

#Java #Training #Medium #ArrayDeque

Baeldung

Introduction to the Java ArrayDeque | Baeldung

A quick and practical introduction to ArrayDeque in Java.

224 viewsДен, 05:34

Java for Beginner

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

Anonymous Quiz

17%

33%

175

6 voters208 viewsДен, 08:48

Java for Beginner

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

import java.util.ArrayDeque;

public class ArrayDequeChallenge {
    public static void main(String[] args) {
        ArrayDeque<Integer> deque = new ArrayDeque<>();
        for (int i = 0; i < 10; i++) {
            deque.add(i);
        }

        while (deque.size() > 1) {
            deque.removeFirst();
            if (deque.size() > 1) {
                deque.addLast(deque.removeFirst() + deque.removeLast());
            }
        }

        System.out.println("Result: " + deque.peek());
    }
}

#Tasks

210 viewsДен, 08:48

Java for Beginner

Мы научим Вас плохому😂

https://t.me/Java_for_beginner_dev

#Mems

210 viewsДен, 10:34

Java for Beginner

Внимание!

На гитхабе (возможно, где-то еще) стали появляться поддельные версии goodbyedpi.exe с вирусом.
Тот архив с паролем, имейте ввиду. Поддельный goodbyedpi.exe значительно большего веса (в 40+ раз). Оригинальный ~100 КБ, поддельный > 4 МБ.
Благодаря сообществу ntc.party удалено уже 4 репозитория на гитхабе с поддельным goodbyedpi.exe,
но почти наверняка эти подделки распространились в интернете.

#От_подписчиков

208 viewsДен, edited 13:36

Java for Beginner

Встреча создана! ☝️

Заходите порешать задачки вместе с нами!⭐️

Ждем всех!
https://telemost.yandex.ru/j/42492956505565

235 viewsДен, 13:59

Java for Beginner

Live stream started

14:07

Java for Beginner

Основные методы ArrayDeque и их применение

Основные методы ArrayDeque:

addFirst(E e):
Добавляет элемент в начало очереди. Если очередь заполнена, увеличивает её размер.

ArrayDeque<Integer> deque = new ArrayDeque<>();
deque.addFirst(10);
deque.addFirst(20);
System.out.println(deque); // [20, 10]

addLast(E e):
Добавляет элемент в конец очереди. Если очередь заполнена, увеличивает её размер.

deque.addLast(30);
System.out.println(deque); // [20, 10, 30]

offerFirst(E e):
Предлагает добавить элемент в начало очереди. Возвращает true, если элемент был добавлен успешно.

deque.offerFirst(40);
System.out.println(deque); // [40, 20, 10, 30]

offerLast(E e):
Предлагает добавить элемент в конец очереди. Возвращает true, если элемент был добавлен успешно.

deque.offerLast(50);
System.out.println(deque); // [40, 20, 10, 30, 50]

pollFirst():
Возвращает и удаляет первый элемент из очереди. Возвращает null, если очередь пуста.

Integer first = deque.pollFirst();
System.out.println(first); // 40
System.out.println(deque); // [20, 10, 30, 50]

pollLast():
Возвращает и удаляет последний элемент из очереди. Возвращает null, если очередь пуста.

Integer last = deque.pollLast();
System.out.println(last); // 50
System.out.println(deque); // [20, 10, 30]

peekFirst():
Возвращает первый элемент из очереди, не удаляя его. Возвращает null, если очередь пуста.

Integer peekFirst = deque.peekFirst();
System.out.println(peekFirst); // 20

peekLast():
Возвращает последний элемент из очереди, не удаляя его. Возвращает null, если очередь пуста.

Integer peekLast = deque.peekLast();
System.out.println(peekLast); // 30

push(E e):
Вставляет элемент на вершину стека. Эквивалентен методу addFirst(E e).

deque.push(60);
System.out.println(deque); // [60, 20, 10, 30]

pop():
Возвращает и удаляет элемент с вершины стека. Эквивалентен методу pollFirst().

Integer pop = deque.pop();
System.out.println(pop); // 60
System.out.println(deque); // [20, 10, 30]

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

Реализация стека с использованием ArrayDeque:

import java.util.ArrayDeque;

public class StackExample {
    public static void main(String[] args) {
        ArrayDeque<Integer> stack = new ArrayDeque<>();

        stack.push(1);
        stack.push(2);
        stack.push(3);

        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }
    }
}

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

import java.util.ArrayDeque;

public class QueueExample {
    public static void main(String[] args) {
        ArrayDeque<Integer> queue = new ArrayDeque<>();

        queue.addLast(1);
        queue.addLast(2);
        queue.addLast(3);

        while (!queue.isEmpty()) {
            System.out.println(queue.pollFirst());
        }
    }
}

Реализация двусторонней очереди с использованием ArrayDeque:

import java.util.ArrayDeque;

public class DequeExample {
    public static void main(String[] args) {
        ArrayDeque<Integer> deque = new ArrayDeque<>();

        deque.addFirst(1);
        deque.addLast(2);
        deque.addFirst(3);
        deque.addLast(4);

        while (!deque.isEmpty()) {
            System.out.println(deque.pollFirst());
        }
    }
}

#Java #Training #Medium #ArrayDeque

237 viewsДен, 14:14

Java for Beginner

#Mems

296 viewsАндрей, 18:32

Java for Beginner

Вчера мы провели трансляцию в канале по решению задач с Codewar. Устраивает ли вас такой формат, нужно ли делать запись, для пересмотра?

Anonymous Poll

17%

Да, все ок, записывать не надо.

67%

Да все ок, но запись обязательно нужна, я хочу пересмотреть!

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

11%

Мне не очень нравится/удобно участвовать в таких собраниях, лучше запись, я ее потом посмотрю.

Я и без вас решу все задачи))

Как я оказался в этом канале???

18 voters313 viewsДен, 00:03

Java for Beginner

Java for Beginner pinned «Вчера мы провели трансляцию в канале по решению задач с Codewar. Устраивает ли вас такой формат, нужно ли делать запись, для пересмотра?»

04:58

About

Blog

Apps

Platform