Java中集合知识点总结

最新推荐文章于 2024-09-30 20:09:33 发布

和小本本一起学Java

最新推荐文章于 2024-09-30 20:09:33 发布

阅读量39

点赞数

分类专栏： Java 文章标签： java windows 开发语言集成学习

本文链接：https://blog.csdn.net/qq_46161480/article/details/134112520

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、Java有哪些容器（集合）？

Java 容器分为 Collection 和 Map 两大类，各自都有很多子类。

Collection

|　　├AbstractCollection 对Collection接口的最小化抽象实现

|　　│

|　　├List 有序集合、可重复

|　　│-├AbstractList 有序集合的最小化抽象实现

|　　│-├ArrayList 基于动态数组（可实现动态扩容）实现的有序集合，线程不安全（查询效率高）

|　　│-├LinkedList 基于链表实现的有序集合，线程不安全（新增和删除效率高）

|　　│-└Vector 矢量队列，线程安全

|　　│　└Stack 栈，先进后出

|　　│

|　　├Set 不可重复集合

|　　│├AbstractSet 不重复集合的最小化抽象实现

|　　│├HashSet 基于哈希表实现的不重复集合，无序，线程不安全

|　　│├LinkedHashSet 基于链表和哈希表实现的不重复集合，有序

|　　│└SortedSet 可排序不重复集合

|　　│ └NavigableSet 可导航搜索的不重复集合

|　　│ └TreeSet 基于红黑树实现的可排序不重复集合

|　　│

|　　├Queue 队列

|　　│├AbstractQueue 队列的核心实现

|　　│├BlockingQueue 阻塞队列

|　　│└Deque 可两端操作线性集合

Map 键值映射集合

|　　├AbstractMap 键值映射集合最小化抽象实现

|　 └TreeMap

|　　├Hashtable 基于哈希表实现的键值映射集合，key、value均不可为null，线程安全的

|　　├HashMap 类似Hashtable，但方法不同步，key、value可为null，线程不安全

|　　 └LinkedHashMap 根据插入顺序实现的键值映射集合

|　　├IdentityHashMap 基于哈希表实现的键值映射集合，两个key引用相等==，认为是同一个key

|　　├SortedMap 可排序键值映射集合

|　　 └NavigableMap 可导航搜索的键值映射集合

|　 └WeakHashMap 弱引用建，不阻塞被垃圾回收器回收，key回收后自动移除键值对

二、Collection 和Collections的区别？

Collection是集合层次中最根本的接口。它提供了对集合对象（list和set）进行基本操作的通用接口方法。实现该接口的类主要有List和Set，定义了集合类的基本方法，该接口的设计目标是为了各种具体的集合提供最大化的统一的操作方式。

Collections是针对集合类的一个包裹类，它提供了一系列静态方法实现对各种集合的搜索、排序以及线程安全化等操作，其中的大多数方法都是用于处理线性表。Collections类不能实例化，如同一个工具类，服务于Collection框架。如果在使用Collections类的方法时，对应的Collection对象null，则这些方法都会抛出NullPointerException。

三、List、Set、Map 之间的区别是什么？

List：有序集合，元素可重复
Set：不重复集合，LinkedHashSet按照插入排序，SortedSet可排序，HashSet无序
Map：键值对集合，存储键、值和之间的映射；Key无序，唯一；value 不要求有序，允许重复

四、Array（数组）和List（列表）之间的转换？

**Array（数组）------>List（列表）：**使用 JDK 中 java.util.Arrays 工具类的 asList 方法

public static void testArray2List() {
    String[] strs = new String[] {"aaa", "bbb", "ccc"};
    List<String> list = Arrays.asList(strs);
    for (String s : list) {
        System.out.println(s);
    }
}

**List（列表）------>Array（数组）😗*使用 List 的 toArray 方法。无参 toArray 方法返回 Object 数组，传入初始化长度的数组对象，返回该对象数组

public static void testList2Array() {
    List<String> list = Arrays.asList("aaa", "bbb", "ccc");
    String[] array = list.toArray(new String[list.size()]);
    for (String s : array) {
        System.out.println(s);
    }
}

五、哪些集合类是线程安全的？

Vector
Stack
Hashtable
java.util.concurrent 包下所有的集合类 ArrayBlockingQueue、ConcurrentHashMap、ConcurrentLinkedQueue、ConcurrentLinkedDeque…

六、什么是Iterator （迭代器）？怎么使用？有什么特点？

什么是迭代器？

首先说一下迭代器模式，它是 Java 中常用的设计模式之一。用于顺序访问集合对象的元素，无需知道集合对象的底层实现。
Iterator 是可以遍历集合的对象，为各种容器提供了公共的操作接口，隔离对容器的遍历操作和底层实现，从而解耦。
缺点是增加新的集合类需要对应增加新的迭代器类，迭代器类与集合类成对增加。

怎么使用？

java.lang.Iterable 接口被 java.util.Collection 接口继承，java.util.Collection 接口的 iterator() 方法返回一个 Iterator 对象
next() 方法获得集合中的下一个元素
hasNext() 检查集合中是否还有元素
remove() 方法将迭代器新返回的元素删除
forEachRemaining(Consumer<? super E> action) 方法，遍历所有元素

public class TestIterator {
    
    static List<String> list = new ArrayList<String>();
    
    static {
        list.add("111");
        list.add("222");
        list.add("333");
    }
    
 
    public static void main(String[] args) {
        testIteratorNext();
        System.out.println();
        
        testForEachRemaining();
        System.out.println();
        
        testIteratorRemove();
    }
    
    //使用 hasNext 和 next遍历 
    public static void testIteratorNext() {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            System.out.println(str);
        }
    }
    
    //使用 Iterator 删除元素 
    public static void testIteratorRemove() {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            if ("222".equals(str)) {
                iterator.remove();
            }
        }
        System.out.println(list);
    }
    
    //使用 forEachRemaining 遍历
    public static void testForEachRemaining() {
        final Iterator<String> iterator = list.iterator();
        iterator.forEachRemaining(new Consumer<String>() {
 
            public void accept(String t) {
                System.out.println(t);
            }
            
        });
    }
}

注意事项：

在迭代过程中调用集合的 remove(Object o) 可能会报 java.util.ConcurrentModificationException 异常
forEachRemaining 方法中调用Iterator 的 remove 方法会报 java.lang.IllegalStateException 异常

//使用迭代器遍历元素过程中，调用集合的 remove(Object obj) 方法可能会报 java.util.ConcurrentModificationException 异常
public static void testListRevome() {
    ArrayList<String> aList = new ArrayList<String>();
    aList.add("111");
    aList.add("333");
    aList.add("222");
    System.out.println("移除前："+aList);
     
    Iterator<String> iterator = aList.iterator();
    while(iterator.hasNext()) {
        if("222".equals(iterator.next())) {
            aList.remove("222");          
        }
    }
    System.out.println("移除后："+aList);
}

//JDK 1.8 Iterator forEachRemaining 方法中 调用Iterator 的 remove 方法会报 java.lang.IllegalStateException 异常
public static void testForEachRemainingIteRemove () {
    final Iterator<String> iterator = list.iterator();
    iterator.forEachRemaining(new Consumer<String>() {

        public void accept(String t) {
            if ("222".equals(t)) {
                iterator.remove();
            }
        }
    });
}

七、为什么基本类型不能做为HashMap的键值？

Java中是使用泛型来约束 HashMap 中的key和value的类型的，HashMap<K, V>
泛型在Java的规定中必须是对象Object类型的，基本数据类型不是Object类型，不能作为键值
map.put(0, “ConstXiong”)中编译器已将 key 值 0 进行了自动装箱，变为了 Integer 类型

八、Java中已经有数组类型，为什么还要提供集合？

数组的优点：

数组的效率高于集合类
数组能存放基本数据类型和对象；集合中只能放对象

数组的缺点：

不是面向对象的，存在明显的缺陷
数组长度固定且无法动态改变；集合类容量动态改变
数组无法判断其中实际存了多少元素，只能通过length属性获取数组的申明的长度
数组存储的特点是顺序的连续内存；集合的数据结构更丰富

JDK 提供集合的意义：

集合以类的形式存在，符合面向对象，通过简单的方法和属性调用可实现各种复杂操作
集合有多种数据结构，不同类型的集合可适用于不同场合
弥补了数组的一些缺点，比数组更灵活、实用，可提高开发效率

九、HashSet和HashMap有什么区别？

HashMap

实现 Map 接口
键值对的方式存储
新增元素使用 put(K key, V value) 方法
底层通过对 key 进行 hash，使用数组 + 链表或红黑树对 key、value 存储

HashSet

实现 Set 接口
存储元素对象
新增元素使用 add(E e) 方法
底层是采用 HashMap 实现，大部分方法都是通过调用 HashMap 的方法来实现

十、comparable 和comparator的区别？

相同点：

Comparable和comparator都是用来实现集合的比较、排序的

不同点：

Comparable位于包 java.lang下，而Comparator位于包java.util下
Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序
Comparable是强行对实现他的类的对象进行整体排序（类的自然排序），类的compareTo方法被称为自然比较比较方法。Comparator强行对某个对象进行整体排序，可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。