当前位置： 首页 > article >正文

java基础面试题六集合框架

article 2024/11/14 18:25:53

目录

1. List，Set，Map是否继承自collection接口？

2. 说说List,Set,Map三者的区别

3. 写出list、map、set接口的实现类，并说出其特点

4. 常见集合类的区别和适用场景

5. 集合的父类是谁？哪些安全的？

6. 遍历集合的方式有哪些？

7. List下面有哪些实现

8. ArrayList与LinkedList区别？

9. ArrayList与Vector区别呢？为什么要用ArrayList取代Vector呢？

10. Java.util.ArrayList常用的方法有哪些？

11. Arraylist 是有序还是无序？为什么？

12. Set集合有哪些实现类，分别有什么特点？

13. List集合和Set集合的区别？

14. Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

15. TreeSet两种排序方式在使用的时候怎么起作用？

16. TreeSet的数据结构

17. 说一下Java的集合Map有哪些Map？

18. final怎么用，修饰Map可以继续添加数据吗？

19. Set和Map的比较

20. HashMap说一下，线程安全吗？

21. HashMap和Hashbable的区别？

22. Hashtable是怎么实现的，为什么线程安全？

23. HashMap和LinkedHashMap的区别

24. HashMap 和 TreeMap 的区别

25. HashMap里面实际装的是什么？

26. HashMap的key存储在哪里？和value存储在一起吗？那么value存储在哪里？说具体点？

27. 自定义类型可以作为Key么？

28. 集合类的工具类是谁？用过工具类哪些方法？

29. Collection 和 Collections的区别？

30. ArrayList 如何实现排序

31. HashMap是否线程安全，怎样解决HashMap的线程不安全

1. List，Set，Map是否继承自collection接口？

Map不是。

2. 说说List,Set,Map三者的区别

1. List

  • 特性：List 是一个有序集合，允许元素重复。
  • 实现类：常见的实现类有 ArrayList、LinkedList 和 Vector。
  • 索引：List 支持通过索引来访问元素，索引从 0 开始。
  • 适用场景：适用于需要维护元素顺序和允许重复元素的场景，比如存储学生成绩列表、任务列表等。

2. Set

  • 特性：Set 是一个无序集合，不允许元素重复。
  • 实现类：常见的实现类有 HashSet、LinkedHashSet（保持插入顺序）和 TreeSet（按自然排序或自定义排序）。
  • 适用场景：适用于需要确保元素唯一性、不允许重复元素的场景，比如存储用户ID、电话号码等。

3. Map

  • 特性：Map 是一个键值对（key-value）集合，每个键唯一，值可以重复。
  • 实现类：常见的实现类有 HashMap、LinkedHashMap（按插入顺序）和 TreeMap（按键排序）。
  • 适用场景：适用于根据键快速查找值的场景，比如存储用户ID和对应的用户信息、单词和解释等。

3. 写出list、map、set接口的实现类，并说出其特点

1. List 接口的实现类

  • ArrayList：查询快，增删慢，不线程安全。
  • LinkedList：增删快，查询慢，不线程安全。
  • Vector：查询快，增删慢，线程安全。
  • Stack：后进先出结构，线程安全。

2. Set 接口的实现类

  • HashSet：无序，允许快速操作，不允许重复元素。
  • LinkedHashSet：有序（按插入顺序），不允许重复元素。
  • TreeSet：按顺序存储，支持排序，不允许重复元素。
  • EnumSet：专用于枚举类型的集合，高效。

3. Map 接口的实现类

  • HashMap：无序，允许 null 键和值，线程不安全。
  • LinkedHashMap：按插入顺序存储，允许 null 键和值。
  • TreeMap：按键排序存储，不允许 null 键。
  • Hashtable：无序，线程安全，不允许 null 键和值。
  • EnumMap：适合枚举类型键的高效存储。
  • ConcurrentHashMap：线程安全，高效并发访问。

4. 常见集合类的区别和适用场景

1. List 集合类 

ArrayList基于数组实现，有序、随机访问效率高，增删元素性能一般，线程不安全。适用于频繁读取数据、元素增删较少的场景，比如商品列表、学生名单等。
LinkedList基于双向链表实现，有序，增删效率高，但随机访问性能差，线程不安全。适用于频繁增删元素的场景，如队列、栈、任务调度等。
Vector类似 ArrayList，但线程安全，方法加锁，性能稍差。适用于多线程环境下的顺序列表存储，线程安全要求不高时推荐使用 ArrayList。
Stack继承自 Vector，实现了后进先出（LIFO）结构。适用于后进先出（LIFO）需求的场景，如撤销操作、浏览历史记录等。

2. Set 集合类

HashSet基于哈希表实现，无序，不允许重复元素，查询和插入效率高，线程不安全。适用于需要快速查找和去重的场景，如用户名、ID、电话簿等。
LinkedHashSet继承自 HashSet，按插入顺序存储，不允许重复元素。适用于需要顺序且无重复的集合场景，比如历史记录、用户输入记录等。
TreeSet基于红黑树实现，按元素自然顺序或自定义顺序存储，不允许重复元素，查询效率高。适用于需要排序和去重的场景，比如学生成绩排名、字母顺序列表等。
EnumSet专门用于存储枚举类型，效率高。适用于枚举类型的集合，且枚举类型固定的场景，如表示状态、方向等固定集合。

3. Map 集合类

HashMap基于哈希表实现，无序存储，允许 null 键和 null 值，线程不安全，查询和插入效率高。适用于快速查找键值对的场景，如缓存、配置参数、数据映射等。
LinkedHashMap继承自 HashMap，按插入顺序存储，允许 null 键和 null 值。适用于既要保持插入顺序又需要键值对映射的场景，如按访问顺序排序的数据缓存。
TreeMap基于红黑树实现，按键排序，不允许 null 键，查询效率高。适用于需要按键排序的场景，比如字典、电话号码簿等。
Hashtable类似 HashMap，线程安全，不允许 null 键和 null 值，效率较低。适用于多线程环境下的键值对存储，要求严格的线程安全，如早期的 Java 应用。
EnumMap专门用于枚举类型的键，效率高，顺序为枚举常量的自然顺序。适用于键为枚举类型的场景，且不允许 null 键，如状态机、固定类别的数据映射。
ConcurrentHashMap线程安全，分段锁设计并发性能高，适合高并发场景，不允许 null 键和 null 值。适用于多线程环境下高效的键值对存储，比如在线用户状态、并发访问的数据缓存等。

4. Queue 接口类 

LinkedList可作为 Queue 使用，支持队列的 FIFO 操作，增删效率高。适用于普通队列操作，如任务队列、消息队列等。
PriorityQueue基于堆实现的优先级队列，按元素的自然顺序或自定义排序器排序。适用于优先级调度场景，如事件调度、任务优先级处理等。
ArrayDeque基于数组实现的双端队列，支持双向操作（两端插入和删除），性能高。适用于双端队列场景，如双向数据流、栈和队列的混合需求。

5. 集合的父类是谁？哪些安全的？

在 Java 中，集合类的父接口是 Collection 和 Map。

集合接口的继承关系

  1. Collection
    Collection 是所有单一数据集合（如 List 和 Set）的父接口。Collection 本身不能直接用于创建集合对象，但它定义了一些集合的基本操作（如添加、删除、遍历等）。

    • 主要子接口：
      • List：有序、允许重复元素。
      • Set：无序、不允许重复元素。
      • Queue：有序，通常按照 FIFO（先进先出）规则进行元素操作。

  2. Map
    Map 是键值对集合的父接口，表示一种将唯一键映射到特定值的数据结构。Map 本身也不能直接用于创建对象，但它定义了键值对的基本操作。

    • 主要子接口和实现类：
      • HashMap：无序存储，允许 null 键和 null 值，线程不安全。
      • LinkedHashMap：按插入顺序存储，允许 null 键和 null 值。
      • TreeMap：按键排序，不允许 null 键。
      • Hashtable：线程安全，不允许 null 键和 null 值。
      • ConcurrentHashMap：线程安全，高效并发。

线程安全的集合类

在 Java 中，并非所有集合类都是线程安全的，只有部分实现类提供了线程安全的操作。

  • 线程安全的集合类：

    1. Vector 和 Stack：这两者都是线程安全的 List 实现，Vector 的所有方法都加了同步锁，而 Stack 继承自 Vector。
    2. Hashtable：线程安全的 Map 实现，不允许 null 键和 null 值，所有方法都加了同步锁。
    3. ConcurrentHashMap：线程安全的高效 Map 实现，分段锁设计保证了更好的并发性，适合高并发场景。
    4. CopyOnWriteArrayList 和 CopyOnWriteArraySet：线程安全的 List 和 Set 实现，适合多读少写的场景，因为每次写操作都会复制整个集合。

  • 非线程安全的集合类：

    • ArrayList、LinkedList、HashSet、HashMap 等标准集合类都是非线程安全的。如果在多线程环境下使用这些集合，需手动同步（如通过 Collections.synchronizedList 包装）或使用并发集合。

6. 遍历集合的方式有哪些？

1. 使用 for-each 循环（增强型 for 循环）

适用于所有实现了 Iterable 接口的集合，如 List、Set、Queue 等。使用简单、代码简洁。

List<String> list = Arrays.asList("A", "B", "C");
for (String item : list) {
    System.out.println(item);
}

2. 使用迭代器（Iterator）

Iterator 是一种通用遍历方法，适用于所有集合，包括 List、Set 和 Map。Iterator 支持在遍历过程中删除元素，确保在多线程环境下的安全性。

List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String item = iterator.next();
    System.out.println(item);
}

对于 List 类型，还可以使用 ListIterator，它支持双向遍历和修改元素：

List<String> list = Arrays.asList("A", "B", "C");
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String item = listIterator.next();
    System.out.println(item);
}

7. List下面有哪些实现

实现类特点适用场景
ArrayList基于数组实现，查询快，增删慢，线程不安全。适合频繁查询和顺序存储的场景。
LinkedList基于双向链表，增删快，查询慢，线程不安全。适合频繁增删操作的场景。
Vector基于数组实现，线程安全，性能较低。适合多线程环境的顺序列表，但一般不推荐使用。
Stack继承自 Vector，实现 LIFO 的栈结构。适合后进先出的场景，如回退功能。
CopyOnWriteArrayList基于写时复制实现，线程安全，适合读多写少。适合多线程环境下读多写少的场景。

8. ArrayList与LinkedList区别？

底层实现动态数组双向链表
随机访问效率高（O(1)）低（O(n)）
插入/删除效率末尾高效，中间位置低效首尾高效，中间位置高效（调整引用指针）
内存占用较小，存储元素本身较大，每个元素需额外存储前后引用指针
线程安全性线程不安全线程不安全
适用场景频繁读取、少量增删频繁插入、删除（如队列、栈实现）

9. ArrayList与Vector区别呢？为什么要用ArrayList取代Vector呢？

1. 线程安全性

  • ArrayList：非线程安全，没有同步机制，因此在多线程环境下需要手动同步。

  • Vector：线程安全，内部方法使用 synchronized 进行同步。每次访问或修改数据时都会加锁，保证线程安全性。

    为什么使用 ArrayList 替代 Vector？
    在现代 Java 开发中，通常采用外部同步或使用 CopyOnWriteArrayList 或 Collections.synchronizedList() 来确保线程安全，而不需要依赖 Vector 的同步机制。Vector 的同步是强制的，会影响性能，因此在不需要线程安全的场景下，ArrayList 是更好的选择。

2. 性能

  • ArrayList：因为没有同步，性能比 Vector 高，适合单线程环境或手动控制同步的多线程环境。
  • Vector：由于同步机制的存在，性能比 ArrayList 低，尤其是在频繁操作的情况下，过多的同步操作会导致性能损耗。

3. 扩容机制

  • ArrayList：默认情况下，容量不足时会扩容为原来的 1.5 倍（即 50%）。

  • Vector：默认情况下，容量不足时会扩容为原来的 2 倍。虽然这种扩容机制减少了扩容次数，但会增加内存消耗。

    为什么使用 ArrayList 替代 Vector？
    ArrayList 的扩容机制相比 Vector 更加节约内存，并减少不必要的扩容操作，更加灵活。

10. Java.util.ArrayList常用的方法有哪些？

1. 添加元素

  • add(E e): 将元素 e 添加到 ArrayList 的末尾。
  • add(int index, E element): 在指定的索引位置插入元素 element。

2. 获取元素

  • get(int index): 获取指定索引位置的元素。

3. 修改元素

  • set(int index, E element): 用新的元素 element 替换指定索引位置的元素。

4. 删除元素

  • remove(int index): 移除指定索引位置的元素。
  • remove(Object o): 移除首次出现的指定元素 o。
  • clear(): 清空 ArrayList 中的所有元素。

5. 查询元素

  • contains(Object o): 检查 ArrayList 中是否包含指定元素 o。
  • indexOf(Object o): 返回指定元素 o 首次出现的索引位置，如果不存在则返回 -1。
  • lastIndexOf(Object o): 返回指定元素 o 最后一次出现的索引位置。

6. 获取大小

  • size(): 返回 ArrayList 中的元素个数。

7. 判断是否为空

  • isEmpty(): 检查 ArrayList 是否为空。

11. Arraylist 是有序还是无序？为什么？

ArrayList 是有序的，因为它会按照元素插入的顺序来存储和访问数据。

原因

  1. 顺序存储：ArrayList 基于动态数组实现，每个元素都有一个固定的索引位置。插入时，元素会按顺序依次存储。

  2. 索引访问：ArrayList 提供按索引访问元素的方法（如 get(int index)），这意味着我们可以通过索引确定每个元素的顺序。

  3. 插入顺序：在不排序的情况下，ArrayList 中的元素会保持插入时的顺序，不会因为插入或删除而打乱已有元素的顺序。

因此，ArrayList 是有序的集合类，其元素按插入顺序排列，适合需要顺序访问或按索引快速访问的场景。

12. Set集合有哪些实现类，分别有什么特点？

1. HashSet

  • 特点：基于哈希表实现的集合，不保证元素的顺序。
  • 存储顺序：无序（插入顺序不被保证），但可以实现快速存取。
  • 速度：插入、删除、查找的时间复杂度为 O(1)，性能通常比其他 Set 实现更高。
  • 注意事项：由于使用哈希算法，HashSet 中存储的元素需要正确实现 hashCode() 和 equals() 方法。

2. LinkedHashSet

  • 特点：HashSet 的子类，基于链表和哈希表的组合实现，保留了元素的插入顺序。
  • 存储顺序：有序（按元素的插入顺序存储）。
  • 速度：在保证插入顺序的前提下，插入、删除、查找的时间复杂度仍然为 O(1)，但略慢于 HashSet。
  • 适用场景：适合需要按插入顺序遍历元素的场景。

3. TreeSet

  • 特点：基于红黑树（自平衡的二叉查找树）实现，元素会按自然顺序或自定义比较器排序。
  • 存储顺序：有序（按元素的自然顺序或自定义排序规则存储）。
  • 速度：插入、删除、查找的时间复杂度为 O(log n)，由于排序，性能一般低于 HashSet 和 LinkedHashSet。
  • 适用场景：适合需要排序的场景，或者需要按顺序遍历元素的情况。

13. List集合和Set集合的区别？

1. 是否允许重复元素

  • List：允许存储重复的元素。例如，一个 List 中可以有多个相同的元素。
  • Set：不允许存储重复的元素，每个元素在 Set 中都是唯一的。

2. 元素的存储顺序

  • List：有序集合，按照元素的插入顺序进行存储和访问。可以通过索引访问元素。
  • Set：一般是无序的（如 HashSet），但有的实现类（如 LinkedHashSet）会按插入顺序存储，TreeSet 则按自然顺序或自定义比较器排序。

3. 索引支持

  • List：支持按索引访问元素，提供了 get(int index)、indexOf(Object o) 等方法，可以直接访问或查找特定索引位置的元素。
  • Set：不支持索引访问，没有按位置访问的功能。Set 中的元素只能通过迭代器或增强型 for 循环来遍历。

4. 常见实现类

  • List：
    • ArrayList：基于动态数组实现，访问速度快，增删元素效率略低。
    • LinkedList：基于双向链表实现，增删元素效率较高，但随机访问速度较慢。
    • Vector：线程安全的 List 实现，已较少使用。
  • Set：
    • HashSet：基于哈希表实现，不保证顺序，查找速度快。
    • LinkedHashSet：基于哈希表和链表，按插入顺序存储。
    • TreeSet：基于红黑树实现，按自然顺序或自定义顺序存储，支持排序。

14. Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

  • Set 使用 equals() 和 hashCode() 方法来区分重复元素。
  • == 比较的是内存地址，而 equals() 比较的是内容。

15. TreeSet两种排序方式在使用的时候怎么起作用？

  • 自然排序：依赖 Comparable 接口中的 compareTo() 方法，适用于需要默认排序的情况。
  • 定制排序：依赖 Comparator 接口，可以在创建 TreeSet 时定义自定义排序规则，用于特定排序需求。

16. TreeSet的数据结构

TreeSet 的底层数据结构是红黑树（Red-Black Tree），它是一种自平衡的二叉搜索树。由于 TreeSet 使用红黑树实现，因此它可以保证集合中元素的有序性和高效的插入、删除、查找操作。

17. 说一下Java的集合Map有哪些Map？

1. HashMap

  • 特点：基于哈希表实现，存储无序。键和值都允许为 null（键只能有一个 null）。
  • 线程安全性：非线程安全，如果需要线程安全，可以使用 Collections.synchronizedMap(new HashMap<>())。
  • 时间复杂度：平均情况下，插入、删除、查找的时间复杂度为 O(1)。
  • 适用场景：适用于不要求顺序、需要快速查找的场景。

2. LinkedHashMap

  • 特点：HashMap 的子类，保留了键值对的插入顺序（也可以按访问顺序）。
  • 线程安全性：非线程安全。
  • 时间复杂度：与 HashMap 类似，平均时间复杂度为 O(1)。
  • 适用场景：适用于需要维护元素插入顺序或按访问顺序迭代的场景。

3. TreeMap

  • 特点：基于红黑树实现，键值对按键的自然顺序或自定义比较器的顺序排序。
  • 线程安全性：非线程安全。
  • 时间复杂度：查找、插入、删除操作的时间复杂度为 O(log n)。
  • 适用场景：适用于需要按顺序遍历键值对的场景。

4. Hashtable

  • 特点：基于哈希表实现，早期的 Map 实现类，不允许键或值为 null。
  • 线程安全性：线程安全，通过同步方法实现线程安全。
  • 时间复杂度：查找、插入、删除的时间复杂度为 O(1)。
  • 适用场景：适用于多线程环境下不允许键或值为 null 的情况（不过由于性能问题，现已较少使用）。

18. final怎么用，修饰Map可以继续添加数据吗？

  • final 修饰 Map 后，Map 的引用地址不能改变，即不能重新指向其他 Map 对象。
  • final 并不影响 Map 的内容，因此可以在 Map 中继续添加、删除或修改元素。

19. Set和Map的比较

HashSet底层就是HashMap

LinkedHashSet底层就是LinkedHashMap

TreeSet底层就是TreeMap

20. HashMap说一下，线程安全吗？

为什么 HashMap 不是线程安全的？

  1. 无同步机制：HashMap 的方法没有进行同步（synchronized）处理，因此多个线程可以同时操作 HashMap，这可能导致竞态条件（Race Condition），如覆盖或丢失数据。

  2. 扩容时的并发问题：HashMap 在需要扩容时，会重新分配内部的哈希桶数组并将数据重新分配到新的桶中。如果多个线程同时触发了扩容，可能会出现环形链表、数据丢失等问题，导致死循环或性能问题。

线程安全的替代方案

  1. ConcurrentHashMap：ConcurrentHashMap 是 HashMap 的线程安全替代品。它采用了分段锁（Segmented Lock）机制，在高并发下可以保证线程安全，同时性能也优于使用同步锁的 Hashtable。

  2. Collections.synchronizedMap()：可以使用 Collections.synchronizedMap() 方法来包装 HashMap，得到一个线程安全的 Map。这种方式会对 HashMap 的所有访问方法进行同步处理，但性能较差，因为所有操作都在同一个锁上进行串行化。

21. HashMap和Hashbable的区别？

线程安全性不安全，需手动同步线程安全，自动同步
是否允许 null 键/值允许 null 键和 null 值不允许 null 键和值
性能更高效（无同步机制）性能较差（由于同步机制）
迭代器fail-fast 迭代器（检测并发修改）传统的迭代器（没有 fail-fast）
继承关系继承自 AbstractMap继承自 Dictionary（已废弃）
使用推荐推荐使用，特别是在现代应用中不推荐使用，已经被淘汰

22. Hashtable是怎么实现的，为什么线程安全？

1. Hashtable 的实现结构

Hashtable 是基于哈希表实现的，这与 HashMap 类似。哈希表使用数组和链表（或其他数据结构）来存储数据，其核心思想是通过哈希函数将键（key）映射到数组中的索引位置，从而实现快速的查找、插入和删除。

  • 哈希表数组：Hashtable 底层使用一个数组来存储键值对。每个数组元素是一个链表或树（如果哈希冲突严重）。每个键值对通过哈希函数计算出键的哈希值，进而映射到数组中的一个索引位置。
  • 链表解决冲突：当两个不同的键经过哈希函数计算后得到相同的索引时，会发生哈希冲突。Hashtable 会使用链表来存储这些哈希冲突的键值对。即，多个键值对会被存储在同一个位置的链表中。

2. Hashtable 的线程安全性

Hashtable 的线程安全性主要来源于它对所有方法的同步（synchronization）。在多线程环境中，多个线程可能同时访问同一个 Hashtable 对象，Hashtable 会使用 synchronized 关键字来确保每次只有一个线程能够访问对象的内部状态，从而防止数据竞争和不一致的状态。

23. HashMap和LinkedHashMap的区别

存储顺序无序按插入顺序或访问顺序
实现结构基于哈希表基于哈希表 + 双向链表
性能较高，操作较快较低，因维护顺序而稍微慢一些
内存开销较小较大，额外维护链表指针
适用场景不关心顺序的场景需要维持顺序（如缓存、按顺序遍历）
null 键/值允许（最多一个 null 键）允许（最多一个 null 键）
构造方法简单构造方法支持按顺序排序的构造方法

24. HashMap 和 TreeMap 的区别

  • HashMap 适合那些不关心顺序、需要快速查找、插入和删除的场景，通常性能更好，尤其是在大数据量的情况下。
  • TreeMap 适合那些需要保证键的有序性，或者需要根据键的顺序进行遍历的场景，尤其适用于有序集合操作，如获取最大/最小键值对、按顺序遍历等。

25. HashMap里面实际装的是什么？

  • HashMap 内部实际存储的是 Entry 对象，每个 Entry 对象存储一个键值对（key-value）。
  • 元素是存储在一个数组中，如果发生哈希冲突，使用链表或红黑树来解决。
  • HashMap 采用哈希算法来确定元素存储的位置，元素的顺序是无序的。

26. HashMap的key存储在哪里？和value存储在一起吗？那么value存储在哪里？说具体点？

  • key 和 value 是存储在 Entry 对象中的。
  • Entry 对象 存储在 HashMap 的 数组 中。数组中的每个元素是一个链表或红黑树的头节点，用于处理哈希冲突。
  • key 和 value 存储在同一个 Entry 对象内，而 next 指针用于处理冲突时的链表连接。

因此，HashMap 的 key 和 value 会通过 Entry 对象一起存储在哈希表的数组中，而哈希表中的每个位置可能有多个 Entry 对象（在发生哈希冲突时）。

27. 自定义类型可以作为Key么？

  • 自定义类型可以作为 HashMap 的 key，但必须确保自定义类正确实现了 hashCode() 和 equals() 方法，这样才能保证哈希值的正确性和键的唯一性。
  • 键对象的 hashCode() 和 equals() 方法应该根据对象的实际属性来实现，确保哈希表的效率和正确性。

28. 集合类的工具类是谁？用过工具类哪些方法？

在 Java 中，集合类的工具类是 java.util.Collections 类，它提供了许多静态方法来操作和处理集合（如 List、Set、Map 等）。这些方法大大简化了集合的操作，增强了集合类的功能。

常用的 Collections 类方法

1. 排序方法

  • sort(List<T> list)： 用于对 List 集合进行升序排序。排序的依据是元素的自然顺序（即元素实现了 Comparable 接口）。

  • sort(List<T> list, Comparator<? super T> c)： 用于按照指定的 Comparator 对 List 进行排序，可以自定义排序规则。

2. 反转方法

  • reverse(List<?> list)： 用于反转 List 中元素的顺序

3. 填充方法

  • fill(List<? super T> list, T obj)： 用指定的元素替换 List 中的所有元素

4. 查找方法

  • max(Collection<? extends T> coll)： 返回集合中最大元素。要求元素实现了 Comparable 接口。

  • min(Collection<? extends T> coll)： 返回集合中最小的元素

29. Collection 和 Collections的区别？

  • Collection 是集合框架的根接口，定义了集合的基本操作方法，所有集合类（如 List、Set 等）都实现了 Collection 接口。
  • Collections 是一个工具类，提供了许多静态方法来操作和处理集合，如排序、查找、反转等。它不用于定义集合类型，而是用于执行常见的集合操作。

30. ArrayList 如何实现排序

1. 使用 Collections.sort() 对 ArrayList 进行排序

Collections.sort() 是 Java 提供的一个静态方法，用于对实现了 Comparable 接口的元素进行排序。它对 List 进行升序排序，并且修改原列表。如果要实现自定义的排序顺序，可以传入一个 Comparator 对象。

31. HashMap是否线程安全，怎样解决HashMap的线程不安全

  • HashMap 本身不是线程安全的，在多线程环境下使用时需要特别小心。
  • 如果需要线程安全的 Map，最推荐使用 ConcurrentHashMap，它可以在多线程环境下高效地进行并发操作。
  • 如果必须使用 HashMap，可以通过 Collections.synchronizedMap() 或显式加锁（如使用 ReentrantLock）来确保线程安全，但这些方法可能会影响性能。

http://www.kler.cn/a/389160.html

相关文章：

  • LeetCode【0031】下一个排列
  • qt QVideoWidget详解
  • 【系统设计】数据库压缩技术详解：从基础到实践（附Redis内存优化实战案例）
  • 简述 synchronized 和 java.util.concurrent.locks.Lock 的异同？
  • 低代码集成多方API的简单实现
  • 超市里的货物架调整（算法解析）|豆包MarsCode AI刷题
  • VisionPro —— CogSobelEdgeTool边缘提取工具
  • 吴恩达深度学习笔记：卷积神经网络（Foundations of Convolutional Neural Networks）4.5-4.6
  • 阿里云centos7.9服务器磁盘挂载，切换服务路径
  • flutter 发版的时候设置版本号
  • Linux -- 进程初印象
  • iOS 18.2 六大新功能外媒實測｜ChatGPT進化版SIRI、自製Genmoji
  • 紫光展锐携手上赞随身Wi-Fi，让5G触手可及
  • 4.1 WINDOWS XP,ReactOS对象与对象目录----1
  • Vue3-06_路由
  • Java 上机实践2（基础数据类型与数组）
  • 【网络安全 | 漏洞挖掘】商品逻辑漏洞之生成商品折扣码
  • 鸿蒙开发：切换至基于rcp的网络请求
  • Linux开发讲课48--- Linux 文件系统概览
  • 封装一个web Worker 处理方法实现多线程
  • [python3] tornado 使用swagger编写接口文档
  • FastHtml llmctx介绍
  • Spring Boot与工程认证：计算机课程管理的新范式
  • 塔吉克斯坦媒体发稿：伊斯梅尔快讯的海外影响力-大舍传媒
  • javascript实现国密sm4算法(支持微信小程序)
  • SVN 提交操作