问什么是 Java Collection Framework？

Ans Java Collection 框架是一个功能强大的内置库，提供了一组最常用数据结构和算法的优化实现。它广泛用于构建 Java 应用程序和解决实际软件开发问题挑战。

Java集合框架有何优势？

Ans Java Collection 框架的一些优点是

1. 统一架构：每个数据结构都源自接口，例如可迭代接口和集合接口，提供通用实现的感觉。
2. 易于使用：它通过提供预构建的数据结构和算法来简化开发过程。开发者可以更加专注于业务逻辑，而不是手动实现和优化常用的数据结构和标准算法。
3. 灵活性：如果我们想改变底层数据结构，我们可以轻松地做到这一点，而不必担心改变数据结构会改变数据检索和访问模式（大部分）。
4. 线程安全：由于java提供了一种在不同线程上单独运行进程的方法，Java Collection Framework提供了不同的类来在多线程环境和单线程应用程序中运行。

JAVA 集合框架层次结构

可迭代接口
Java 中的 Iterable 接口是 Collection Framework 的关键组件。它是所有可迭代集合类型的根接口。实现 Iterable 接口允许对象成为“for-each 循环”（也称为增强 for 循环）的目标。
它还提供了一个迭代器对象，可用于实现此可迭代接口的所有数据结构的前向迭代。

使用 FOR EACH 循环的示例（增强型 FOR 循环）

ArrayList内部实现了List，List Interface扩展了Collection Interface，Collection Interface扩展了Iterable Interface。

List list = new ArrayList();//声明一个数据结构
list.add("Java");//添加元素
list.add("Collections");//添加元素
list.add("Framework");//添加元素
for (String element : list) {//使用增强的for循环进行迭代
System.out.println(element);
}

使用 ITERABLE 对象的示例

Iterator iterator = list.iterator();
while (iterator.hasNext()) {
字符串元素 = iterator.next();
System.out.println(element);
}

因此，我们可以创建自定义可迭代，实现可迭代接口并重写 next、hasNext 和 remove 方法。这是相同的示例。

import java.util.Iterator;
class CustomIterable implements Iterable {
    private final int[] numbers = {1, 2, 3, 4, 5};

    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int index = 0;
            private int lastReturnedIndex = -1;

            @Override
            public boolean hasNext() {
                return index 



笔记 ：

Java 中的迭代器是快速失败的。这意味着如果集合在迭代时被修改（除了通过迭代器自己的remove()方法），它会抛出ConcurrentModificationException。
remove() 方法只能删除元素，并且每次调用 next() 时只能调用一次。否则，它将抛出 IllegalStateException。

  
  
  采集接口


这是数据结构和内部实现变得灵活的接口。大多数类都间接实现此接口，允许通过更改分配给它的 Collection 引用的对象来更改实现。


//ArrayList
Collection c = new ArrayList():
c.add(1);
c.add(2);
c.contains(1);

Collection c1 = new LinkedList():
c1.addAll(c);//Array added to a linked list

/*What if i dont want arraylist but now i want a priority queue for applying efficient algorithms such as findmax and find min*/
//Just Change Object - SIMPLE!
Collection c = new **PriorityQueue**():
c.add(1);
c.add(2);
c.contains(1);




集合接口方法


int size : 返回集合的大小。

boolean isEmpty : 如果集合为空则返回 true。

boolean contains(Object o) ：如果集合中存在对象 o，则返回 true。

Iterator iterator() ：返回指向集合的迭代器。

Object[] toArray() ：将集合转换为 Object 类型的数组。

 T[] toArray(T[] a) ：返回包含集合所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

boolean add(E e) ：将元素 e 添加到集合中。如果操作成功则返回true。

boolean remove(Object o) ：从集合中删除对象 o。如果操作成功则返回true。

boolean containsAll(Collection> c) ：如果两个集合中的所有元素相同，则返回 true。如果操作成功则返回 true。
10.boolean addAll(Collection extends E> c) ：添加两个集合的所有元素。如果操作成功则返回true。

boolean removeAll(Collection> c) ：从调用者集合中删除集合 c 的元素。如果操作成功则返回true。

boolean keepAll(Collection> c) ：仅保留集合 c.
 中存在的元素

voidclear() ：清除集合中的所有元素。
通过实现集合类，我们可以重写上面的方法来创建自定义集合。以下是相同的示例。


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class CustomCollection implements Collection {
    private final ArrayList list = new ArrayList();

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return list.contains(o);
    }

    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index  T[] toArray(T[] a) {
        return list.toArray(a);
    }

    @Override
    public boolean add(E e) {
        return list.add(e);
    }

    @Override
    public boolean remove(Object o) {
        return list.remove(o);
    }

    @Override
    public boolean containsAll(Collection> c) {
        return list.containsAll(c);
    }

    @Override
    public boolean addAll(Collection extends E> c) {
        return list.addAll(c);
    }

    @Override
    public boolean removeAll(Collection> c) {
        return list.removeAll(c);
    }

    @Override
    public boolean retainAll(Collection> c) {
        return list.retainAll(c);
    }

    @Override
    public void clear() {
        list.clear();
    }
}







  
  
  列表接口


Java中的List接口是Java Collections Framework的一部分，并且扩展了Collection接口。它表示一个有序集合（也称为序列），允许位置访问、重复元素以及对其元素进行迭代。 List 接口由几个类实现，例如 ArrayList、LinkedList、Vector 和 Stack。

列表界面的主要特征：

有序集合：列表保留元素的插入顺序，这意味着可以通过索引访问元素。
允许重复：列表可以包含重复元素，与不允许重复的集合不同。
位置访问：可以通过索引访问、添加或删除列表中的元素。
迭代：List 接口允许增强 for 循环，以及使用 Iterator 或 ListIterator 进行迭代。
List接口常用方法：
所有集合接口方法也由List接口实现，因为List接口扩展了Collection接口。

void add(int index, E element)：在此列表中的指定索引处插入指定元素 E。
E get(int index)：返回此列表中指定位置的元素。
E remove(int index)：删除列表中指定位置的元素。
E set(int index, E element)：用指定元素替换此列表中指定位置的元素。
int indexOf(Object o)：返回指定元素第一次出现的索引，如果列表不包含该元素，则返回 -1。
int lastIndexOf(Object o)：返回指定元素最后一次出现的索引，如果列表不包含该元素，则返回 -1。
List subList(int fromIndex, int toIndex)：返回此列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分的视图。

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

public class ListExample {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Java");
        list.add("Collections");
        list.add("Framework");

        // Accessing elements by index
        System.out.println("First Element: "   list.get(0));

        // Removing an element by index
        list.remove(1);
        System.out.println("After Removal: "   list);

        // Updating an element
        list.set(1, "Updated Element");
        System.out.println("Updated List: "   list);

        // Using a sublist
        List sublist = list.subList(0, 1);
        System.out.println("Sublist: "   sublist);
    }
}