Java for Beginner

Введение в Queue

Queue — это интерфейс в Java, представляющий коллекцию, предназначенную для хранения элементов в порядке, поддерживающем принципы FIFO (First-In-First-Out). Элементы добавляются в конец очереди и извлекаются из начала. Queue является частью коллекций Java и находится в пакете java.util.

Реализации Queue

Существует несколько реализаций интерфейса Queue в Java:

LinkedList: Класс LinkedList реализует интерфейс Queue и предоставляет эффективные операции вставки и удаления с обоих концов списка.

Queue<String> queue = new LinkedList<>();

PriorityQueue: Класс PriorityQueue реализует интерфейс Queue и предоставляет приоритетную очередь, в которой элементы упорядочены на основе их естественного порядка или на основе предоставленного компаратора.

Queue<String> priorityQueue = new PriorityQueue<>();

ArrayDeque: Класс ArrayDeque реализует интерфейс Deque (двусторонняя очередь) и может использоваться как Queue.

Queue<String> arrayDeque = new ArrayDeque<>();

Основные операции:

Добавление элементов:

add(E e): Добавляет элемент в конец очереди. Выбрасывает исключение IllegalStateException, если очередь ограничена и заполнена.

queue.add("Element");

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

queue.offer("Element");

Удаление элементов:

remove(): Удаляет и возвращает элемент из начала очереди. Выбрасывает исключение NoSuchElementException, если очередь пуста.

String element = queue.remove();

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

String element = queue.poll();

Просмотр элементов:

element(): Возвращает, но не удаляет, элемент из начала очереди. Выбрасывает исключение NoSuchElementException, если очередь пуста.

String element = queue.element();

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

String element = queue.peek();

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

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

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

        // Добавление элементов
        queue.add("Element 1");
        queue.offer("Element 2");

        // Просмотр элемента
        System.out.println("Peek: " + queue.peek());

        // Удаление элементов
        System.out.println("Removed: " + queue.remove());
        System.out.println("Polled: " + queue.poll());

        // Попытка просмотра/удаления из пустой очереди
        System.out.println("Peek from empty queue: " + queue.peek());
        System.out.println("Poll from empty queue: " + queue.poll());
    }
}

#Java #Training #Collections #Queue

146 viewsДен, edited 05:22

Java for Beginner

Введение в Stack

Stack — это класс в Java, представляющий коллекцию, предназначенную для хранения элементов в порядке, поддерживающем принципы LIFO (Last-In-First-Out). Элементы добавляются и извлекаются с одного конца стека, называемого вершиной. Класс Stack находится в пакете java.util и наследуется от класса Vector.

Создание Stack

Для создания экземпляра Stack нужно импортировать класс java.util.Stack и использовать его конструктор:

Stack<String> stack = new Stack<>();

Основные операции

Добавление элементов:

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

stack.push("Element");

Удаление элементов:

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

String element = stack.pop();

Просмотр элементов:

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

String element = stack.peek();

Проверка состояния стека:

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

boolean isEmpty = stack.empty();

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

int position = stack.search("Element");

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

import java.util.Stack;

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

        // Добавление элементов
        stack.push("Element 1");
        stack.push("Element 2");
        stack.push("Element 3");

        // Просмотр элемента
        System.out.println("Peek: " + stack.peek());

        // Удаление элементов
        System.out.println("Popped: " + stack.pop());
        System.out.println("Popped: " + stack.pop());

        // Проверка состояния стека
        System.out.println("Is stack empty? " + stack.empty());

        // Поиск элемента
        stack.push("Element 4");
        stack.push("Element 5");
        System.out.println("Position of 'Element 4': " + stack.search("Element 4"));

        // Удаление оставшихся элементов
        System.out.println("Popped: " + stack.pop());
        System.out.println("Popped: " + stack.pop());

        // Попытка просмотра/удаления из пустого стека
        System.out.println("Is stack empty? " + stack.empty());
    }
}

Сравнение Queue и Stack
Очередь (Queue): Использует порядок FIFO (First-In-First-Out). Элементы добавляются в конец и удаляются из начала.
Стек (Stack): Использует порядок LIFO (Last-In-First-Out). Элементы добавляются и удаляются с вершины.

#Java #Training #Collections

136 viewsДен, 13:25

Java for Beginner

Collections, особенности и внутреннее устройство

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

Что такое коллекции?
Коллекции в Java представляют собой архитектуру, позволяющую группировать объекты, чтобы упростить управление и манипулирование ими. В Java коллекции представлены в виде интерфейсов и классов, которые обеспечивают удобные методы для работы с данными. Основные интерфейсы коллекций включают List, Set, Queue, Deque и Map. Каждый из этих интерфейсов реализуется различными классами, которые обеспечивают конкретную реализацию соответствующих структур данных.

Иерархия коллекций в Java начинается с интерфейса Collection, который является корневым интерфейсом для всех коллекций, за исключением Map. Вот основные интерфейсы и классы, которые используются для создания коллекций:
Collection: Основной интерфейс, от которого наследуются другие коллекции.

List: Коллекция, представляющая собой упорядоченный набор элементов, допускающий дублирование. Примеры: ArrayList, LinkedList.
Set: Коллекция, не допускающая дублирование элементов. Примеры: HashSet, TreeSet.
Queue: Коллекция, представляющая собой очередь, работающую по принципу FIFO (first-in, first-out). Примеры: LinkedList, PriorityQueue.
Deque: Двусторонняя очередь, позволяющая добавлять и удалять элементы с обеих сторон. Примеры: ArrayDeque, LinkedList.
Map: Интерфейс для хранения пар «ключ-значение», где каждый ключ уникален. Примеры: HashMap, TreeMap, LinkedHashMap.

Внутреннее устройство коллекций
Каждая коллекция в Java имеет свое уникальное внутреннее устройство и особенности, которые делают её подходящей для решения определенных задач:

1. ArrayList
ArrayList является реализацией интерфейса List, которая использует динамический массив для хранения элементов. Это означает, что элементы в ArrayList могут быть доступны по индексу, и этот доступ осуществляется за константное время (O(1)). Однако добавление новых элементов может потребовать перераспределения массива, что занимает время O(n). ArrayList отлично подходит для задач, где требуется частый доступ к элементам по индексу.

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

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        System.out.println("List: " + list);
    }
}

2. LinkedList
LinkedList также реализует интерфейс List, но использует связный список для хранения элементов. В отличие от ArrayList, LinkedList обеспечивает эффективное добавление и удаление элементов в начале и середине списка, поскольку для этого не требуется перераспределение памяти. Однако доступ к элементам по индексу занимает больше времени, так как необходимо последовательно переходить от одного узла к другому.

import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        System.out.println("List: " + list);
    }
}

#Java #Training #Medium #Collections

169 views05:34

Java for Beginner

3. HashSet
HashSet реализует интерфейс Set и хранит элементы в виде хэш-таблицы. В HashSet не допускается дублирование элементов, и порядок их хранения не гарантируется. Хэш-таблица обеспечивает быстрый доступ к элементам (O(1)), что делает HashSet отличным выбором для задач, где важна производительность при добавлении и поиске уникальных элементов.

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

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        set.add("Apple"); // Дубликат не будет добавлен

        System.out.println("Set: " + set);
    }
}

4. TreeSet
TreeSet также реализует интерфейс Set, но хранит элементы в отсортированном порядке с использованием красно-черного дерева. Доступ к элементам и операции добавления выполняются за логарифмическое время (O(log n)). TreeSet используется, когда необходимо поддерживать элементы в отсортированном порядке.

import java.util.Set;
import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("Banana");
        set.add("Apple");
        set.add("Cherry");

        System.out.println("Sorted Set: " + set);
    }
}

5. HashMap
HashMap реализует интерфейс Map и хранит данные в виде пар «ключ-значение». Ключи в HashMap уникальны, и доступ к значениям по ключу осуществляется за константное время (O(1)). HashMap является отличным выбором для хранения ассоциативных массивов, где важна производительность при доступе к данным по ключу.

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);

        System.out.println("Map: " + map);
    }
}

Особенности коллекций

Изменяемые и неизменяемые коллекции: Большинство коллекций в Java являются изменяемыми, что означает, что их элементы можно добавлять, удалять и изменять. Однако существуют и неизменяемые коллекции, которые нельзя изменить после создания. Создание неизменяемых коллекций особенно важно в многопоточных приложениях для предотвращения непредсказуемого поведения.

Синхронизированные коллекции: Коллекции, такие как ArrayList и HashMap, не синхронизированы по умолчанию, что делает их небезопасными для многопоточной среды. Java предоставляет методы для создания синхронизированных коллекций, например, с использованием Collections.synchronizedList().

Производительность: Выбор правильной коллекции влияет на производительность приложения. Например, для частых операций вставки и удаления в середине списка лучше подходит LinkedList, тогда как для доступа по индексу предпочтительнее использовать ArrayList.

#Java #Training #Medium #Collections

👍2

153 views05:34

Java for Beginner

Основные утилитные методы класса Collections

1. sort(List<T> list)
Метод sort(List<T> list) сортирует элементы списка в естественном порядке или с использованием заданного компаратора. Это один из самых часто используемых методов для упорядочивания элементов в списке.

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

public class SortExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(3);
        numbers.add(1);
        numbers.add(4);
        numbers.add(2);

        Collections.sort(numbers);

        System.out.println("Sorted list: " + numbers);
    }
}

Вывод:

Sorted list: [1, 2, 3, 4]
Этот пример демонстрирует сортировку списка целых чисел в естественном порядке (по возрастанию). Метод sort упорядочивает элементы на месте, изменяя исходный список.

2. reverse(List<?> list)
Метод reverse(List<?> list) изменяет порядок элементов в списке на противоположный. Это полезно, когда необходимо быстро изменить порядок элементов, например, для реализации функции отмены действий или для отображения данных в обратном порядке.

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

public class ReverseExample {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>();
        items.add("Apple");
        items.add("Banana");
        items.add("Cherry");

        Collections.reverse(items);

        System.out.println("Reversed list: " + items);
    }
}

Вывод:

Reversed list: [Cherry, Banana, Apple]
В этом примере список строк меняет свой порядок на противоположный с помощью метода reverse.

3. shuffle(List<?> list)
Метод shuffle(List<?> list) случайным образом перемешивает элементы списка. Этот метод полезен для создания случайных выборок данных, например, при разработке игр, тестов или при случайном перемешивании колоды карт.

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

public class ShuffleExample {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>();
        items.add("Apple");
        items.add("Banana");
        items.add("Cherry");

        Collections.shuffle(items);

        System.out.println("Shuffled list: " + items);
    }
}

Вывод может быть таким:

Shuffled list: [Banana, Cherry, Apple]
Метод shuffle перемешивает элементы списка в случайном порядке, так что каждый вызов метода может давать разный результат.

4. binarySearch(List<? extends Comparable<? super T>> list, T key)
Метод binarySearch(List<? extends Comparable<? super T>> list, T key) выполняет двоичный поиск указанного элемента в отсортированном списке. Метод возвращает индекс элемента, если он найден, и отрицательное значение, если элемент отсутствует в списке.

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

public class BinarySearchExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

        int index = Collections.binarySearch(numbers, 3);

        if (index >= 0) {
            System.out.println("Found at index: " + index);
        } else {
            System.out.println("Not found");
        }
    }
}

Вывод:

Found at index: 2
Этот пример демонстрирует использование двоичного поиска для поиска числа 3 в отсортированном списке чисел.

#Java #Training #Medium #Collections

143 views14:24

About

Blog

Apps

Platform