Java的列表、集合、数组的添加一个元素各自用什么方法详解

目录

• add() 添加元素
• 一、列表（List）
• 二、集合（Set）
• 对比总结
• 三、树形结构（Tree）
• 四、队列（Queue）
• 五、链表（LinkedList）
• 六、向量（Vector）
• 其他数据结构的添加方法
• 双端队列（Deque）
• put()-映射（Map）
• push() -栈（Stack）
• 数组（Array）
• 总结

在Java中，列表（List）、集合（Set）和数组（Array）添加元素的方法有所不同，以下是具体说明及示例：

add() 添加元素

一、列表（List）

常用实现类包括ArrayList和LinkedList，核心方法为add()：

1. 末尾添加

   add(Object o)：

   List<String> list = new ArrayList<>();
   list.add("Java");  // 添加元素到末尾
   

2. 指定位置插入

   add(int index, Object o)：

   list.add(1, "python");  // 在索引1处插入元素，原元素后移
   

3. 批量添加

   addAll(Collection<?> c)或Collections.addAll()：

   List<String> list2 = Arrays.asList("C++", "Go");
   list.addAll(list2);  // 批量添加集合元素
   

二、集合（Set）

常用实现类如HashSet、TreeSet，添加元素需满足唯一性：

1. 基本添加

   add(Object o)：

   Set<String> set = new HashSet<>();
   set.add("Apple");  // 成功返回true，重复元素返回false
   

2. 有序集合的添加

   如TreeSet会自动按自然顺序排序：

   Set<Integer> sortedSet = new TreeSet<>();
   sortedSet.add(3);
   sortedSet.add(1);  // 最终顺序为1, 3
   

对比总结

示例完整代码

数组转列表并添加元素：

int[] arr = {1, 2, 3};
List<Integer> list = new ArrayList<>(Arrays.asList(arr));
list.add(4);
list.add(1, 99);  // 插入到索引1处
System.out.println(list);  // 输出[1, 99, 2, 3, 4]

集合去重示例：

Set<String> cities = new HashSet<>();
cities.add("Beijing");
cities.add("Shanghai");
cities.add("Beijing");  // 重复元素不会被添加
System.out.println(cities);  // 输出[Beijing, Shanghai]

如需动态处理大量元素，推荐优先使用ArrayList（列表）或HashSet（集合）。

三、树形结构（Tree）

Java 标准库未直接提供树结构，但可通过 TreeSet 或 TreeMap 间接实现有序存储：

TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(5);  // 自动按升序排列
treeSet.add(3);  // 内部顺序变为3, 5

四、队列（QuexjBUMJaZuphpe）

队列遵循 先进先出（FIFO） 原则，常用实现类为 LinkedList 和 PriorityQueue。

1. 普通队列

   使用 add() 或 offer() 方法在队尾添加元素：

   Queue<Integer> queue = new LinkedList<>();
   queue.add(10);  // 添加元素，队列满时抛异常
   queue.offer(20); // 添加元素，队列满时返回false
   

2. 优先级队列

   PriorityQueue 根据元素自然顺序或自定义比较器排序：

   Queue<Integer> pq = new PriorityQueue<>();
   pq.add(5);  // 添加元素并自动排序
   pq.add(1);  // 内部顺序变为1, 5
   

五、链表（LinkedList）

LinkedList 同时实现了 List 和 Deque，支持灵活插入：

1. 任意位置插入

   使用 add(int index, E element)：

   LinkedList<String> linkedList = new LinkjsedList<>();
   linkedList.add(0, "First");  // 在索引0处插入
   linkedList.add(1, "Second");
   

六、向量（Vector）

向量是线程安全的动态数组，使用 addElement() 或 add() 添加：

Vector<Integer> 编程vector = new Vector<>();
vector.addElement(100);  // 传统方法
vector.add(200);         // 与ArrayList兼容

其他数据结构的添加方法

Java 中除了列表（List）、集合（Set）和数组（Array）之外，还有其他多种数据结构支持元素的添加操作。以下是其他常见数据结构及其添加元素的示例和方法：

双端队列（Deque）

双端队列支持从两端添加元素，实现类为 ArrayDeque。

1. 头部/尾部添加

   使用 addFirst(编程客栈) 和 addLast()：

   Deque<String> deque = new ArrayDeque<>();
   deque.addFirst("Front");  // 头部添加
   deque.addLast("End");     // 尾部添加
   

put()-映射（Map）

映射存储键值对，常用实现类为 HashMap 和 TreeMap。

1. 添加键值对

   使用 put() 方法：

   Map<String, Integer> map = new HashMap<>();
   map.put("Apple", 10);  // 键不存在时新增
   map.put("Banana", 20);
   

push() -栈（Stack）

栈遵循 后进先出（LIFO） 原则，实现类为 Stack（已过时）或 Deque 模拟。

1. 使用 Deque 模拟栈

   Deque<Integer> stack = new ArrayDeque<>();
   stack.push(1);  // 压栈
   stack.push(2);  // 栈顶元素变为2
   

数组（Array）

数组是固定长度的数据结构，添加元素通常需要创建新数组或使用动态容器：

1. 直接赋值

   通过索引直接赋值，但需确保索引有效且数组已初始化：

   int[] arr = new int[3];
   arr[0] = 1;  // 直接赋值到索引0的位置
   

2. 扩容后添加

   使用Arrays.copyOf()创建新数组并添加元素：

   int[] arr = {1, 2, 3};
   arr = Arrays.copyOf(arr, arr.length + 1);  // 扩容
   arr[arr.length - 1] = 4;  // 添加新元素
   

3. 转换为ArrayList动态添加

   将数组转为ArrayList，利用其add()方法：

   String[] arr = {"a", "b"};
   List<String> list = new ArrayList<>(Arrays.asList(arr));
   list.add("c");  // 添加新元素
   arr = list.toArray(new String[0]);  // 转回数组
   

总结

扩展说明：

• 堆（Heap）：Java 中通过 PriorityQueue 实现堆结构，添加元素会自动调整堆结构。
• 并发集合：如 ConcurrentHashMap 和 CopyOnWriteArrayList，适用于多线程环境，但添加方法类似普通集合。

如果需要更具体的实现细节或线程安全方案，可进一步查看相关类的官方文档或源码实现。

到此这篇关于Java的列表、集合、数组的添加一个元素各自用什么方法的文章就介绍到这了,更多相关Java列表、集合、数组添加元素内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！