• UML List 集合（超详解）

    导语：

    在我们编写代码的过程中会发现有些东西并不适合于用数组来直接装入，这时候我们都会选择我们的集合来完成这个储存的功能，那么我们今天来说一说我们有哪些用的多的集合。

     > 先说一下集合的原理，其实就是将一些数组封装好我们直接用就好啦，那么，又有那些集合呢？List，Set，Map相信大家应该不会陌生，这些是我们常用的一集合，List和Set又有一个共同的特点，就是它们同在collection这个接口之下，二Map不一样，它是单独的Map。下面我们先重点说一说List集合

    在介绍List之前我们先了解一下UML图

    UML

    什么是UML图

    UML-Unified Modeling Language 统一建模语言，又称标准建模语言。是用来对软件密集系统进行可视化建模的一种语言。UML的定义包括UML语义和UML表示法两个元素。

    UML是在开发阶段，说明、可视化、构建和书写一个面向对象软件密集系统的制品的开放方法。最佳的应用是工程实践，对大规模，复杂系统进行建模方面，特别是在软件架构层次，已经被验证有效。统一建模语言（UML）是一种模型化语言。模型大多以图表的方式表现出来。一份典型的建模图表通常包含几个块或框，连接线和作为模型附加信息之用的文本。这些虽简单却非常重要，在UML规则中相互联系和扩展。

    上面的图就是UML图

    UML图的几种关系,(在面试可能遇到)

    泛化(Generalization), 实现(Realization), 依赖(Dependence),关联(Association),聚合(Aggregation) ,组合(Composition)

    泛化(Generalization)

    也就是继承：表示is-a的关系，是对象之间耦合度最大的一种关系，子类继承父类(或者是子接口继承父接口),在Java中使用extends关键字来表示,在类图中使用带三角箭头的实线表示，箭头从子类指向父类。

    实现(Realization):

    指的是两个实体之间的一种合同关系,一个实体定义一个合同,而另外一个实体保证履行该合同,这就对应于Java中的一个类实现了一个接口,在Java中使用implements 关键字来表示,在类图上,使用虚线 + 空心三角形的方法来表示,箭头从实现类指向接口

    依赖(Dependency)

    可以简单的理解，就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、、临时性的、非常弱的，但是B类的变化会影响到A；比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖；表现在代码层面，为类B作为参数被类A在某个method方法中使用,或者类A引用了类B的静态方法；在类图上,使用虚线 + 箭头来表示,箭头的方向,从依赖的类指向被依赖的类

    关联(Assocation)

    就是对象之间的一种依赖关系,比如客户类和订单类之间的关系,这种关系通常使用类的属性表达。关联又分为一般关联、聚合关联与组合关联. 表现在代码层面，为被关联类B以类属性的形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量,在类图使用带箭头的实线表示，箭头从使用类指向被关联的类 可以是单向和双向

    聚合(Aggregation)

    聚合算是关联的一种形式,表示has-a的关系，是一种不稳定的包含关系。较强于一般关联,有整体与局部的关系,并且没有了整体,局部也可单独存在。如公司和员工的关系，公司包含员工，但如果公司倒闭，员工依然可以换公司。在类图使用空心的菱形表示，菱形在整体的那一侧

     

    组合

    组合(Composition):表示contains-a的关系，是一种强烈的包含关系。组合类负责被组合类的生命周期。是一种更强的聚合关系。部分不能脱离整体存在。如公司和部门的关系，没有了公司，部门也不能存在了；调查问卷中问题和选项的关系；订单和订单选项的关系。在类图使用实心的菱形表示，菱形从局部指向整体。

    标题

    整体类图如下：

    List

    特点：元素有序，且可重复

    遍历：下标，foreach，迭代器

    迭代器：是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合，terator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口， 它扩展了 Iterator 接口。

    List集合扩容：

    >初始容量10,负载因子0.5，扩容增量0.5倍，新容量 = 原容量 + 原容量 * 0.5  ， 如 ArrayList的容量为10，一次扩容后是容量为15。

    List实现类：

    arraylist，LinkedList，Vector，CopyOnWriteArrayList。

    arraylist：

    特点：简单数据结构，超出容量自动扩容,动态数组;内部实现是基于基础的对象数组的；随机访问快;不适合随机增加或删除;array list是Java中遍历速度最快的。

    动态数组&扩容机制：

    假设一组数据有24个元素，现在用list集合来装，当我们不知道有24个元素时让集合自动扩容，当容量到达默认容量时，在第十一个时开始扩容，容量增长为5，容量即为15，当又到达最大容量时，并且还有元素要进来，又开始自动增长，容量增长到为22，然后又到大最大容量继续扩容，到没有数据元素截至。当我们已知数据元素长度，我们就可以指定默认容量，就不会像上面一样继续增长，浪费空间。

    注意:arraylist所谓的线程不安全是在类成员变量之中，在我们的方法的之中就不会存在线程安不安全的问题。

    array list删除的之注意事项及案例

    数据准备：为方便演示，需要有紧挨在一起的两个或多个相同的元素

    1. package com.zking.test;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Iterator;
    5. import java.util.List;
    6.  
    7. import org.junit.Before;
    8. import org.junit.Test;
    9.  
    10. public class Tesylist {
    11. 	List<Integer> list;
    12.  
    13. 	@Before
    14. 	public void setup() {
    15. 		list = new ArrayList<Integer>();
    16. 		list.add(1);
    17. 		list.add(4);
    18. 		list.add(8);
    19. 		list.add(8);
    20. 		list.add(12);
    21. 		list.add(16);
    22. 	}
    23.  
    24. 	/**
    25. 	 * 删除元素为8的元素
    26. 	 */
    27.  
    28. 	@Test
    29. 	public void listDel01() {
    30. 		for (int i = 0; i < list.size(); i++) {
    31. 			if (list.get(i) == 8)
    32. 				list.remove(i);
    33. 		}
    34. 		System.out.println(list);
    35. 		// 结果：[1,4,8,12,16]，这种方式直接找到第一个元素8，找到后直接删除结束
    36.  
    37. 	}
    38.  
    39. 	@Test
    40. 	public void listDel02() {
    41. 		for (int i = 0; i < list.size(); i++) {
    42. 			if (list.get(i) == 8)
    43. 				list.remove(i--);
    44. 		}
    45. 		System.out.println(list);
    46. 		// 结果：[1,4,12,16] 这种方式找到第一个8 删除，但第二个8同时发生移位，
    47. 		// 直接跳到第一个8 的位置，但此时指针还未移动，所以又删除一个8 后才往下据继续移动
    48.  
    49. 	}
    50.  
    51. 	@Test
    52. 	public void listDel03() {
    53. 		for (int i = list.size() - 1; i >= 0; i--) {
    54. 			if (list.get(i) == 8) {
    55. 				list.remove(i);
    56. 			}
    57. 		}
    58. 		System.out.println(list);
    59. 		// 结果：[1,4,12,16] 这种方式是将集合到过来进行遍历删除，第二个8发生移位但又移动
    60. 		// 到了指针还为移动位置，然后删除了
    61.  
    62. 	}
    63.  
    64. 	@Test
    65. 	public void listDel04() {
    66. 		for (Integer i : list) {
    67. 			if (i == 8)
    68. 				list.remove(i);
    69. 		}
    70. 		System.out.println(list);
    71. 		// 结果：执行错误
    72.  
    73. 	}
    74.  
    75. 	@Test
    76. 	public void listDel05() {
    77. 		Iterator<Integer> it = list.iterator();
    78. 		while (it.hasNext()) {
    79. 			if (it.next() == 8) {
    80. 				it.remove();
    81. 			}
    82. 		}
    83. 		System.out.println(list);
    84. 		// 结果：[1,4,12,16]迭代器
    85.  
    86. 	}
    87.  
    88. 	@Test
    89. 	public void listDel06() {
    90. 		Iterator<Integer> it = list.iterator();
    91. 		while (it.hasNext()) {
    92. 			Integer value = it.next();
    93. 			if (value == 8) {
    94. 				list.remove(value);
    95. 			}
    96. 		}
    97. 		System.out.println(list);
    98. 		// 结果：执行不通过
    99. 	}
    100.  
    101. 		@Test
    102. 	public void listDel07() {
    103. //		ist.add(1);
    104. //		list.add(4);
    105. //		list.add(8);
    106. //		list.add(8);
    107. //		list.add(12);
    108. //		list.add(16);
    109.  
    110. 		list.add(4);
    111. 		// 结果: [1,4,8,12,16]，在这里，删除的是下标为4的元素，刚好为元素8
    112. 		list.remove(Integer.valueOf(4));
    113. 		System.out.println(list);
    114. //		结果: [1,8,8,12,16]，在这里，删除的是元素为4的元素，以为通过
    115. //		integer.valueof()将4转成了一个对象4，所以删除的是4而不是下标为4的元素
    116. 	}
    117. }

    总结：通过上面的案例，我们可以知道，原来araaylist的删除还这么多的方法。

    arraylist的扩容机制案例

    1. @Test
    2. 	public void listkr() throws Exception {
    3. 		List<Integer> list1 = new ArrayList<Integer>();
    4. 		for (int i = 0; i < 100; i++) {
    5. 			list1.add(i);
    6. 			System.out.println("i:" + i);
    7. 			System.out.println("len:" + getlistsize(list1));
    8. 		}
    9. 	}
    10.  
    11. 	private int getlistsize(List obj) throws Exception {
    12. 		Class<? extends List> clazz = obj.getClass();
    13. 		Field f = clazz.getDeclaredField("elementData");
    14. 		f.setAccessible(true);
    15. 		Object[] object = (Object[]) f.get(obj);
    16. 		return object.length;
    17. 	}
    18.     
    19. //运行结果
    20.     i:0
    21. 	len:10
    22. 	i:1
    23. 	len:10
    24. 	i:2
    25. 	len:10
    26. 	i:3
    27. 	len:10
    28. 	i:4
    29. 	len:10
    30. 	i:5
    31. 	len:10
    32. 	i:6
    33. 	len:10
    34. 	i:7
    35. 	len:10
    36. 	i:8
    37. 	len:10
    38. 	i:9
    39. 	len:10
    40. 	i:10
    41. 	len:15
    42. 	i:11
    43. 	len:15
    44. 	i:12
    45. 	len:15
    46. 	i:13
    47. 	len:15
    48. 	i:14
    49. 	len:15
    50. 	i:15
    51. 	len:22
    52. 	i:16
    53. 	len:22
    54. 	i:17
    55. 	len:22
    56. 	i:18
    57. 	len:22
    58. 	i:19
    59. 	len:22
    60. 	i:20
    61. 	len:22
    62. 	i:21
    63. 	len:22
    64. 	i:22
    65. 	len:33
    66. 	i:23
    67. 	len:33
    68. 	i:24
    69. 	len:33
    70. 	i:25
    71. 	len:33
    72. 	i:26
    73. 	len:33
    74. 	i:27
    75. 	len:33
    76. 	i:28
    77. 	len:33
    78. 	i:29
    79. 	len:33
    80. 	i:30
    81. 	len:33
    82. 	i:31
    83. 	len:33
    84. 	i:32
    85. 	len:33
    86. 	i:33
    87. 	len:49
    88. 	i:34
    89. 	len:49
    90. 	i:35
    91. 	len:49
    92. 	i:36
    93. 	len:49
    94. 	i:37
    95. 	len:49
    96. 	i:38
    97. 	len:49
    98. 	i:39
    99. 	len:49
    100. 	i:40
    101. 	len:49
    102. 	i:41
    103. 	len:49
    104. 	i:42
    105. 	len:49
    106. 	i:43
    107. 	len:49
    108. 	i:44
    109. 	len:49
    110. 	i:45
    111. 	len:49
    112. 	i:46
    113. 	len:49
    114. 	i:47
    115. 	len:49
    116. 	i:48
    117. 	len:49
    118. 	i:49
    119. 	len:73
    120. 	i:50
    121. 	len:73
    122. 	...............
    123.  
    124.

    总结：通过这个案例我们就可以更清晰的认识到array list的扩容机制

    新容量 = 原容量 + 原容量 * 0.5  

    LinkedList

    下面是LinkedList的一个概略图模型图

     特点：

    1. LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部

    2. 线程不安全

    3. LinkedList可被用作堆栈（stack）【包括了push，pop方法】，队列（queue）或双向队列（deque）

    4. 以双向链表实现，链表无容量限制，允许元素为null，线程不安全

    5. 适合做随机的增加或删除

    Vector

    特点

    1. 线程安全

    2. 并行性能慢，不建议使用

    vector的线程的安全性是通过加锁的形式来实现的，但由于加的锁范围太大，造成了空间和性能的浪费，所以一般用的少；

    CopyOnWriteArrayList

    特点：

    1.写时复制

    2. 线程安全

    3. 适合于读多，写少的场景

    4. 写时复制出一个新的数组，完成插入、修改或者移除操作后将新数组赋值给array

    5. 比Vector性能高

    6.最终一致性

    7.实现了List接口，使用方式与ArrayList类似

    缺点：要等数据修改完了之后才能读取到，在修改数据时别人无法读取新数据，但值得一提的是在在复制和替换的时候这个时间是非常短的，所以我们也可以放心大胆使用。

    总结：list集合中用的最多的是array list，但如果作为类成员变量来使用，就会在高并发下可能产生线程问题，但作为方法变量就不会存在这个问题；除了我们的array list还有LinkedList,Vector,CopyOnWriteArrayList,这些都是常用的list还需要我们好好学习！！！

  • 相关阅读:
    ABC253EX (fzt子集计数+矩阵树定理)
    C#.NET Framework RSA 私钥签名 公钥验签（验证签名） ver:20230612
    微服务（服务治理）
    煤矿安全大模型：微调internlm2模型实现针对煤矿事故和煤矿安全知识的智能问答
    ＜二.1＞ android 直接使用hal库播放pcm demo
    springboot毕设项目大学社团管理系统3rj9k（java+VUE+Mybatis+Maven+Mysql）
    linux 性能分析工具perf
    mybatis-plus进行数据字段加密解密入库
    线程的“结束”
    简历准备及面试技巧，你应该知道的一切
  • 原文地址：https://blog.csdn.net/weixin_67150631/article/details/125475936