Java中Map与List作用、定义、调用实战详解
作者：悦悦欧呐呐呐呐
在Java编程语言中,数据结构之间转换是常见的需求,尤其是集合框架中的List、Set和Map以及数组,这篇文章主要介绍了Java中Map与List作用、定义、调用的相关资料,需要的朋友可以参考下
Map 与 List 详解：作用、定义、调用（Java 实战）
Map 和 List 是 Java 集合框架（java.util）中最常用的两个容器，核心区别是 存储结构和核心用途：
- List 是「有序可重复的线性集合」，适合按顺序存储、访问数据；
- Map 是「无序唯一的键值对集合」，适合通过唯一 Key 快速查找 Value。
下面从 作用、定义、调用（常用 API）、实战场景 四个维度逐一拆解，结合 User 类示例，让用法更直观。
1.List：有序可重复的 “线性容器”
2.1. 核心作用
- 存储 有序、可重复 的数据（类似 “排队的队伍”：按插入顺序排列，允许重复元素）；
- 核心场景：需要按顺序访问 / 操作数据（如展示所有用户列表、存储批量数据）；
- 查找方式：通过「索引」（0 开始）访问，查找非首尾元素需遍历（时间复杂度 O (n)）。
2.2. 定义（创建）
List 是接口，不能直接实例化，需用实现类（常用 ArrayList、LinkedList）：
| 实现类 | 特点 | 适用场景 |
|---|---|---|
| ArrayList | 基于数组实现，查询快、增删（中间）慢 | 多查询、少增删（如展示用户列表） |
| LinkedList | 基于链表实现，查询慢、增删（中间）快 | 少查询、多增删（如队列、栈） |
定义语法（以 ArrayList 为例）：
import java.util.List;
import java.util.ArrayList;
// 1. 存储基本类型包装类（如 Long、String）
List<Long> idList = new ArrayList<>(); // 存储用户 ID 列表
// 2. 存储自定义对象（如 User）
List<User> userList = new ArrayList<>(); // 存储用户对象列表
// 3. 初始化时添加元素（Java 9+）
List<String> nameList = List.of("张三", "李四"); // 不可修改的 List
1.3. 核心调用（常用 API）
以 List<User> 为例，结合用户场景实战：
public class ListDemo {
public static void main(String[] args) {
// 1. 创建并初始化 List
List<User> userList = new ArrayList<>();
User zhangsan = new User(1L, "张三", 25);
User lisi = new User(2L, "李四", 30);
User wangwu = new User(3L, "王五", 28);
// 2. 添加元素（add）
userList.add(zhangsan); // 末尾添加：[张三]
userList.add(1, lisi); // 插入到索引 1：[张三, 李四]
userList.add(wangwu); // 末尾添加：[张三, 李四, 王五]
// 3. 获取元素（get）：通过索引访问（0 开始）
User firstUser = userList.get(0); // 获取第一个元素：张三
System.out.println(firstUser.getName()); // 输出：张三
// 4. 修改元素（set）：替换指定索引的元素
userList.set(2, new User(3L, "王五（修改后）", 29)); // 索引 2 替换为新对象
// 5. 删除元素（remove）：按索引或对象删除
userList.remove(1); // 删除索引 1 的元素（李四）：[张三, 王五（修改后）]
userList.remove(zhangsan); // 删除指定对象（张三）：[王五（修改后）]
// 6. 遍历 List（3 种常用方式）
// 方式 1：普通 for 循环（适合需要索引的场景）
for (int i = 0; i < userList.size(); i++) {
User user = userList.get(i);
System.out.println("索引 " + i + "：" + user.getName());
}
// 方式 2：增强 for 循环（简洁，无需索引）
for (User user : userList) {
System.out.println("用户：" + user);
}
// 方式 3：Java 8+ 流式遍历（函数式编程，简洁灵活）
userList.forEach(user -> System.out.println("流式遍历：" + user.getName()));
// 7. 其他常用操作
int size = userList.size(); // 元素个数：1
boolean contains = userList.contains(wangwu); // 是否包含王五对象？false（已修改）
userList.clear(); // 清空所有元素：size=0
boolean isEmpty = userList.isEmpty(); // 是否为空？true
}
}
2.Map：无序唯一的 “键值对容器”
2.1. 核心作用
- 存储 Key-Value 键值对（类似 “字典”：拼音→汉字、身份证号→用户信息）；
- 核心场景：需要通过唯一 Key 快速查找 Value（如缓存用户、配置映射、统计计数）；
- 查找方式：通过「Key」查找，时间复杂度接近 O (1)（HashMap），比 List 快得多；
- 约束：Key 必须唯一（重复 put 会覆盖旧值），Value 可重复。
2.2. 定义（创建）
Map 是接口，需用实现类（常用 HashMap、LinkedHashMap、TreeMap）：
| 实现类 | 特点 | 适用场景 |
|---|---|---|
| HashMap | 基于哈希表，无序、查询快、线程不安全 | 绝大多数场景（如缓存用户） |
| LinkedHashMap | 继承 HashMap，按插入顺序 / 访问顺序排序 | 需要有序的键值对（如历史记录） |
| TreeMap | 基于红黑树，按 Key 自然排序 | 需要排序的键值对（如按 ID 排序） |
定义语法（以 HashMap 为例）：
import java.util.Map; import java.util.HashMap; // 1. Key=基本类型包装类，Value=基本类型/包装类（如统计用户年龄分布） Map<Integer, Integer> ageCountMap = new HashMap<>(); // Key=年龄，Value=人数 // 2. Key=用户 ID（Long），Value=User 对象（缓存用户） Map<Long, User> userMap = new HashMap<>(); // 3. Key=String，Value=List（如按性别分组用户） Map<String, List<User>> genderGroupMap = new HashMap<>();
2.3. 核心调用（常用 API）
以 Map<Long, User> 为例，结合用户缓存场景实战：
public class MapDemo {
public static void main(String[] args) {
// 1. 创建并初始化 Map
Map<Long, User> userMap = new HashMap<>();
User zhangsan = new User(1L, "张三", 25);
User lisi = new User(2L, "李四", 30);
// 2. 添加/修改元素（put）：Key 不存在则添加，存在则覆盖
userMap.put(zhangsan.getId(), zhangsan); // Key=1L → Value=张三
userMap.put(lisi.getId(), lisi); // Key=2L → Value=李四
userMap.put(1L, new User(1L, "张三（更新）", 26)); // 覆盖 Key=1L 的值
// 3. 获取元素（get）：通过 Key 查找，找不到返回 null
User findUser = userMap.get(2L);
System.out.println(findUser.getName()); // 输出：李四
// 4. 安全获取（getOrDefault）：Key 不存在时返回默认值
User defaultUser = userMap.getOrDefault(3L, new User(0L, "默认用户", 0));
System.out.println(defaultUser.getName()); // 输出：默认用户
// 5. 删除元素（remove）：通过 Key 删除
userMap.remove(2L); // 删除 Key=2L 的键值对：仅剩 Key=1L
// 6. 遍历 Map（3 种常用方式）
// 方式 1：遍历 Key 集合（keySet）→ 适合只需要 Key 或 Value
for (Long userId : userMap.keySet()) {
User user = userMap.get(userId);
System.out.println("ID：" + userId + "，姓名：" + user.getName());
}
// 方式 2：遍历键值对（entrySet）→ 推荐（效率高，同时获 Key/Value）
for (Map.Entry<Long, User> entry : userMap.entrySet()) {
Long id = entry.getKey();
User user = entry.getValue();
System.out.println("ID：" + id + "，年龄：" + user.getAge());
}
// 方式 3：Java 8+ 流式遍历（forEach）→ 简洁
userMap.forEach((id, user) ->
System.out.println("流式遍历：ID=" + id + "，用户=" + user)
);
// 7. 其他常用操作
int size = userMap.size(); // 键值对个数：1
boolean hasKey = userMap.containsKey(1L); // 是否存在 Key=1L？true
boolean hasValue = userMap.containsValue(zhangsan); // 是否存在张三对象？false（已更新）
userMap.clear(); // 清空所有键值对
boolean isEmpty = userMap.isEmpty(); // 是否为空？true
}
}
3.List 与 Map 核心区别对比
| 维度 | List（如 ArrayList） | Map（如 HashMap） |
|---|---|---|
| 存储结构 | 线性结构（数组 / 链表），按索引存储 | 哈希表 / 红黑树，按 Key-Value 存储 |
| 核心特点 | 有序、可重复 | 无序（HashMap）、Key 唯一、Value 可重复 |
| 查找方式 | 按索引（O (n) 非首尾） | 按 Key（O (1) HashMap） |
| 核心用途 | 顺序存储、批量访问（如展示列表） | 快速查找、映射缓存（如按 ID 查用户） |
| 元素操作 | 基于索引（add (int index, E)、get (int)） | 基于 Key（put (K, V)、get (K)） |
4.实战：List 与 Map 搭配使用
addUser、getUserById、listAllUsers 方法，用 Map 做缓存（快速查 ID）、List 做批量返回（展示所有用户），是典型的搭配场景：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class UserService {
// Map：缓存用户（Key=用户 ID，快速查询）
private Map<Long, User> userCache = new HashMap<>();
// 1. 添加用户：存入 Map（自动去重，ID 重复则覆盖）
public boolean addUser(User user) {
if (user == null || user.getId() == null) {
return false;
}
userCache.put(user.getId(), user);
return true;
}
// 2. 按 ID 查询：Map.get(Key) 快速获取（O(1)）
public User getUserById(Long id) {
return userCache.get(id);
}
// 3. 查询所有用户：Map.values() 转成 List 返回（顺序无关，如需顺序用 LinkedHashMap）
public List<User> listAllUsers() {
return new ArrayList<>(userCache.values());
}
// 拓展：按性别分组用户（Map<String, List<User>>）
public Map<String, List<User>> groupByGender() {
Map<String, List<User>> genderMap = new HashMap<>();
for (User user : userCache.values()) {
String gender = user.getGender(); // 假设 User 有 gender 字段
// 不存在该性别分组，则创建新 List
genderMap.computeIfAbsent(gender, k -> new ArrayList<>());
// 加入该性别分组
genderMap.get(gender).add(user);
}
return genderMap;
}
// 测试
public static void main(String[] args) {
UserService service = new UserService();
service.addUser(new User(1L, "张三", 25, "男"));
service.addUser(new User(2L, "李四", 30, "男"));
service.addUser(new User(3L, "王五", 28, "女"));
System.out.println(service.getUserById(1L).getName()); // 张三
System.out.println(service.listAllUsers().size()); // 3
// 按性别分组
Map<String, List<User>> genderMap = service.groupByGender();
System.out.println("男性用户：" + genderMap.get("男").size()); // 2
System.out.println("女性用户：" + genderMap.get("女").size()); // 1
}
}
// 补充完整的 User 类
class User {
private Long id;
private String name;
private int age;
private String gender;
// 构造器、getter、toString
public User(Long id, String name, int age, String gender) {
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
}
// getter 方法
public Long getId() { return id; }
public String getName() { return name; }
public int getAge() { return age; }
public String getGender() { return gender; }
@Override
public String toString() {
return "User{id=" + id + ", name='" + name + "'}";
}
}
总结
到此这篇关于Java中Map与List作用、定义、调用的文章就介绍到这了,更多相关Java Map与List详解内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！