CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("Apple");
list.add(1, "Banana");

list.remove("Banana");
list.remove(0);

list.set(0, "Orange");

String fruit = list.get(0);

boolean containsApple = list.contains("Apple");
int size = list.size();

for (String fruit : list) {
    System.out.println(fruit);
}

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.List;
import java.util.Iterator;

public class CopyOnWriteArrayListMethodsExample {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();

        // Добавление элементов
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        System.out.println("After adding elements: " + list);

        // Вставка элемента
        list.add(1, "Orange");
        System.out.println("After insertion: " + list);

        // Обновление элемента
        list.set(2, "Mango");
        System.out.println("After updating: " + list);

        // Удаление элемента по индексу
        list.remove(3);
        System.out.println("After removing by index: " + list);

        // Удаление элемента по значению
        list.remove("Apple");
        System.out.println("After removing by value: " + list);

        // Проверка содержимого
        boolean containsBanana = list.contains("Banana");
        System.out.println("Contains Banana: " + containsBanana);

        // Получение элемента
        String fruit = list.get(0);
        System.out.println("Element at index 0: " + fruit);

        // Итерация по элементам
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println("Iterating: " + iterator.next());
        }

        // Размер списка
        int size = list.size();
        System.out.println("Size of list: " + size);

        // Очистка списка
        list.clear();
        System.out.println("After clearing: " + list);
    }
}

import java.util.Vector;

public class VectorExample {
    public static void main(String[] args) {
        // Создание вектора с начальной емкостью 10
        Vector<String> vector = new Vector<>(10);

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

        // Чтение элементов
        System.out.println("Element at index 1: " + vector.get(1));

        // Удаление элемента
        vector.remove(2);

        // Итерация по элементам
        for (String element : vector) {
            System.out.println("Element: " + element);
        }
    }
}

import java.util.Vector;

public class VectorChallenge {
    public static void main(String[] args) {
        Vector<Integer> vector = new Vector<>();
        vector.add(15);
        vector.add(30);
        vector.add(45);
        vector.add(60);
        vector.add(75);

        // Iterate and modify
        for (int i = 0; i < vector.size(); i++) {
            if (vector.get(i) % 30 == 0) {
                vector.set(i, vector.get(i) / 2);
            }
        }

        // Add new elements
        vector.add(10);
        vector.add(20);

        int sum = 0;
        for (int num : vector) {
            sum += num;
        }

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

Vector<String> vector = new Vector<>();
vector.add("Element 1");

vector.add(1, "Element 2");

String element = vector.get(0);

int size = vector.size();

vector.remove("Element 1");

vector.remove(0);

Enumeration<String> enumeration = vector.elements();
while (enumeration.hasMoreElements()) {
    System.out.println("Element: " + enumeration.nextElement());
}

Iterator<String> iterator = vector.iterator();
while (iterator.hasNext()) {
    System.out.println("Element: " + iterator.next());
}

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("Top element: " + stack.peek());

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

        // Чтение элементов после удаления
        System.out.println("Top element after pop: " + stack.peek());
    }
}

public static String reverseString(String input) {
    Stack<Character> stack = new Stack<>();
    for (char c : input.toCharArray()) {
        stack.push(c);
    }
    StringBuilder reversed = new StringBuilder();
    while (!stack.isEmpty()) {
        reversed.append(stack.pop());
    }
    return reversed.toString();
}

public static boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '{' || c == '[') {
            stack.push(c);
        } else {
            if (stack.isEmpty()) return false;
            char top = stack.pop();
            if ((c == ')' && top != '(') || (c == '}' && top != '{') || (c == ']' && top != '[')) {
                return false;
            }
        }
    }
    return stack.isEmpty();
}

public static String infixToPostfix(String expression) {
    Stack<Character> stack = new Stack<>();
    StringBuilder result = new StringBuilder();
    for (char c : expression.toCharArray()) {
        if (Character.isLetterOrDigit(c)) {
            result.append(c);
        } else if (c == '(') {
            stack.push(c);
        } else if (c == ')') {
            while (!stack.isEmpty() && stack.peek() != '(') {
                result.append(stack.pop());
            }
            stack.pop();
        } else {
            while (!stack.isEmpty() && precedence(c) <= precedence(stack.peek())) {
                result.append(stack.pop());
            }
            stack.push(c);
        }
    }
    while (!stack.isEmpty()) {
        result.append(stack.pop());
    }
    return result.toString();
}

public static int precedence(char ch) {
    switch (ch) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        case '^':
            return 3;
    }
    return -1;
}

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);
    }
}

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

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

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

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

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