public class demo1 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        arrayList.add(5);
        // 使用for循环和下标遍历ArrayList
        System.out.println("for循环:");
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }

        // 使用增强的for循环（foreach）遍历ArrayList
        System.out.println("\n增强for循环:");
        for (Integer number : arrayList) {
            System.out.println(number);
        }

        // 使用迭代器遍历ArrayList
        System.out.println("\nIterator:");
        Iterator<Integer> iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

// 添加一个新的元素 'e' 到列表中
public boolean add(E e) {
    // 确保数组有足够的容量来容纳新元素
    // 'size + 1' 传递给 ensureCapacityInternal 方法，检查是否有空间添加一个新元素
    ensureCapacityInternal(size + 1);  // 增加 modCount 的值
    
    // 将元素添加到当前 'size' 位置，然后将 'size' 加 1
    elementData[size++] = e;
    
    // 返回 true 表示元素添加成功
    return true;
}

// 确保内部数组的容量至少为 'minCapacity'
private void ensureCapacityInternal(int minCapacity) {
    // 计算所需的容量，并确保数组具有这种容量
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

// 计算基于当前元素和所需最小容量的实际需要的容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 如果当前的 elementData 数组是默认的空数组，确保有一个最小初始容量
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 返回默认容量和所需最小容量中的较大者
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 否则，直接返回所需的最小容量
    return minCapacity;
}

// 确保数组具有指定的明确容量 'minCapacity'
private void ensureExplicitCapacity(int minCapacity) {
    // 每次进行容量检查或扩展时，修改计数 modCount 增加
    modCount++;
 
    // 溢出意识的代码
    // 如果所需的最小容量大于当前数组长度，执行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

// 扩展数组的容量以容纳至少 'minCapacity' 个元素
private void grow(int minCapacity) {
    // 获取旧的容量大小
    int oldCapacity = elementData.length;
    // 新容量扩展到原容量的约 1.5 倍，右移一位相当于除以 2
    // 扩容并不是严格的 1.5 倍，而是大约的倍数
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    
    // 如果新容量仍然小于所需的最小容量，则直接使用所需的最小容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    
    // 如果新容量超出了最大数组大小，调用 hugeCapacity 方法获取最终容量
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    
    // 调用 Arrays.copyOf 扩展数组到新容量
    elementData = Arrays.copyOf(elementData, newCapacity);
}

public class demo2 {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1); // add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());
        // for-each遍历
        for (int e:list) {
            System.out.print(e + " ");
        }
        System.out.println();
        // 使用迭代器遍历---正向遍历
        ListIterator<Integer> it = list.listIterator();
        while(it.hasNext()){
            System.out.print(it.next()+ " ");
        }
        System.out.println();
        // 使用反向迭代器---反向遍历
        ListIterator<Integer> rit = list.listIterator(list.size());
        while (rit.hasPrevious()){
            System.out.print(rit.previous() +" ");
        }
        System.out.println();
    }
}

public class Demo3 {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        
        // 添加元素到栈
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        stack.push(7);
        
        System.out.println("栈的大小: " + stack.size());

        // 1. 使用 for-each 循环遍历
        System.out.print("for-each 循环遍历: ");
        for (int element : stack) {
            System.out.print(element + " ");
        }
        System.out.println();
        
        // 2. 使用正向迭代器遍历
        System.out.print("正向迭代器遍历: ");
        Iterator<Integer> iterator = stack.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
        
        // 3. 使用反向迭代器遍历
        System.out.print("反向迭代器遍历: ");
        ListIterator<Integer> reverseIterator = stack.listIterator(stack.size());
        while (reverseIterator.hasPrevious()) {
            System.out.print(reverseIterator.previous() + " ");
        }
        System.out.println();
    }
}

Deque<Integer> stack = new ArrayDeque<>();	//双端队列的线性实现
Deque<Integer> queue = new LinkedList<>();	//双端队列的链式实现

public class Demo4 {
    public static void main(String[] args) {
        Deque<Integer> deque = new ArrayDeque<>();

        // 添加元素到双端队列
        deque.add(1);  // add 方法默认添加到尾部
        deque.add(2);
        deque.add(3);
        deque.add(4);
        deque.add(5);
        deque.add(6);
        deque.add(7);

        System.out.println("双端队列的大小: " + deque.size());

        // 1. 使用 for-each 循环遍历
        System.out.print("for-each 循环遍历: ");
        for (int element : deque) {
            System.out.print(element + " ");
        }
        System.out.println();

        // 2. 使用正向迭代器遍历
        System.out.print("正向迭代器遍历: ");
        Iterator<Integer> iterator = deque.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();

        // 3. 使用反向迭代器遍历
        System.out.print("反向迭代器遍历: ");
        Iterator<Integer> reverseIterator = deque.descendingIterator();
        while (reverseIterator.hasNext()) {
            System.out.print(reverseIterator.next() + " ");
        }
        System.out.println();
    }
}

public class SetDemo {
    public static void main(String[] args) {
        Set<String> s = new HashSet<>();
        s.add("张三");
        s.add("李四");
        s.add("王五");
        //增强for循环
        for (String s1 : s) {
            System.out.println(s1);
        }
        System.out.println("--------------");
        //迭代器
        Iterator<String> iterator = s.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("--------------");
        //Lambda表达式
        s.forEach(str -> System.out.println(str));
    }
}

public class Demo6 {
    public static void main(String[] args) {
        // 创建一个TreeSet实例
        SortedSet<Integer> sortedSet = new TreeSet<>();

        // 添加元素
        sortedSet.add(5);
        sortedSet.add(1);
        sortedSet.add(3);
        sortedSet.add(2);
        sortedSet.add(4);

        // 输出集合
        System.out.println("SortedSet: " + sortedSet);

        // 获取第一个和最后一个元素
        System.out.println("First: " + sortedSet.first());
        System.out.println("Last: " + sortedSet.last());

        // 获取子集
        SortedSet<Integer> headSet = sortedSet.headSet(3);
        System.out.println("HeadSet (less than 3): " + headSet);

        SortedSet<Integer> tailSet = sortedSet.tailSet(3);
        System.out.println("TailSet (3 or more): " + tailSet);

        SortedSet<Integer> subSet = sortedSet.subSet(2, 4);
        System.out.println("SubSet (2 inclusive, 4 exclusive): " + subSet);
    }
}