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

stack.push("Element");

String element = stack.pop();

String element = stack.peek();

boolean isEmpty = stack.empty();

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

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

public class Box<T> {
    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

Box<Integer> integerBox = new Box<>();
integerBox.set(10);
System.out.println(integerBox.get());

Box<String> stringBox = new Box<>();
stringBox.set("Hello");
System.out.println(stringBox.get());

public class Util {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"one", "two", "three"};

Util.printArray(intArray);
Util.printArray(strArray);

public interface Pair<K, V> {
    K getKey();
    V getValue();
}

public class OrderedPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;

    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }
}

Pair<String, Integer> pair = new OrderedPair<>("One", 1);
System.out.println("Key: " + pair.getKey() + ", Value: " + pair.getValue());

public class Pair<T, U> {
    private T first;
    private U second;

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public void setSecond(U second) {
        this.second = second;
    }

    @Override
    public String toString() {
        return "Pair{" + "first=" + first + ", second=" + second + '}';
    }
}

Pair<Integer, String> pair = new Pair<>(1, "One");
System.out.println(pair); // Output: Pair{first=1, second=One}

pair.setFirst(2);
pair.setSecond("Two");
System.out.println(pair); // Output: Pair{first=2, second=Two}

public class TypeCastingExample {
    public static void main(String[] args) {
        Parent parent = new Child();
        Child child;
        
        try {
            child = (Child) parent;
            System.out.println(child.getMessage());
        } catch (ClassCastException e) {
            System.out.println("ClassCastException");
        }

        try {
            Parent anotherParent = new AnotherChild();
            child = (Child) anotherParent;
            System.out.println(child.getMessage());
        } catch (ClassCastException e) {
            System.out.println("ClassCastException");
        }
    }
}

class Parent {
    String getMessage() {
        return "Parent";
    }
}

class Child extends Parent {
    @Override
    String getMessage() {
        return "Child";
    }
}

class AnotherChild extends Parent {
    @Override
    String getMessage() {
        return "AnotherChild";
    }
}

public class Box<T extends Number> {
    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

public <T extends Number & Comparable<T>> T findMax(T[] array) {
    T max = array[0];
    for (T element : array) {
        if (element.compareTo(max) > 0) {
            max = element;
        }
    }
    return max;
}

public void printList(List<?> list) {
    for (Object element : list) {
        System.out.println(element);
    }
}

public void addNumbers(List<? extends Number> list) {
    double sum = 0;
    for (Number number : list) {
        sum += number.doubleValue();
    }
    System.out.println("Sum: " + sum);
}

public void addIntegers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}

public class ComparableBox<T extends Comparable<T>> {
    private T value;

    public ComparableBox(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public int compareTo(ComparableBox<T> other) {
        return value.compareTo(other.getValue());
    }
}

public class Util {
    public static <T> boolean compare(Box<T> box1, Box<T> box2) {
        return box1.get().equals(box2.get());
    }
}

Box<Integer> box1 = new Box<>();
box1.set(10);
Box<Integer> box2 = new Box<>();
box2.set(10);

boolean result = Util.compare(box1, box2); // true

public class OuterClass {
    private String outerField = "Outer Field";

    public class InnerClass {
        public void display() {
            System.out.println("Outer field is: " + outerField);
        }
    }

    public void testInner() {
        InnerClass inner = new InnerClass();
        inner.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.testInner();
    }
}

public class OuterClass {
    public void methodWithInnerClass() {
        class LocalInnerClass {
            void display() {
                System.out.println("This is a local inner class");
            }
        }
        
        LocalInnerClass localInner = new LocalInnerClass();
        localInner.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.methodWithInnerClass();
    }
}

public class OuterClass {
    public void createAnonymousClass() {
        MyInterface anonymous = new MyInterface() {
            @Override
            public void myMethod() {
                System.out.println("Anonymous inner class method");
            }
        };
        anonymous.myMethod();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.createAnonymousClass();
    }
}

interface MyInterface {
    void myMethod();
}

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>(Arrays.asList("apple", "banana", "cherry", "date"));
        List<String> list = new ArrayList<>(set);
        
        Collections.sort(list, new CustomComparator());
        Queue<String> queue = new LinkedList<>(list);

        System.out.println(queue.poll() + " " + queue.peek());
    }
}

class CustomComparator implements Comparator<String> {
    @Override
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
}