Java 集合框架：从数据结构到性能优化，全面分析集合类 ...

河曲智叟  金牌会员 | 2025-3-24 21:36:41 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 997|帖子 997|积分 2991

Java 集合框架（Java Collections Framework，JCF）是 Java 语言中用于存储、操纵和管理数据的尺度库。它提供了一组通用的接口、类和方法，使开辟者能够高效地操纵不同范例的数据集合。
本文将联合 Java 集合框架类图，介绍集合框架的整体架构，并对各个集合类的特性、适用场景及优缺点举行具体分析。
1. Java 集合框架概览

Java 集合框架紧张分为 Collection 和 Map 两大类。


  • Collection（集合）：用于存储一组对象，继续自 Iterable，包括 List、Set 等子接口。

  • Map（映射）：用于存储键值对（key-value），不属于 Collection 接口，但同样是集合框架的一部分，如 HashMap、TreeMap 等。

2. Collection 体系

Collection 是 Java 集合框架的核心接口，它继续了 Iterable，允许集合中的元素举行迭代（如 for-each 循环）。
Collection 紧张分为 List 和 Set 两大类：
Collection 是 Java 集合框架的核心接口，它继续了 Iterable，允许集合中的元素举行迭代（如 for-each 循环）。
Collection 紧张分为 List 和 Set 两大类：
2.1 List（列表）

List 接口表示有序集合，允许元素重复，支持索引访问。

List 实现类特点


  • ArrayList：基于动态数组，查找快（O(1)），插入删除慢（O(n)）。
  • LinkedList：基于双向链表，插入删除快（O(1)），查找慢（O(n)）。
  • Vector：雷同 ArrayList，但线程安全（所有方法都使用 synchronized 举行同步）。
 实例：
ArrayList

  1. package List_;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. /**
  8. * @author lay
  9. * @version 1.0
  10. **/
  11. public class List_exercise_ {
  12.     @SuppressWarnings("all")
  13.     public static void main(String[] args) {
  14.         List arrayList = new ArrayList();
  15.         for (int i = 0; i < 12; i++) {
  16.             arrayList.add("小黄" + i);
  17.         }
  18.         //第二个位置插入元素"行书评教育"，通过相应的方法，add()
  19.         arrayList.add(2,"行书评教育");
  20.         System.out.println("插入后数= "+arrayList);
  22.         Object o = arrayList.get(5);
  23.         System.out.println("获得的元素 = " +o +o.getClass());
  25.         arrayList.remove(6);
  26.         System.out.println("删除后的list:= "+ arrayList);
  28.         arrayList.set(7,"小米");
  29.         System.out.println("修改后的元素为：=" +arrayList);
  31.         Iterator iterator = arrayList.iterator();
  33. //        while (iterator.hasNext()) {
  34. //            Object next =  iterator.next();
  35. //            System.out.print(next);
  36. //        }
  38. //        for (int i = 0; i < arrayList.size(); i++) {
  39. //            Object o1 = arrayList.get(i);
  40. //            System.out.print(o1);
  41. //        }
  42.         //
  43.         for (Object object :arrayList) {
  44.                     System.out.println(object);
  45.         }
  48.     }
  49. }
复制代码
 LinkedList:

  1. package Collection_;
  3. import java.util.Iterator;
  4. import java.util.LinkedList;
  6. /**
  7. * @author lay
  8. * @version 1.0
  9. **/
  10. public class LinkedList_CRUD {
  11.     public static void main(String[] args) {
  12.         LinkedList linkedList = new LinkedList();
  13.         linkedList.add(1);
  14.         linkedList.add(2);
  15.         System.out.println(linkedList);
  17.         linkedList.remove();
  18.         System.out.println(linkedList);
  20.         Iterator iterator = linkedList.iterator();
  21.         while (iterator.hasNext()) {
  22.             Object o =  iterator.next();
  23.             System.out.println(o);
  24.         }
  25.     }
  26. }
复制代码
 Vector:

  1. package Collection_;
  3. import java.util.List;
  4. import java.util.Vector;
  6. /**
  7. * @author lay
  8. * @version 1.0
  9. **/
  10. public class Vector_Detail {
  11.     public static void main(String[] args) {
  12.         Vector vector = new Vector();
  13. //        Vector vector = new Vector(8);
  14.         for (int i = 0; i < 10; i++) {
  15.             vector.add(i);
  16.         }
  17.         vector.add(100);
  18.         System.out.println("vector=" + vector);
  19.     }
  20. }
复制代码
2.2 Set（集合）

Set 接口表示无序集合，不允许重复元素。

Set 实现类特点


  • HashSet：基于 HashMap 实现，元素无序，插入、删除、查找时间复杂度均为 O(1)。
  • TreeSet：基于红黑树（TreeMap）实现，元素有序（默认升序，可自定义 Comparator 规则），插入、删除、查找复杂度 O(log n)。
实例：
HashSet

  1. package Set_;
  3. import java.util.HashSet;
  4. import java.util.Iterator;
  5. import java.util.Set;
  7. /**
  8. * @author lay
  9. * @version 1.0
  10. **/
  11. public class Set_Methods_ {
  12.     @SuppressWarnings("all")
  13.     public static void main(String[] args) {
  14.         Set set = new HashSet();//以Set接口的实现类hashset
  15.         set.add("sdfa");
  16.         set.add("john");
  17.         set.add("lucy");
  18.         set.add("john");//重复
  19.         set.add("jack");
  20.         set.add("hsp");
  21.         set.add("mary");
  22.         set.add(null);//
  23. //        System.out.println(set);
  24. //        for (int i = 0; i < 10; i++) {
  25. //            System.out.println(set);
  26. //        }
  29.         //遍历
  30.         Iterator iterator = set.iterator();
  31.         while (iterator.hasNext()) {
  32.             Object o =  iterator.next();
  33.             System.out.println(o);
  34.         }
  36.         set.remove(null);
  37.         for (Object o :set) {
  38.             System.out.println(o);
  39.         }
  40.     }
  41. }
复制代码
 TreeSet

  1. package Collection_;
  3. import java.util.Comparator;
  4. import java.util.TreeSet;
  6. /**
  7. * @author lay
  8. * @version 1.0
  9. **/
  10. @SuppressWarnings("all")
  11. public class TreeSet_ {
  12.     public static void main(String[] args) {
  14.         TreeSet treeSet = new TreeSet();
  15.         treeSet.add(145);
  16.         treeSet.add(45);
  17.         treeSet.add(5);
  18.         treeSet.add(741);
  19.         System.out.println(treeSet);//无参构造器无序
  21.         //使用匿名内部类，
  22.         TreeSet treeSet1 = new TreeSet(new Comparator() {
  23.             @Override
  24.             public int compare(Object o1, Object o2) {
  25.                 //向下转型
  26. //                return ((String) o1).compareTo((String) o2);
  27.                 return ((String) o1).length()-((String) o2).length();
  28.             }
  29.         });
  32.         treeSet1.add("Z");
  33.         treeSet1.add("Dse");
  34.         treeSet1.add("Sse");
  35.         treeSet1.add("Wwefwa");
  36.         treeSet1.add("Wasefefe");
  37.         System.out.println(treeSet1);
  41.     }
  42. }
复制代码
3. Map 体系

Map 接口用于存储键值对（key-value），key 不能重复，但 value 可以重复。

Map 实现类特点


  • HashMap：基于哈希表，默认 key 无序，插入、删除、查找 O(1)。
  • LinkedHashMap：继续 HashMap，但维护 key 的插入顺序，遍历时按插入顺序输出。
  • TreeMap：基于红黑树，key 有序，查找 O(log n)。
  • Hashtable：HashMap 的线程安全版本，但服从较低（同步方法降低并发性能）。
  • Properties：继续自 Hashtable，专门用于配置文件（key-value 均为字符串）。
实例用法：
 
TreeMap

  1. package Map_;
  3. import java.util.Comparator;
  4. import java.util.TreeMap;
  6. /**
  7. * @author lay
  8. * @version 1.0
  9. **/
  10. public class Tree_Map {
  11.     public static void main(String[] args) {
  12. //        TreeMap treeMap = new TreeMap();//默认构造器无序
  13.         TreeMap treeMap = new TreeMap(new Comparator() {
  14.             @Override
  15.             public int compare(Object o1, Object o2) {
  16. //                return ((String) o1).compareTo((String) o2);//按字符顺序排序
  17.                 return ((String) o1).length() -((String) o2).length();//按字符顺序排序
  19.             }
  20.         });
  21.         treeMap.put("ada","123");
  22.         treeMap.put("eqr","3");
  23.         treeMap.put("zrr","13");
  24.         treeMap.put("rhth","1");
  26.         System.out.println(treeMap);
  28.     }
  29. }
复制代码
Hashtable

  1. package Map_;
  3. import java.util.Hashtable;
  5. /**
  6. * @author lay
  7. * @version 1.0
  8. **/
  9. @SuppressWarnings("all")
  10. public class Hashtable_ {
  11.     public static void main(String[] args) {
  12.         //1. Properties 继承 Hashtable
  13. //2. 可以通过 k-v 存放数据，当然 key 和 value 不能为 null
  14. //增加
  15.         Hashtable properties = new Hashtable();
  16. //properties.put(null, "abc");//抛出 空指针异常
  17. //properties.put("abc", null); //抛出 空指针异常
  18.         properties.put("john", 100);//k-v
  19.         properties.put("lucy", 100);
  20.         properties.put("lucsdfy", 100);
  21.         properties.put("ludsfwerwcy", 100);
  22.         properties.put("lerucy", 100);
  23.         properties.put("luercy", 100);
  24.         properties.put("lucwery", 100);
  25.         properties.put("wr", 100);
  26.         properties.put("lweic", 100);
  27.         properties.put("lic", 88);//如果有相同的 key ， value 被替换
  28.         System.out.println("properties=" + properties);
  31.     }
  32. }
复制代码

Properties

  1. package Map_;
  3. import java.util.Properties;
  5. /**
  6. * @author lay
  7. * @version 1.0
  8. **/
  9. public class Properties_ {
  10.     public static void main(String[] args) {
  11.         Properties properties = new Properties();
  12. //properties.put(null, "abc");//抛出 空指针异常
  13. //properties.put("abc", null); //抛出 空指针异常
  14.         properties.put("john", 100);//k-v
  15.         properties.put("lucy", 100);
  16.         properties.put("lic", 100);
  17.         properties.put("lic", 88);//如果有相同的 key ， value 被替换,也是修改
  18.         System.out.println("properties=" + properties);
  19.         System.out.println(properties.get("lic"));
  20.         properties.remove("lic");
  21.         System.out.println(properties);
  22.     }
  23. }
复制代码
 4. List、Set、Map 的对比总结


5. 线程安全性



  • 非线程安全：ArrayList、LinkedList、HashMap、HashSet
  • 线程安全：Vector、Hashtable、Properties
  • 加锁实现线程安全：Collections.synchronizedList(new ArrayList<>())
6. 选择合适的数据结构


7. 结论

Java 集合框架提供了丰富的数据结构，以满足不同的开辟需求。


  • List 适用于有序、允许重复的场景，如 ArrayList 得当快速查找，LinkedList 得当频仍插入删除。
  • Set 适用于去重的场景，如 HashSet 去重但无序，TreeSet 去重且有序。
  • Map 适用于键值对存储，HashMap 查询快但无序，TreeMap 查询稍慢但有序，LinkedHashMap 维护插入顺序。
  • 线程安全的集合类（如 Vector、Hashtable）在现代并发编程中较少使用，建议使用 ConcurrentHashMap 等更优方案。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

河曲智叟

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表