Class Vector<E>

import java.util.Vector;

public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

// Tạo một vector rỗng với dung lượng ban đầu là 10 và tăng trưởng dung lượng mặc định là 0
Vector<String> vector1 = new Vector<>();

// Tạo một vector chứa các phần tử từ một bộ sưu tập khác
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Vector<Integer> vector2 = new Vector<>(numbers);

// Tạo một vector rỗng với dung lượng ban đầu được chỉ định và tăng trưởng dung lượng bằng 0
Vector<Character> vector3 = new Vector<>(20);

// Tạo một vector rỗng với dung lượng ban đầu và tăng trưởng dung lượng được chỉ định
Vector<Double> vector4 = new Vector<>(15, 5); // Dung lượng ban đầu là 15, tăng trưởng 5 đơn vị mỗi khi cần thiết

import java.util.ArrayList;
import java.util.Vector;

public class Example {
    public static void main(String[] args) {
        // Tạo một Vector với kiểu dữ liệu Integer
        Vector<Integer> vector = new Vector<>();

        // Sử dụng phương thức add(E e): Thêm phần tử vào cuối danh sách
        vector.add(10);
        vector.add(20);
        vector.add(30);

        System.out.println("Vector sau khi thêm các phần tử bằng add(E e): " + vector);

        // Sử dụng phương thức add(int index, E element): Chèn phần tử vào vị trí index
        vector.add(1, 15); // Chèn 15 vào vị trí thứ 1 (giữa 10 và 20)
        System.out.println("Vector sau khi chèn 15 vào vị trí index 1: " + vector);

        // Sử dụng phương thức addAll(Collection<? extends E> c): Thêm tất cả các phần tử của một collection vào cuối danh sách
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(40);
        arrayList.add(50);
        vector.addAll(arrayList);

        System.out.println("Vector sau khi thêm tất cả phần tử từ một ArrayList: " + vector);

        // Sử dụng phương thức addAll(int index, Collection<? extends E> c): Thêm tất cả các phần tử của một collection vào vị trí index
        ArrayList<Integer> anotherList = new ArrayList<>();
        anotherList.add(5);
        anotherList.add(7);
        vector.addAll(0, anotherList); // Thêm các phần tử vào đầu danh sách

        System.out.println("Vector sau khi thêm tất cả phần tử từ một collection vào vị trí index 0: " + vector);

        // Sử dụng phương thức addElement(E obj): Thêm phần tử vào cuối danh sách (phương thức cũ)
        vector.addElement(60);
        System.out.println("Vector sau khi thêm phần tử bằng addElement(E obj): " + vector);

        // Sử dụng phương thức insertElementAt(E obj, int index): Chèn phần tử vào vị trí index
        vector.insertElementAt(25, 3); // Chèn 25 vào vị trí thứ 3
        System.out.println("Vector sau khi chèn 25 vào vị trí index 3: " + vector);
    }
}

import java.util.ArrayList;
import java.util.Vector;
import java.util.function.Predicate;

public class Example {
    public static void main(String[] args) {
        // Tạo một Vector với kiểu dữ liệu Integer và thêm các phần tử vào
        Vector<Integer> vector = new Vector<>();
        vector.add(10);
        vector.add(20);
        vector.add(30);
        vector.add(40);
        vector.add(50);

        // In Vector ban đầu
        System.out.println("Vector ban đầu: " + vector);

        // Sử dụng phương thức removeAll(Collection<?> c): Xóa tất cả các phần tử của danh sách này cũng có trong collection c
        ArrayList<Integer> removeList = new ArrayList<>();
        removeList.add(20);
        removeList.add(40);
        vector.removeAll(removeList);

        System.out.println("Vector sau khi xóa tất cả các phần tử có trong removeList: " + vector);

        // Sử dụng phương thức removeAllElements(): Xóa tất cả các phần tử trong danh sách
        vector.removeAllElements();

        System.out.println("Vector sau khi xóa tất cả các phần tử: " + vector);

        // Tạo lại Vector và thêm các phần tử vào
        vector.add(10);
        vector.add(20);
        vector.add(30);
        vector.add(40);
        vector.add(50);

        // Sử dụng phương thức removeElement(Object obj): Xóa phần tử đầu tiên tìm thấy có giá trị bằng obj
        vector.removeElement(30);

        System.out.println("Vector sau khi xóa phần tử 30: " + vector);

        // Sử dụng phương thức removeElementAt(int index): Xóa phần tử tại vị trí index
        vector.removeElementAt(1); // Xóa phần tử tại vị trí index 1 (20)

        System.out.println("Vector sau khi xóa phần tử tại vị trí index 1: " + vector);

        // Sử dụng phương thức removeIf(Predicate<? super E> filter): Xóa tất cả các phần tử thỏa mãn điều kiện filter
        vector.removeIf(new Predicate<Integer>() {
            @Override
            public boolean test(Integer t) {
                return t > 40; // Xóa tất cả các phần tử lớn hơn 40
            }
        });

        System.out.println("Vector sau khi xóa tất cả các phần tử lớn hơn 40: " + vector);
    }
}

import java.util.Vector;

public class Example {
    public static void main(String[] args) {
        // Tạo một Vector với kiểu dữ liệu String và thêm các phần tử vào
        Vector<String> vector = new Vector<>();
        vector.add("Apple");
        vector.add("Banana");
        vector.add("Cherry");
        vector.add("Date");
        vector.add("Apple"); // Thêm phần tử "Apple" thêm một lần nữa

        // In Vector ban đầu
        System.out.println("Vector ban đầu: " + vector);

        // Sử dụng phương thức get(int index): Lấy phần tử tại vị trí index
        String elementAtIndex2 = vector.get(2);
        System.out.println("Phần tử tại vị trí index 2: " + elementAtIndex2);

        // Sử dụng phương thức contains(Object o): Kiểm tra xem danh sách có chứa phần tử o hay không
        boolean containsBanana = vector.contains("Banana");
        System.out.println("Danh sách có chứa 'Banana' không: " + containsBanana);

        // Sử dụng phương thức indexOf(Object o): Trả về chỉ số của lần xuất hiện đầu tiên của o
        int indexOfCherry = vector.indexOf("Cherry");
        System.out.println("Chỉ số của lần xuất hiện đầu tiên của 'Cherry': " + indexOfCherry);

        // Sử dụng phương thức indexOf(Object o, int index): Trả về chỉ số của lần xuất hiện đầu tiên của o bắt đầu từ vị trí index
        int indexOfAppleFromIndex2 = vector.indexOf("Apple", 2);
        System.out.println("Chỉ số của lần xuất hiện đầu tiên của 'Apple' bắt đầu từ vị trí index 2: " + indexOfAppleFromIndex2);

        // Sử dụng phương thức lastIndexOf(Object o): Trả về chỉ số của lần xuất hiện cuối cùng của o
        int lastIndexOfApple = vector.lastIndexOf("Apple");
        System.out.println("Chỉ số của lần xuất hiện cuối cùng của 'Apple': " + lastIndexOfApple);

        // Sử dụng phương thức lastIndexOf(Object o, int index): Trả về chỉ số của lần xuất hiện cuối cùng của o bắt đầu từ vị trí index
        int lastIndexOfAppleFromIndex3 = vector.lastIndexOf("Apple", 3);
        System.out.println("Chỉ số của lần xuất hiện cuối cùng của 'Apple' bắt đầu từ vị trí index 3: " + lastIndexOfAppleFromIndex3);

        // Sử dụng phương thức isEmpty(): Kiểm tra xem danh sách có rỗng hay không
        boolean isEmpty = vector.isEmpty();
        System.out.println("Danh sách có rỗng không: " + isEmpty);

        // Sử dụng phương thức size(): Trả về số lượng phần tử trong danh sách
        int size = vector.size();
        System.out.println("Số lượng phần tử trong danh sách: " + size);

        // Sử dụng phương thức firstElement(): Lấy phần tử đầu tiên
        String firstElement = vector.firstElement();
        System.out.println("Phần tử đầu tiên: " + firstElement);

        // Sử dụng phương thức lastElement(): Lấy phần tử cuối cùng
        String lastElement = vector.lastElement();
        System.out.println("Phần tử cuối cùng: " + lastElement);
    }
}

import java.util.Vector;
import java.util.function.UnaryOperator;

public class Example {
    public static void main(String[] args) {
        // Tạo một Vector với kiểu dữ liệu String và thêm các phần tử vào
        Vector<String> vector = new Vector<>();
        vector.add("Apple");
        vector.add("Banana");
        vector.add("Cherry");
        vector.add("Date");
        vector.add("Elderberry");

        // In Vector ban đầu
        System.out.println("Vector ban đầu: " + vector);

        // Sử dụng phương thức set(int index, E element): Thay thế phần tử tại vị trí index
        vector.set(2, "Blueberry");
        System.out.println("Vector sau khi thay thế phần tử tại vị trí index 2 bằng 'Blueberry': " + vector);

        // Sử dụng phương thức setElementAt(E obj, int index): Thay thế phần tử tại vị trí index (tương tự set(int index, E element))
        vector.setElementAt("Coconut", 3);
        System.out.println("Vector sau khi thay thế phần tử tại vị trí index 3 bằng 'Coconut': " + vector);

        // Sử dụng phương thức replaceAll(UnaryOperator<E> operator): Thay thế mỗi phần tử bằng kết quả của việc áp dụng toán tử lên phần tử đó
        vector.replaceAll(new UnaryOperator<String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase(); // Chuyển tất cả các phần tử thành chữ hoa
            }
        });
        System.out.println("Vector sau khi thay thế mỗi phần tử bằng chữ hoa: " + vector);
    }
}

import java.util.ListIterator;
import java.util.Vector;

public class Example {
    public static void main(String[] args) {
        // Tạo một Vector với kiểu dữ liệu Double và thêm các phần tử vào
        Vector<Double> vector = new Vector<>();
        vector.add(1.1);
        vector.add(2.2);
        vector.add(3.3);
        vector.add(4.4);
        vector.add(5.5);

        // In Vector ban đầu
        System.out.println("Vector ban đầu: " + vector);

        // Sử dụng phương thức listIterator(int index): Trả về một list iterator bắt đầu từ vị trí index
        ListIterator<Double> listIterator = vector.listIterator(2); // Bắt đầu từ vị trí index 2

        System.out.println("Duyệt qua các phần tử bắt đầu từ vị trí index 2:");

        // Duyệt qua các phần tử bằng ListIterator
        while (listIterator.hasNext()) {
            Double element = listIterator.next();
            System.out.println("Phần tử: " + element);
        }

        // Duyệt ngược lại với ListIterator
        System.out.println("Duyệt ngược qua các phần tử:");
        while (listIterator.hasPrevious()) {
            Double element = listIterator.previous();
            System.out.println("Phần tử: " + element);
        }
    }
}

import java.util.Spliterator;
import java.util.Vector;
import java.util.function.Consumer;

public class Example {
    public static void main(String[] args) {
        // Tạo một Vector với kiểu dữ liệu Double và thêm các phần tử vào
        Vector<Double> vector = new Vector<>();
        vector.add(1.1);
        vector.add(2.2);
        vector.add(3.3);
        vector.add(4.4);
        vector.add(5.5);

        // In Vector ban đầu
        System.out.println("Vector ban đầu: " + vector);

        // Sử dụng phương thức spliterator(): Tạo một Spliterator duyệt qua các phần tử
        Spliterator<Double> spliterator = vector.spliterator();

        System.out.println("Duyệt qua các phần tử với Spliterator:");

        // Duyệt qua các phần tử bằng Spliterator
        spliterator.forEachRemaining(new Consumer<Double>() {
            @Override
            public void accept(Double element) {
                System.out.println("Phần tử: " + element);
            }
        });
    }
}

import java.util.Comparator;
import java.util.Vector;

public class Example {
    public static void main(String[] args) {
        // Tạo một Vector với kiểu dữ liệu Double và thêm các phần tử vào
        Vector<Double> vector = new Vector<>();
        vector.add(3.3);
        vector.add(1.1);
        vector.add(4.4);
        vector.add(2.2);
        vector.add(5.5);

        // In Vector ban đầu
        System.out.println("Vector ban đầu: " + vector);

        // Sử dụng phương thức sort(Comparator<? super E> c): Sắp xếp danh sách theo bộ so sánh đã cho
        vector.sort(new Comparator<Double>() {
            @Override
            public int compare(Double d1, Double d2) {
                // So sánh theo thứ tự giảm dần
                return d2.compareTo(d1);
            }
        });

        // In Vector sau khi sắp xếp
        System.out.println("Vector sau khi sắp xếp giảm dần: " + vector);
    }
}

import java.util.List;
import java.util.Vector;
// Đối tượng Person do người dùng định nghĩa
class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name + " (" + age + " Tuổi)";
    }
}

public class Example {
    public static void main(String[] args) {
        // Tạo một Vector chứa các đối tượng Person
        Vector<Person> vector = new Vector<>();
        vector.add(new Person("Alice", 30));
        vector.add(new Person("Bob", 25));
        vector.add(new Person("Charlie", 35));
        vector.add(new Person("Diana", 28));
        vector.add(new Person("Edward", 40));

        // In Vector ban đầu
        System.out.println("Vector ban đầu:");
        for (Person person : vector) {
            System.out.println(person);
        }

        // Sử dụng phương thức subList(int fromIndex, int toIndex): Trả về một view của một phần của danh sách
        List<Person> subList = vector.subList(1, 4); // Lấy các phần tử từ chỉ số 1 đến chỉ số 3 (4 không bao gồm)

        // In subList
        System.out.println("\nSubList (từ chỉ số 1 đến 3):");
        for (Person person : subList) {
            System.out.println(person);
        }
    }
}

import java.util.Vector;

public class Example {
    public static void main(String[] args) {
        // Tạo hai Vector với kiểu dữ liệu String và thêm các phần tử vào
        Vector<String> vector1 = new Vector<>();
        vector1.add("Apple");
        vector1.add("Banana");
        vector1.add("Cherry");

        Vector<String> vector2 = new Vector<>();
        vector2.add("Apple");
        vector2.add("Banana");
        vector2.add("Cherry");

        Vector<String> vector3 = new Vector<>();
        vector3.add("Date");
        vector3.add("Elderberry");
        vector3.add("Fig");

        // So sánh hai Vector
        System.out.println("Vector1 và Vector2 có bằng nhau không? " + vector1.equals(vector2)); // True
        System.out.println("Vector1 và Vector3 có bằng nhau không? " + vector1.equals(vector3)); // False

        // Lấy mã băm của Vector
        System.out.println("Mã băm của Vector1: " + vector1.hashCode());
        System.out.println("Mã băm của Vector2: " + vector2.hashCode());
        System.out.println("Mã băm của Vector3: " + vector3.hashCode());
    }
}