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

业界资讯 2024-11-02 23:45:50 阅读次数: 0

深入理解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)），额外的内存开销（存储指针）

猜你喜欢

转载自blog.csdn.net/PQ781826/article/details/143359473
今日推荐
周排行
Android图片与下拉框
java常用的设计模式之单例模式
zabbix自动化监控之自动注册
杨老师课堂之Excel VBA 程序开发第八讲使用工作表函数
Android 去掉底部虚拟导航栏
Android Studio 3.2 Beta 4 发布，功能改进和修复
Linux-3.5_总线驱动设备
Qt QTableView QStandardItemModel用法
session处理
分享几个实用的方法
每日归档
更多
2025-02-06(0)
2025-02-05(0)
2025-02-04(0)
2025-02-03(0)
2025-02-02(0)
2025-02-01(0)
2025-01-31(0)
2025-01-30(0)
2025-01-29(0)
2025-01-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022