深入理解Java集合：从基础到高级应用

1. 数组与集合的区别

1.1 相同点

数组和集合都是用于存储多个数据的容器，但它们的使用场景和特性各有不同。

1.2 不同点

• 长度：数组的长度在创建时就固定了，而集合的长度是动态可变的，可以随时增加或减少元素。
• 数据类型：数组可以存储基本数据类型（如int、char等）和引用数据类型，而集合只能存储引用数据类型。如果需要存储基本数据类型，则必须使用对应的包装类（如Integer、Character等）。

2. 集合类体系结构

Java集合框架的设计是层次化的，主要包括以下几个部分：

• Collection接口：是所有集合类的根接口，定义了一些基本的操作方法。
• List接口：有序集合，允许重复元素，常用的实现类有ArrayList和LinkedList。
• Set接口：无序集合，不允许重复元素，常用的实现类有HashSet和TreeSet。
• Map接口：键值对集合，允许通过键快速查找值，常用的实现类有HashMap和TreeMap。

3. Collection接口

• Collection接口是所有单列集合的基础，所有方法被 List 和 Set 系列集合共享。

• JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现
• 以下是一些常用方法及其说明：

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	移除指定元素
boolean contains(Object o)	判断集合中是否存在指定元素
int size()	获取集合元素个数
boolean isEmpty()	判断集合是否为空
void clear()	清空集合

细节

注意事项

1. 接口特性：

   • Collection是一个接口，无法直接创建其对象。应使用其实现类（如ArrayList）创建对象。

2. 添加元素：

   • List系列（如ArrayList）允许重复元素，add方法始终返回true。
   • Set系列（如HashSet）不允许重复元素，add方法返回true表示添加成功，返回false表示添加失败（元素已存在）。

3. 清空集合：

   • 使用clear()方法可以清空集合中的所有元素。

4. 删除元素：

   • remove(E e)方法只能通过元素对象删除，不能通过索引删除。
   • 方法返回布尔值，删除成功返回true，删除失败（元素不存在）返回false。

5. 判断元素是否包含：

   • contains(Object obj)方法依赖于对象的equals方法来判断元素是否存在。如果集合中存储的是自定义对象，需在该对象的类中重写equals方法。

6. 判断集合是否为空：

   • 使用isEmpty()方法判断集合是否为空，返回true表示集合为空，返回false表示集合中有元素。

7. 获取集合长度：

   • 使用size()方法获取集合中元素的数量。

3.1 Collection接口的实现

Java的集合框架并没有提供Collection接口的直接实现，而是通过更具体的子接口（如Set和List）来实现。开发者在使用时，通常会选择具体的实现类，如ArrayList、HashSet等。这种设计不仅提高了灵活性，还允许开发者在不同场景中选择最优的实现。

3.2 Collection的遍历

遍历集合是操作集合中数据的重要部分，Java提供了多种遍历方式，以满足不同的需求。

3.2.1 迭代器遍历

• 迭代器介绍

  • 迭代器,集合的专用遍历方式
  • Iterator<E> iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

• Iterator中的常用方法

  ​ boolean hasNext(): 判断当前位置是否有元素可以被取出
  ​ E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

• Collection集合的遍历

public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("javaee");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }

• 迭代器中删除的方法

  ​ void remove(): 删除迭代器对象当前指向的元素

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");

        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            if("b".equals(s)){
                //指向谁,那么此时就删除谁.
                it.remove();
            }
        }
        System.out.println(list);
    }

---

迭代器的注意事项

1. 异常处理：

   • 遍历结束后，调用next()方法会抛出NoSuchElementException异常，因为迭代器指向了最后一个元素后的位置。

   

2. 指针状态：

   • 迭代器遍历结束后，指针不会复位。如果需要重新遍历集合，必须获取新的迭代器对象。

3. next方法使用：

   • 在循环中，每次调用next()方法只能使用一次，以避免获取相同的元素。

4. 操作限制：

   • 在使用迭代器遍历集合时，不能通过集合的方法增加或删除元素。可以使用迭代器提供的remove()方法安全地删除当前指向的元素。

3.2.2 增强for循环

• 介绍

  • 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
  • 实现Iterable接口的类才可以使用迭代器和增强for
  • 简化数组和Collection集合的遍历

• 格式

  for(集合/数组中元素的数据类型 变量名 :  集合/数组名) {
  
  		// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
  
  	}
  

• 代码

public static void main(String[] args) {
        ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        //1,数据类型一定是集合或者数组中元素的类型
        //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3,list就是要遍历的集合或者数组
        for(String str : list){
            System.out.println(str);
        }
    }

增强 for 的注意事项

1. 修改增强 for 中的变量，不会改变集合中原本的数据：

   

   

3.2.3 Lambda表达式

在Java 8及以后版本中，Lambda表达式提供了一种更简洁的遍历方式，结合forEach方法，开发者可以轻松实现对集合的遍历。

• 代码

public static void main(String[] args) {
       /* 
        lambda表达式遍历：
                default void forEach(Consumer<? super T> action):
        */

        //1.创建集合并添加元素
        Collection<String> coll = new ArrayList<>();
        coll.add("zhangsan");
        coll.add("lisi");
        coll.add("wangwu");
        //2.利用匿名内部类的形式
        //底层原理：
        //其实也会自己遍历集合，依次得到每一个元素
        //把得到的每一个元素，传递给下面的accept方法
        //s依次表示集合中的每一个数据
       /* coll.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        //lambda表达式
        coll.forEach(s -> System.out.println(s));
    }

以下是对你提供的内容的详细补充和拓展：

---

4. List集合

4.1 List集合的概述和特点【记忆】

• List集合的概述：

  • List集合是一个有序集合，这里的“有序”指的是元素的存取顺序，即插入的顺序与存取的顺序是一致的。
  • 用户可以通过整数索引精确控制元素的插入位置，并可以通过索引访问和搜索列表中的元素。
  • 与Set集合不同，List通常允许重复的元素。

• List集合的特点：

  • 存取有序：元素的顺序与插入顺序相同。
  • 可以重复：允许添加重复的元素。
  • 有索引：通过索引访问和管理元素。

4.2 List集合的特有方法【应用】

• 方法介绍：

方法名	描述
void add(int index, E element)	在指定位置插入指定元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index, E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

• 示例代码：

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

public class MyListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        method1(list); // 添加元素
        method2(list); // 删除元素
        method3(list); // 修改元素
        method4(list); // 获取元素
    }

    private static void method1(List<String> list) {
        // 在指定位置插入元素
        list.add(0, "qqq");
        System.out.println("添加后的列表: " + list);
    }

    private static void method2(List<String> list) {
        // 删除指定索引处的元素
        String removedElement = list.remove(0);
        System.out.println("被删除的元素: " + removedElement);
        System.out.println("删除后的列表: " + list);
    }

    private static void method3(List<String> list) {
        // 修改指定索引处的元素
        String replacedElement = list.set(0, "xxx");
        System.out.println("被替换的元素: " + replacedElement);
        System.out.println("修改后的列表: " + list);
    }

    private static void method4(List<String> list) {
        // 获取指定索引处的元素
        String element = list.get(0);
        System.out.println("获取的元素: " + element);
    }
}

4.3 List集合的五种遍历方式【应用】

1. 迭代器：使用Iterator进行遍历。
2. 列表迭代器：使用ListIterator，可以在遍历时添加或修改元素。
3. 增强for：使用增强for循环简化遍历。
4. Lambda表达式：使用forEach方法结合Lambda表达式遍历。
5. 普通for循环：通过索引访问元素。

• 代码示例：

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

public class ListTraversalDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        // 1. 迭代器遍历
        System.out.println("迭代器遍历：");
        list.forEach(System.out::println);

        // 2. 增强for遍历
        System.out.println("增强for遍历：");
        for (String s : list) {
            System.out.println(s);
        }

        // 3. Lambda表达式遍历
        System.out.println("Lambda表达式遍历：");
        list.forEach(s -> System.out.println(s));

        // 4. 普通for循环
        System.out.println("普通for循环遍历：");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // 5. 列表迭代器
        System.out.println("列表迭代器遍历：");
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            String s = listIterator.next();
            if ("bbb".equals(s)) {
                listIterator.add("qqq"); // 在bbb后添加qqq
            }
        }
        System.out.println("遍历后的列表: " + list);
    }
}

4.4 细节点注意：

• List系列集合中的删除方法：

  • 直接删除元素：使用remove(Object obj)。
  • 通过索引进行删除：使用remove(int index)。

• 删除元素的注意事项

  • 当调用 remove 方法时，如果存在方法重载（即多个方法名相同但参数类型不同），Java会优先选择与传入参数类型一致的方法：

    • remove(int index)：如果传入的是基本数据类型int，会优先调用此方法。
    • remove(Object o)：若传入的是Integer对象（如Integer.valueOf(1)），则会调用此方法。

• 代码示例：

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

public class ListRemovalDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        // 直接删除元素
        list.remove(Integer.valueOf(1)); // 删除元素1
        System.out.println("删除后的列表: " + list);

        // 通过索引进行删除
        list.remove(0); // 删除索引0的元素
        System.out.println("再次删除后的列表: " + list);
    }
}

---

5. 数据结构

5.1 数据结构之栈和队列

• 栈结构

  • 特点：先进后出（LIFO，Last In First Out）
  • 应用场景：
    • 函数调用管理（调用栈）
    • 表达式求值（后缀表达式转换）
    • 浏览器历史记录

• 队列结构

  • 特点：先进先出（FIFO，First In First Out）
  • 应用场景：
    • 任务调度
    • 数据缓冲（如IO缓冲）
    • 广度优先搜索（BFS）

5.2 数据结构之数组和链表

• 数组结构

  • 特点：查询快、增删慢
  • 存储：连续内存空间
  • 优缺点：
    • 优点：快速随机访问（O(1)）
    • 缺点：动态扩展困难（需要复制整个数组），增删操作需要移动元素（O(n)）

• 链表结构

  • 特点：查询慢、增删快
  • 存储：非连续内存，节点包含数据和指向下一个节点的指针
  • 优缺点：
    • 优点：动态大小（可以随意增删节点），插入和删除操作更快（O(1)）
    • 缺点：随机访问速度慢（O(n)），额外的内存开销（存储指针）
      记录

• 队列结构

  • 特点：先进先出（FIFO，First In First Out）
  • 应用场景：
    • 任务调度
    • 数据缓冲（如IO缓冲）
    • 广度优先搜索（BFS）

5.2 数据结构之数组和链表

• 数组结构

  • 特点：查询快、增删慢
  • 存储：连续内存空间
  • 优缺点：
    • 优点：快速随机访问（O(1)）
    • 缺点：动态扩展困难（需要复制整个数组），增删操作需要移动元素（O(n)）

• 链表结构

  • 特点：查询慢、增删快
  • 存储：非连续内存，节点包含数据和指向下一个节点的指针
  • 优缺点：
    • 优点：动态大小（可以随意增删节点），插入和删除操作更快（O(1)）
    • 缺点：随机访问速度慢（O(n)），额外的内存开销（存储指针）