鸿鹄的JAVA学习第八课：数据结构和集合进阶（2）

方法	描述
`add(E e)`	向链表尾部添加元素，返回`true`
`add(int index, E element)`	在指定索引处插入元素（需遍历链表，效率较低）
`get(int index)`	获取指定索引处的元素（需遍历链表，效率较低）
`set(int index, E element)`	修改指定索引处的元素，返回旧值
`remove(int index)`	删除指定索引处的元素，返回被删除的元素
`size()`	返回链表中元素的个数
`contains(Object o)`	判断链表是否包含指定元素（需遍历链表）

import java.util.LinkedList;

public class Main2 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add(1,"ccc");
        String r=list.get(2);//返回“bbb”
        System.out.println(r);
        for (String bookName : list) {
            System.out.println(bookName);
        }//返回“aaa”,"ccc","bbb"
        int a=list.size();
        System.out.println(a);//返回3
        list.set(2,"ddd");
        for (String bookName : list) {
            System.out.println(bookName);
        }//返回“aaa”,"ccc","ddd"
    }
}

3.2. 作为双端队列的方法

头部操作：

方法	描述
`addFirst(E e)`	在头部插入元素
`getFirst()`	获取头部元素（链表为空时抛异常）
`peekFirst()`	获取头部元素（链表为空时返回`null`）
`removeFirst()`	删除并返回头部元素（链表为空时抛异常）
`pollFirst()`	删除并返回头部元素（链表为空时返回`null`）

尾部操作：

方法	描述
`addLast(E e)`	在尾部插入元素（等价于`add(e)`）
`getLast()`	获取尾部元素（链表为空时抛异常）
`peekLast()`	获取尾部元素（链表为空时返回`null`）
`removeLast()`	删除并返回尾部元素（链表为空时抛异常）
`pollLast()`	删除并返回尾部元素（链表为空时返回`null`）

import java.util.LinkedList;
public class Main2 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.addFirst("ddd");//将“ddd”插入头部
        System.out.println(list.getFirst());//返回”ddd“
        System.out.println(list.removeFirst());//删除ddd并返回“ddd”
    }
}

4.LinkedList 的遍历方式

迭代器（Iterator）

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String element = it.next();
    // 处理元素
}

增强 for 循环

for (String element : list) {
    // 处理元素
}

列表迭代器（ListIterator）

ListIterator<String> lit = list.listIterator();
while (lit.hasNext()) {
    String element = lit.next();
    if (element.equals("B")) {
        lit.set("C"); // 修改元素
    }
}

5.总结

优点	缺点
1. 高效的增删操作（尤其是头尾）	1. 随机访问效率低（O (n)）
2. 支持双端队列操作	2. 内存占用较高
3. 灵活的链表结构

三.set系列集合

1.Set 集合的基本概念

定义：Set是 Java 集合框架中的无序（存储顺序与取出顺序无关）、不允许重复元素的集合接口，主要实现类包括HashSet、TreeSet和LinkedHashSet。
核心特性：
1. 唯一性：通过equals()方法判断元素是否重复，若重复则仅保留一个。
2. 无序性：不同实现类对 “无序” 的定义不同（如HashSet基于哈希表，无固定顺序；TreeSet按自然顺序或定制顺序排序）。
3. 不支持索引：无法通过索引访问元素，只能通过迭代器或增强 for 循环遍历。

2.Set 接口的常用方法

方法	描述
`boolean add(E e)`	添加元素，若元素已存在则返回`false`（不执行添加）
`boolean remove(Object o)`	删除指定元素，存在则返回`true`
`boolean contains(Object o)`	判断是否包含指定元素（通过`equals()`比较）
`int size()`	返回集合中元素的个数
`boolean isEmpty()`	判断集合是否为空
`Iterator<E> iterator()`	返回迭代器，用于遍历集合元素
`void clear()`	清空集合所有元素

import java.util.HashSet;
public class Main2 {
    public static void main(String[] args) {
        HashSet<String> set=new HashSet<>();
        set.add("aaa");
        set.add("bbb");
        set.add("ccc");//添加“aaa”,"bbb","ccc"
        set.remove("aaa");//删除“aaa”
        System.out.println(set.contains("bbb"));//存在“bbb”,返回true
        System.out.println(set.size());//返回2
        System.out.println(set.isEmpty());//集合中有元素，返回“false”
    }
}

3.set集合的遍历

3.1增强 for 循环

Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c"));
for (String element : set) {
    System.out.print(element + " "); // 输出顺序不确定（HashSet无序）
}

3.2迭代器遍历

Iterator<String> it = set.iterator();
while (it.hasNext()) {
    String element = it.next();
    // 处理元素
}

四.HashSet集合

1. 数据结构与原理

底层实现：基于哈希表（本质是HashMap，元素存储为键，值统一为PRESENT常量）。
唯一性保证：
1. 先通过元素的hashCode()计算哈希值，确定存储位置（桶）。
2. 若桶中无元素，直接存入；若有元素，通过equals()比较是否重复，重复则不存储。
无序性：元素的存储顺序由哈希值决定，与插入顺序无关。
适用场景：需要快速判断元素是否存在（contains()时间复杂度接近O(1)），无序且允许null的场景。

2.构造方法

HashSet<E> set = new HashSet<>(); // 空集合，默认初始容量16，负载因子0.75
HashSet<E> setWithCapacity = new HashSet<>(initialCapacity); // 指定初始容量
HashSet<E> setFromCollection = new HashSet<>(collection); // 基于现有集合创建

五.TreeSet集合

1. 数据结构与原理

底层实现：基于红黑树，元素按自然顺序或定制 Comparator 顺序排序。
唯一性保证：通过compareTo()（自然顺序）或Comparator.compare()（定制顺序）判断元素是否相等，若比较结果为 0 则视为重复，不存储。
有序性：元素始终按排序规则排列，迭代时按顺序输出。
适用场景：需要元素自动排序、范围查询（如headSet、tailSet）的场景。

2. 构造方法

TreeSet<E> set = new TreeSet<>(); // 自然排序（元素需实现Comparable接口）
TreeSet<E> setWithComparator = new TreeSet<>(Comparator comparator); // 定制排序
TreeSet<E> setFromCollection = new TreeSet<>(collection); // 基于现有集合创建（自动排序）

3.TreeSet集合的特殊遍历

TreeSet<Integer> treeSet = new TreeSet<>(Arrays.asList(3, 1, 2));
// 正序遍历（自然顺序）
for (Integer num : treeSet) {
    System.out.print(num + " "); // 输出：1 2 3
}
// 逆序遍历
Iterator<Integer> descendingIt = treeSet.descendingIterator();
while (descendingIt.hasNext()) {
    System.out.print(descendingIt.next() + " "); // 输出：3 2 1
}