• 常用的Java集合框架你知道多少？

    目录

    一、UML类图

    二、List

    特点：

    遍历：

    扩容：

    ​编辑

    如何实现？

    1.ArrayList

    2.LinkedList

    3.Vector

    4.CopyOnWriteArrayList

    ArrayList remove 的注意点

    三、Set

    特点：

    遍历：

    扩容：

    实现：

    01.HashSet

    02.TreeSet

    03.排序：

    四、Map

    特点：

    扩容：

    遍历：

    实现：

    01.HashMap

    02.HashTable

    03.ConcurrentHashMap

    04.TreeMap

    05.LinkedHashMap

    一、UML类图

    UML关系图：

    注:这是老版，新版还添加了其他的类

    UML：统一建模语言

    想更好的了解UML可以去这个网址:

    UML类图几种关系的总结http://www.uml.org.cn/oobject/201609062.asp

    二、List

    特点：

    元素有序，且可重复

    遍历：

    下标，foreach，迭代器

    扩容：

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

    利用反射机制

    1. 	@Test
    2. 	public void listKuo() throws Exception {
    3. 		List<Integer> list=new ArrayList<>();
    4. 		for (int i = 0; i <= 100; i++) {
    5. 			list.add(i);
    6. 			System.out.println("i:"+i);
    7. 			System.out.println("len:"+getListEleSize(list));
    8. 		}
    9. 	}
    10. 	
    11. 	private int getListEleSize(List obj) throws Exception{
    12. 		Class<? extends List> clazz=obj.getClass();
    13. 		java.lang.reflect.Field  f=clazz.getDeclaredField("elementData");
    14. 		f.setAccessible(true);
    15. 		Object[] object= (Object[])f.get(obj);
    16. 		return object.length;
    17. 	}

    如何实现？

    1.ArrayList

    • 简单数据结构，超出容量自动扩容，动态数组
    • 内部实现是基于基础的对象数组的
    • 随机访问快(最快)
    • 不适合随机增加或删除
    • 线程不安全

    2.LinkedList

    • LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部
    • 线程不安全
    • LinkedList可被用作堆栈（stack）【包括了push，pop方法】，队列（queue）或双向队列（deque）
    • 以双向链表实现，链表无容量限制，允许元素为null，线程不安全
    • 适合做随机的增加或删除

    3.Vector

    • 线程安全
    • 并行性能慢，不建议使用

    4.CopyOnWriteArrayList

    • 写时复制
    • 线程安全
    • 适合于读多，写少的场景
    • 写时复制出一个新的数组，完成插入、修改或者移除操作后将新数组赋值给array
    • 比Vector性能高
    • 最终一致性
    • 实现了List接口，使用方式与ArrayList类似

    ArrayList remove 的注意点

    设置下面这个方法，更方便检查

    项目右键找到

    点击Add Library中的JUnit，然后点击下一步

     

    出现以下界面选择JUnit4，再应用就可以了

    用Debug As中的JUnit Test运行

    如果正确那么那个长框中就为绿色，错误为红色（如下图）

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

    1. private List<Integer> list;//成员变量
    2. 	
    3. 	//每次运行都会执行Before方法
    4. 	@Before
    5. 	public void setup() {
    6. 		list = new ArrayList<>();
    7. 		list.add(1);
    8. 		list.add(2);
    9. 		list.add(3);
    10. 		list.add(3);
    11. 		list.add(4);
    12. 	}

    各种输出方法

    1. 	/**
    2. 	 * 删除集合中所有为3的元素
    3. 	 */
    4. 	@Test
    5. 	public void remove01() {
    6. 		for (int i = 0; i < list.size(); i++) {
    7. 			if (list.get(i) == 3)
    8. 				list.remove(i);// 错误，因为数组下标会发生改变（移位）
    9. 		}
    10. 		System.out.println(list);// [1, 2, 3, 4]
    11. 	}
    12.  
    13. 	@Test
    14. 	public void remove02() {
    15. 		for (int i = 0; i < list.size(); i++) {
    16. 			if (list.get(i) == 3)
    17. 				list.remove(i--);// 正确，删除之后下标往上移了一位，所以又识别到了3
    18. 		}
    19. 		System.out.println(list);// [1, 2, 4]
    20. 	}
    21.  
    22. 	@Test
    23. 	public void remove03() {
    24. 		for (int i = list.size() - 1; i >= 0; i--) {
    25. 			if (list.get(i) == 3) {
    26. 				list.remove(i);// 正确，这是从后往前进行检测
    27. 			}
    28. 		}
    29. 		System.out.println(list);// [1, 2, 4]
    30. 	}
    31.  
    32. 	@Test
    33. 	public void remove04() {
    34. 		for (Integer i : list) {
    35. 			if (i == 3)
    36. 				list.remove(i);// 错误，维护的值不相等了
    37. 		}
    38. 		System.out.println(list);
    39. 	}
    40.  
    41. 	@Test
    42. 	public void remove05() {
    43. 		// 迭代器
    44. 		Iterator<Integer> it = list.iterator();
    45. 		while (it.hasNext()) {
    46. 			if (it.next() == 3) {
    47. 				it.remove();// 正确
    48. 			}
    49. 		}
    50. 		System.out.println(list);
    51. 	}
    52.  
    53. 	@Test
    54. 	public void remove06() {
    55. 		Iterator<Integer> it = list.iterator();
    56. 		while (it.hasNext()) {
    57. 			Integer value = it.next();
    58. 			if (value == 3) {
    59. 				list.remove(value);
    60. 			}
    61. 		}
    62. 		System.out.println(list);//错误
    63. 	}
    64. 	
    65. 	@Test
    66. 	public void remove07() {
    67. 		list.remove(2);//删除下标为2的数
    68. 		System.out.println(list);//[1, 2, 3, 4] 
    69. 	}

    三、Set

    特点：

    无序，不重复

    遍历：

    foreach，迭代器

    扩容：

    初始容量16，负载因子0.75，扩容增量1倍

    实现：

    01.HashSet

    • 它存储唯一元素并允许空值（依据对象的hashcode来确定该元素是否存在）
    • 由HashMap支持
    • 不保持插入顺序
    • 非线程安全
    • 性能参数：初始容量，负载因子（默认值： 初始容量16，负载因子0.75    示例：new HashSet<>(20, 0.5f);）

    示例

    1. package com.pf.dao;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.HashSet;
    5. import java.util.Iterator;
    6. import java.util.List;
    7. import java.util.Set;
    8.  
    9. import org.junit.Before;
    10. import org.junit.Test;
    11.  
    12.  
    13. public class SetDemo {
    14. 	
    15. 	private List<Integer> list = new ArrayList<>();
    16. 	
    17. 	private Set<Integer> set = new HashSet<>();
    18. 	
    19. 	@Before
    20. 	public void setup() {
    21. 		list.add(1);
    22. 		list.add(1);
    23. 		list.add(2);
    24. 		list.add(2);
    25. 		list.add(3);
    26. 		list.add(4);
    27. 		list.add(5);
    28. 		
    29. 		set.add(1);
    30. 		set.add(1);
    31. 		set.add(2);
    32. 		set.add(4);
    33. 		set.add(5);
    34. 		set.add(3);
    35. 	}
    36. 	
    37. 	/**
    38. 	 * 去重
    39. 	 */
    40. 	@Test
    41. 	public void test01() {
    42. 		List<Integer> tmp = new ArrayList<>(new HashSet<Integer>(list));
    43. 		System.out.println(tmp);
    44. 	}
    45. 	
    46. 	@Test
    47. 	public void test02() {
    48. 		for(Integer e:set) {
    49. 			System.out.println(e);
    50. 		}
    51. 	}
    52. 	
    53. 	public void test03() {
    54. 		Iterator<Integer> it = set.iterator();
    55. 		while(it.hasNext()) {
    56. 			System.out.println(it.next());
    57. 		}
    58. 	}	
    59. 	
    60.  
    61. }

    02.TreeSet

    • 是一个包含有序的且没有重复元素的集合
    • 作用是提供有序的Set集合，自然排序或者根据提供的Comparator进行排序
    • TreeSet是基于TreeMap实现的

    03.排序：

    java.lang.Comparable

    java.util.Comparator

    第一种：根据sid进行的升序（如果想降序的话，只需要改成o2.getSid()-o1.getSid()）

    1. package com.pf.dao;
    2.  
    3. public class Student {
    4. 	
    5. 	private Integer sid;
    6. 	private String sname;
    7. 	private int age;
    8. 	public Integer getSid() {
    9. 		return sid;
    10. 	}
    11. 	public void setSid(Integer sid) {
    12. 		this.sid = sid;
    13. 	}
    14. 	public String getSname() {
    15. 		return sname;
    16. 	}
    17. 	public void setSname(String sname) {
    18. 		this.sname = sname;
    19. 	}
    20. 	public int getAge() {
    21. 		return age;
    22. 	}
    23. 	public void setAge(int age) {
    24. 		this.age = age;
    25. 	}
    26. 	@Override
    27. 	public int hashCode() {
    28. 		final int prime = 31;
    29. 		int result = 1;
    30. 		result = prime * result + age;
    31. 		result = prime * result + ((sid == null) ? 0 : sid.hashCode());
    32. 		result = prime * result + ((sname == null) ? 0 : sname.hashCode());
    33. 		return result;
    34. 	}
    35. 	@Override
    36. 	public boolean equals(Object obj) {
    37. 		if (this == obj)
    38. 			return true;
    39. 		if (obj == null)
    40. 			return false;
    41. 		if (getClass() != obj.getClass())
    42. 			return false;
    43. 		Student other = (Student) obj;
    44. 		if (age != other.age)
    45. 			return false;
    46. 		if (sid == null) {
    47. 			if (other.sid != null)
    48. 				return false;
    49. 		} else if (!sid.equals(other.sid))
    50. 			return false;
    51. 		if (sname == null) {
    52. 			if (other.sname != null)
    53. 				return false;
    54. 		} else if (!sname.equals(other.sname))
    55. 			return false;
    56. 		return true;
    57. 	}
    58. 	@Override
    59. 	public String toString() {
    60. 		return "Student [sid=" + sid + ", sname=" + sname + ", age=" + age + "]";
    61. 	}
    62. 	public Student() {
    63. 		super();
    64. 		// TODO Auto-generated constructor stub
    65. 	}
    66. 	public Student(Integer sid, String sname, int age) {
    67. 		super();
    68. 		this.sid = sid;
    69. 		this.sname = sname;
    70. 		this.age = age;
    71. 	}
    72. 	
    73. 	
    74.  
    75. }
    1. 	private List<Integer> list = new ArrayList<>();
    2. 	
    3. 	private Set<Integer> set = new HashSet<>();
    4. 	
    5. 	@Before
    6. 	public void setup() {
    7. 		list.add(1);
    8. 		list.add(1);
    9. 		list.add(2);
    10. 		list.add(2);
    11. 		list.add(3);
    12. 		list.add(4);
    13. 		list.add(5);
    14. 		
    15. 		set.add(1);
    16. 		set.add(1);
    17. 		set.add(2);
    18. 		set.add(4);
    19. 		set.add(5);
    20. 		set.add(3);
    21. 	}
    22.  
    23. 	@Test
    24. 	public void test04() {
    25. 		TreeSet<Student> stu = new TreeSet<>(new Comparator<Student>() {
    26. 			@Override
    27. 			public int compare(Student o1, Student o2) {//排序
    28. 				return o1.getSid()-o2.getSid();
    29. 			}
    30. 		});
    31. 		
    32. 		
    33. 		stu.add(new Student(1,"zs", 18));
    34. 		stu.add(new Student(1,"zs", 18));
    35. 		stu.add(new Student(2,"ls", 19));
    36. 		stu.add(new Student(4,"lihao", 10));
    37. 		stu.add(new Student(7,"lihao", 18));
    38. 		stu.add(new Student(5,"zengfanyan", 20));
    39. 		stu.add(new Student(3,"we", 30));
    40. 		
    41. 		//删除
    42. 		//stu.remove(new Student(4, "lihao", 10));
    43. 		
    44. 		for(Student s: stu) {
    45. 			System.out.println(s);
    46. 		}
    47. 	}

    效果图：

     第二种：

    在实体类（student）中继承一个接口

    public class Student implements Comparable<Student>{

    然后实现一个方法

    1. 	@Override
    2. 	public int compareTo(Student o) {
    3. 		return this.getSid() - o.getSid();
    4. 	}

    最后再测试类中把排序删掉

    1. 	@Test
    2. 	public void test04() {
    3. 		TreeSet<Student> stu = new TreeSet<>();
    4. 		
    5. 		
    6. 		stu.add(new Student(1,"zs", 18));
    7. 		stu.add(new Student(1,"zs", 18));
    8. 		stu.add(new Student(2,"ls", 19));
    9. 		stu.add(new Student(4,"lihao", 10));
    10. 		stu.add(new Student(7,"lihao", 18));
    11. 		stu.add(new Student(5,"zengfanyan", 20));
    12. 		stu.add(new Student(3,"we", 30));
    13. 		
    14. 		//删除
    15. 		//stu.remove(new Student(4, "lihao", 10));
    16. 		
    17. 		for(Student s: stu) {
    18. 			System.out.println(s);
    19. 		}
    20. 	}

    四、Map

    特点：

    无序，键值对，键不能重复，值可以重复，键重复则覆盖，没有继承Collection接口

    扩容：

    初始容量16，负载因子0.75，扩容增量1倍

    遍历：

    先获取所有键的Set集合，再遍历（通过键获取值）

    取出保存所有Entry的Set,再遍历此Set即可

    1. package com.pf.dao;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Iterator;
    5. import java.util.Map;
    6. import java.util.Map.Entry;
    7.  
    8. import org.junit.Before;
    9. import org.junit.Test;
    10.  
    11. public class MapDemo {
    12. 	
    13. 	private Map<String, Object> map=new HashMap<String, Object>();
    14. 	
    15. 	@Before
    16. 	public void setup() {
    17. 		map.put("1", "zhuzhu");
    18. 		map.put("1", "aa");
    19. 		map.put("2", "she");
    20. 		map.put("3", "he");
    21. 		
    22. 		//如果键值对没有就添加进去
    23. 		map.putIfAbsent("1", "zzz");
    24. 	}
    25. 	
    26. 	@Test
    27. 	public void test01() {
    28. 		Iterator<String> it = map.keySet().iterator();//通过获取键的集合来获取迭代器
    29. 		while(it.hasNext()) {
    30. 			String key=it.next();
    31. 			System.out.println(map.get(key));
    32. 		}
    33. 	}
    34. 	
    35. 	@Test
    36. 	public void test02() {
    37. 		Iterator<Entry<String, Object>> it = map.entrySet().iterator();
    38. 		//比上面的方法略微快一点点，如果对所有的map集合一次遍历完成之后都要去处理的话，就用这种更好
    39. 		while(it.hasNext()) {
    40. 			Entry<String, Object> e = it.next();
    41. 			System.out.println("key = " + e.getKey()+"value = "+e.getValue());
    42. 		}
    43. 	}
    44.  
    45. }

    实现：

    01.HashMap

    • 线程不安全，最常用，速度快
    • 内部采用数组来存放数据

    基本原理：

    put执行过程

     Table数组中的的Node

    1》链表结构示意图

    数据结构：链表 - 简书本文内容：1、 什么是链表？2、 链表共分几类？3、 链表的 C 实现！ 总表：《数据结构？》 工程代码 Github: Data_Structures_C_Implemen...https://www.jianshu.com/p/73d56c3d228c

    2》红黑树结构示意图

    红黑树是什么?红黑树特点有哪些?-奇Q工具网对于红黑树你了解多少呢?很多刚刚接触java的人都不知道红黑树是什么，那么下面就一起来看一下红黑树的概念以及它的特点吧!一、什么是红黑树?红黑树，是一种自平衡二叉查找树，是在计算机科学当中，所用到的一种数据结构，最典型的用途就是实现关联数组。红黑树是一种特化的AVL树，也就是平衡二叉树，都是在进行插入和删除操作的的时候，通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。红黑树是复杂的，可是，它的最坏情况运行时间也是非常良好的，并且在实践中是高效的。红黑树可以在O(log n)时间内做查找icon-default.png?t=M5H6https://qqe2.com/java/post/1321.html 可以在下面网站中测试（可以在这个网站学习数据类型）Data Structure Visualization http://www.rmboot.com/注：流程图中绿色标出的部分为JDK8新增的处理逻辑，目的是在Table[i]中的Node节点数量大于8时，通过红黑树提升查找速度。 

    02.HashTable

    线程安全，不太常用

    1. 	@Test
    2. 	public void test03() {
    3. 		Map<Integer, Object> table = new Hashtable<Integer, Object>();
    4. 		table.put(1, "zfm");
    5. 		table.put(2, "zfm2");
    6. 		table.put(3, "zfm3");
    7. 		table.put(4, "zfm4");
    8. 		
    9. 		Iterator<Integer> it = table.keySet().iterator();
    10. 		while(it.hasNext()) {
    11. 			int key=it.next();
    12. 			System.out.println(table.get(key));
    13. 		}
    14. 	}

    03.ConcurrentHashMap

    线程安全，比HashTable性能高（一桶一锁，加强比较并替换操作)

    1. 	@Test
    2. 	public void test04() {
    3. 		Map<Integer, Object> cmap = new ConcurrentHashMap<Integer, Object>();
    4. 		cmap.put(1, "zfm");
    5. 		cmap.put(2, "zfm2");
    6. 		cmap.put(3, "zfm3");
    7. 		cmap.put(4, "zfm4");
    8. 		
    9. 		Iterator<Integer> it = cmap.keySet().iterator();
    10. 		while(it.hasNext()) {
    11. 			int key=it.next();
    12. 			System.out.println(cmap.get(key));
    13. 		}
    14. 	}

    04.TreeMap

    • key值按一定的顺序排序
    • 添加或获取元素时性能较HashMap慢（因为需求维护内部的红黑树，用于保证key值的顺序）

    这是降序排列

    1. 	@Test
    2. 	public void test05() {
    3. 		TreeMap<Integer, Object> treeMap = new TreeMap<Integer, Object>(new Comparator<Integer>() {
    4.  
    5. 			@Override
    6. 			public int compare(Integer o1, Integer o2) {
    7. 				return o2 - o1;
    8. 			}
    9. 		});
    10. 		treeMap.put(1, "zs1");
    11. 		treeMap.put(3, "zs3");
    12. 		treeMap.put(2, "zs2");
    13. 		treeMap.put(4, "zs4");
    14. 		
    15. 		Iterator<Integer> it = treeMap.keySet().iterator();
    16. 		while(it.hasNext()) {
    17. 			int key = it.next();        
    18. 			System.out.println(treeMap.get(key));
    19. 		}
    20. 	}

    注：如果在new的时候不记得了可以按住Ctrl键再将鼠标移到TreeMap上点击就可以跳转源代码进行查看了

    05.LinkedHashMap

    • 继承HashMap
    • LinkedHashMap是有序的，且默认为插入顺序（当我们希望有顺序地去存储key-value时，就需要使用LinkedHashMap了）
    1. 	@Test
    2. 	public void test06() {
    3. 		Map<String, String> linkedHashMap = new LinkedHashMap<>();
    4.         linkedHashMap.put("name1", "josan1");
    5.         linkedHashMap.put("name2", "josan2");
    6.         linkedHashMap.put("name3", "josan3");
    7.         Set<Entry<String, String>> set = linkedHashMap.entrySet();
    8.         Iterator<Entry<String, String>> iterator = set.iterator();
    9.         while(iterator.hasNext()) {
    10.             Entry entry = iterator.next();
    11.             String key = (String) entry.getKey();
    12.             String value = (String) entry.getValue();
    13.             System.out.println("key:" + key + ",value:" + value);
    14.         }
    15. 	}

    工具类

    • Collections：提供一组静态方法操作集合
    • Arrays：提供一组静态方法操作数组

  • 相关阅读:
    撰写英文文献有哪些技巧？
    Asp .Net Core 系列：集成 Ocelot+Nacos+Swagger+Cors实现网关、服务注册、服务发现
    状态压缩dp蒙德里安的梦想
    父组件与子组件的属性透传
    关于#matlab#的问题：我看到了gp-ols算法，请问gp我可以理解为是线性拟合吗，还是利用树结构寻优
    对自己LRU算法代码的优化
    Python3 OS 文件/目录方法
    【echart】饼图 legend tooltip格式化比例为0不显示
    MAC安装redis的简单方法
    HTML5期末大作业：简单的学生网页作业源码 基于html企业官网项目的设计与实现【艺术官网】
  • 原文地址：https://blog.csdn.net/m0_67331668/article/details/125483431