• UML类图以及常用集合

    目录

    一、UML类图几种关系的总结

    1. 泛化（Generalization）

    2. 实现（Realization）

    3. 关联（Association)

    4. 聚合（Aggregation）

    5. 组合(Composition)

    6. 依赖(Dependency)

    二、常用集合类的UML图

    三、List集合

    List实现类        

    1.ArrayList            

    ArrayList的删除注意事项

    2.LinkedList   

    3.Vector         

    4.CopyOnWriteArrayList          

    四、set集合

    用foreach和迭代器进行遍历

    set实现类        

    1.HashSet            

    2.TreeSet            

    五、map集合   

    map实现类

    1.HashMap        

    遍历map数组

    2.HashTable            

    3.ConcurrentHashMap         

    4.TreeMap       

    5.LinkedHashMap           

    一、UML类图几种关系的总结

    1. 泛化（Generalization）

    【泛化关系】：是一种继承关系，表示一般与特殊的关系，它指定了子类如何特化父类的所有特征和行为。例如：老虎是动物的一种，即有老虎的特性也有动物的共性。

    【箭头指向】：带三角箭头的实线，箭头指向父类

    2. 实现（Realization）

    【实现关系】：是一种类与接口的关系，表示类是接口所有特征和行为的实现.

    【箭头指向】：带三角箭头的虚线，箭头指向接口

     

    3. 关联（Association)

    【关联关系】：是一种拥有的关系，它使一个类知道另一个类的属性和方法；如：老师与学生，丈夫与妻子关联可以是双向的，也可以是单向的。双向的关联可以有两个箭头或者没有箭头，单向的关联有一个箭头。

    【代码体现】：成员变量

    【箭头及指向】：带普通箭头的实心线，指向被拥有者

            上图中，老师与学生是双向关联，老师有多名学生，学生也可能有多名老师。但学生与某课程间的关系为单向关联，一名学生可能要上多门课程，课程是个抽象的东西他不拥有学生。 

    下图为自身关联：

     

    4. 聚合（Aggregation）

    【聚合关系】：是整体与部分的关系，且部分可以离开整体而单独存在。如车和轮胎是整体和部分的关系，轮胎离开车仍然可以存在。

    聚合关系是关联关系的一种，是强的关联关系；关联和聚合在语法上无法区分，必须考察具体的逻辑关系。

    【代码体现】：成员变量

    【箭头及指向】：带空心菱形的实心线，菱形指向整体

     

    5. 组合(Composition)

    【组合关系】：是整体与部分的关系，但部分不能离开整体而单独存在。如公司和部门是整体和部分的关系，没有公司就不存在部门。

    组合关系是关联关系的一种，是比聚合关系还要强的关系，它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期。

    【代码体现】：成员变量

    【箭头及指向】：带实心菱形的实线，菱形指向整体

     

    6. 依赖(Dependency)

    【依赖关系】：是一种使用的关系，即一个类的实现需要另一个类的协助，所以要尽量不使用双向的互相依赖.

    【代码表现】：局部变量、方法的参数或者对静态方法的调用

    【箭头及指向】：带箭头的虚线，指向被使用者

     

    各种关系的强弱顺序：

            泛化 = 实现 > 组合 > 聚合 > 关联 > 依赖 

    下面这张UML图，比较形象地展示了各种类图关系：

    二、常用集合类的UML图

    由于上图map有点不全，可以看下图 

    三、List集合

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

    遍历：下标，foreach，迭代器

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

    扩容：初始容量10,负载因子0.5，扩容增量0.5倍

                   

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

           

             如 ArrayList的容量为10，一次扩容后是容量为15

     三种遍历方法 

    1. package com.xyz.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 ListTest {
    11. 	
    12. 	List<Integer> list=new ArrayList<Integer>();
    13. 	
    14. 	@Before
    15. 	public void setup() {
    16. 		list.add(1);
    17. 		list.add(3);
    18. 		list.add(5);
    19. 		list.add(2);
    20. 		list.add(6);
    21. 		list.add(4);
    22. 	}
    23. 	
    24. 	
    25. 	/**
    26. 	 * foreach遍历
    27. 	 */
    28. 	@Test
    29. 	public void test01() {
    30. 		for (Integer e : list) {
    31. 			System.out.println(e);
    32. 		}
    33. 	}
    34. 	
    35. 	/**
    36. 	 * 下标遍历
    37. 	 */
    38. 	@Test
    39. 	public void test02() {
    40. 		for (int i = 0; i < list.size(); i++) {
    41. 			System.out.println(list.get(i));
    42. 		}
    43. 	}
    44. 	
    45. 	/**
    46. 	 * 迭代器遍历
    47. 	 */
    48. 	@Test
    49. 	public void test03() {
    50. 		Iterator<Integer> it = list.iterator();
    51. 		while(it.hasNext()) {
    52. 			System.out.println(it.next());
    53. 		}
    54. 	}
    55.  
    56. }

    List实现类        

    1.ArrayList            

    • 简单数据结构，超出容量自动扩容，动态数组         

    • 内部实现是基于基础的对象数组的          

    • 随机访问快，遍历快            

    • 不适合随机增加或删除

    • 适用于不确定数据的最大个数的情况 

    • 线程不安全

    ArrayList的删除注意事项

    1. package com.xyz.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 ListRemove {
    11.  
    12. 	private List<Integer> list;
    13. 	
    14. 	@Before
    15. 	public void setup() {
    16. 		list=new ArrayList<>();
    17. 		list.add(1);
    18. 		list.add(2);
    19. 		list.add(3);
    20. 		list.add(3);
    21. 		list.add(4);
    22. 		list.add(5);
    23. 	}
    24. 	
    25. 	/**
    26. 	 * 删除集合中为3的元素的下标
    27. 	 */
    28. 	@Test
    29. 	public void test01() {
    30. 		for(int i=0;i<list.size();i++){
    31. 			   if(list.get(i)==3) list.remove(i);
    32. 		}
    33. 		System.out.println(list);
    34. 		//运行结果：[1,2,3,4,5]
    35. 		//原因：list.get(i)拿到下标为i的元素，当两个一样的元素3相邻时，
    36. 		//	   第一个3在判断并删除后，第二个3及其后面的所有元素的下标都会向前移动一位，
    37. 		//	   这样第二个3就到了第一个3下标所在的位置，但是指针已经判断过第一个3所在位置的元素是否为3了，故不会删除掉第二个3
    38. 	}
    39. 	
    40. 	@Test
    41. 	public void test02() {
    42. 		for(int i=0;i<list.size();i++){
    43. 			   if(list.get(i)==3) list.remove(i--);
    44. 		}
    45. 		System.out.println(list);
    46. 		//运行结果：[1,2,4,5]
    47. 		//原因：第一个3在判断并删除后，第二个3及其后面的所有元素的下标都会向前移动一位，
    48. 		//	   使用了i--，即在进行删除之后指针会向前移一位，再回到删除过的下标位置进行判断，
    49. 		//	   而这样就避免了因为ArrayList的位移现象所导致的判断遗漏。
    50. 	}
    51. 	
    52. 	@Test
    53. 	public void test03() {
    54. 		for(int i=list.size()-1;i>=0;i--){
    55. 			 if(list.get(i)==3){
    56. 			  list.remove(i);
    57. 			 }
    58. 		}
    59. 		System.out.println(list);
    60. 		//运行结果：[1,2,4,5]
    61. 		//原因：这是从集合中的最后一位元素向第一位元素方向进行遍历的倒序遍历方法，
    62. 		//	   这样即使ArrayList的位移现象发生也无法对删除产生影响
    63. 	}
    64. 	
    65. 	@Test
    66. 	public void test04() {
    67. 		for(Integer i:list){
    68. 		    if(i==3) list.remove(i);
    69. 		}
    70. 		System.out.println(list);
    71. 		//运行结果：运行错误
    72. 		//原因：因为ArrayList中有一个变量（modCount=原数组的元素个数）还在内部封装了一个内部类（Itr），
    73. 		//	   这个内部类实现了迭代器，当使用foreach方法遍历时，使用的是ArrayList内部类的迭代器，
    74. 		//	   其中内部类中定义了一个改变次数的变量（expectedModCount），这个变量被赋值为外部modcount的值，
    75. 		//	   当使用内部类（Itr）发生增加或者修改操作时，抛出异常，其目的是阻止ArrayList长度发生改变。
    76. 	}
    77. 	
    78. 	@Test
    79. 	public void test05() {
    80. 		Iterator<Integer> it=list.iterator();
    81. 		while(it.hasNext()){
    82. 		  if(it.next()==3){
    83. 		   it.remove();
    84. 		  }
    85. 		}
    86. 		System.out.println(list);
    87. 		//运行结果：[1,2,4,5]
    88. 		//ArrayList集合在进行删除、增加等操作时，要考虑其动态位移的特性，推荐使用迭代器，会比较安全
    89. 		//上述代码的it.remove不要写成list.remove(i)
    90. 	}
    91. 	
    92. 	@Test
    93. 	public void test06() {
    94. 		Iterator<Integer> it=list.iterator();
    95. 		while(it.hasNext()){
    96. 		Integer value=it.next();
    97. 		   if(value==3){
    98. 			   list.remove(value);
    99. 		  }
    100. 		}
    101. 		System.out.println(list);
    102. 		//运行结果：运行错误
    103. 		//由于写成了list.remove(value)
    104. 	}
    105. 	
    106. 	@Test
    107. 	public void test07() {
    108. 		list.remove(2);
    109. 		System.out.println(list);
    110. 		//运行结果：[1,2,3,4,5]
    111. 		//删除下标为2的元素
    112. 	}
    113. 	
    114. 	@Test
    115. 	public void test08() {
    116. 		list.remove(Integer.valueOf(2));
    117. 		System.out.println(list);
    118. 		//运行结果：[1,3,3,4,5]
    119. 		//删除元素2
    120. 	}
    121. 	
    122. }

    2.LinkedList   

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

    • 线程不安全

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

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

    • 适合做随机的增加或删除      

    3.Vector         

    线程安全            

    并行性能慢，不建议使用       

    4.CopyOnWriteArrayList          

    • 写时复制            

    • 线程安全           

    • 适合于读多，写少的场景            

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

    • 比Vector性能高            

    • 最终一致性           

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

    写时复制是指将原本集合中的数据复制过去，然后在复制过去的集合里的元素进行操作，最终一致性是指修改完成后，这个修改过的集合就会给到原本的集合那里 

    四、set集合

    特点：无序，不重复

    遍历：foreach，迭代器

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

    思考：如何对List容器中的元素去重？试试以下代码吧

    1. package com.xyz.test;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.HashSet;
    5. import java.util.List;
    6.  
    7. import org.junit.Before;
    8. import org.junit.Test;
    9.  
    10. public class SetTest {
    11. 	
    12. 	private List<Integer> list=new ArrayList<Integer>(); 
    13. 	
    14. 	@Before
    15. 	public void setup() {
    16. 		list.add(1);
    17. 		list.add(2);
    18. 		list.add(2);
    19. 		list.add(3);
    20. 		list.add(3);
    21. 		list.add(4);
    22. 		list.add(5);
    23. 		list.add(6);
    24. 	}
    25. 	
    26. 	/**
    27. 	 * 使用set去重
    28. 	 */
    29. 	@Test
    30. 	public void test01() {
    31. 		List<Integer> tmp=new ArrayList<Integer>(new HashSet<Integer>(list));
    32. 		System.out.println(tmp);
    33. 		//运行结果：[1,2,3,4,5,6]
    34. 	}	
    35.  
    36. }

    用foreach和迭代器进行遍历

    1. package com.xyz.test;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Iterator;
    5. import java.util.Set;
    6.  
    7. import org.junit.Before;
    8. import org.junit.Test;
    9.  
    10. public class SetTest { 
    11. 	
    12. 	private Set<Integer> set=new HashSet<Integer>();
    13. 	
    14. 	@Before
    15. 	public void setup() {
    16. 		set.add(1);
    17. 		set.add(1);
    18. 		set.add(2);
    19. 		set.add(4);
    20. 		set.add(4);
    21. 		set.add(5);
    22. 		set.add(3);
    23. 	}
    24. 	
    25. 	/**
    26. 	 * foreach遍历
    27. 	 */
    28. 	@Test
    29. 	public void test02() {
    30. 		for (Integer e : set) {
    31. 			System.out.println(e);
    32. 			//运行结果：1 2 3 4 5
    33. 		}
    34. 	}
    35. 	
    36. 	/**
    37. 	 * 迭代器遍历
    38. 	 */
    39. 	@Test
    40. 	public void test03() {
    41. 		Iterator<Integer> it=set.iterator();
    42. 		while(it.hasNext()) {
    43. 			System.out.println(it.next());
    44. 			//运行结果：1 2 3 4 5
    45. 		}
    46. 	}
    47.  
    48. }

    set实现类        

    1.HashSet            

    • 它存储唯一元素并允许空值，依据对象的hashcode来确定该元素是否存在

    • 由HashMap支持

    • 不保持插入顺序

    • 非线程安全

    • 性能参数：初始容量，负载因子

            默认值： 初始容量16，负载因子0.75

            示例：new HashSet<>(20, 0.5f);

    在上面我们用set对数组进行了去重，那对象我们能不能去重呢？

    1.首先我们实例一个学生对象

    1. package com.xyz.test;
    2.  
    3. public class Student {
    4. 	
    5. 	private Integer sid;
    6. 	private String sname;
    7. 	private Integer age;
    8. 	
    9. 	public Integer getSid() {
    10. 		return sid;
    11. 	}
    12. 	public void setSid(Integer sid) {
    13. 		this.sid = sid;
    14. 	}
    15. 	public String getSname() {
    16. 		return sname;
    17. 	}
    18. 	public void setSname(String sname) {
    19. 		this.sname = sname;
    20. 	}
    21. 	public Integer getAge() {
    22. 		return age;
    23. 	}
    24. 	public void setAge(Integer age) {
    25. 		this.age = age;
    26. 	}
    27. 	
    28. 	@Override
    29. 	public int hashCode() {
    30. 		final int prime = 31;
    31. 		int result = 1;
    32. 		result = prime * result + ((age == null) ? 0 : age.hashCode());
    33. 		result = prime * result + ((sid == null) ? 0 : sid.hashCode());
    34. 		result = prime * result + ((sname == null) ? 0 : sname.hashCode());
    35. 		return result;
    36. 	}
    37. 	@Override
    38. 	public boolean equals(Object obj) {
    39. 		if (this == obj)
    40. 			return true;
    41. 		if (obj == null)
    42. 			return false;
    43. 		if (getClass() != obj.getClass())
    44. 			return false;
    45. 		Student other = (Student) obj;
    46. 		if (age == null) {
    47. 			if (other.age != null)
    48. 				return false;
    49. 		} else if (!age.equals(other.age))
    50. 			return false;
    51. 		if (sid == null) {
    52. 			if (other.sid != null)
    53. 				return false;
    54. 		} else if (!sid.equals(other.sid))
    55. 			return false;
    56. 		if (sname == null) {
    57. 			if (other.sname != null)
    58. 				return false;
    59. 		} else if (!sname.equals(other.sname))
    60. 			return false;
    61. 		return true;
    62. 	}
    63. 	
    64. 	@Override
    65. 	public String toString() {
    66. 		return "Student [sid=" + sid + ", sname=" + sname + ", age=" + age + "]";
    67. 	}
    68. 	
    69. 	public Student(Integer sid, String sname, Integer age) {
    70. 		super();
    71. 		this.sid = sid;
    72. 		this.sname = sname;
    73. 		this.age = age;
    74. 	}
    75.  
    76. 	
    77. 	
    78. }

    不要忘了加上hashCode和equals方法，因为这两个方法是用来判断对象是否相同的

    2.下面我们来测试一下能不能去重 

    我们增加两个id，姓名，年龄一样的对象

    1. package com.xyz.test;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Set;
    5.  
    6. import org.junit.Test;
    7.  
    8. public class SetTest {
    9. 	
    10. 	@Test
    11. 	public void test04() {
    12. 		Set<Student> stu=new HashSet<Student>();
    13. 		
    14. 		stu.add(new Student(1, "小黑", 18));
    15. 		stu.add(new Student(1, "小黑", 18));
    16. 		stu.add(new Student(2, "小黄", 16));
    17. 		stu.add(new Student(3, "小白", 24));
    18. 		stu.add(new Student(4, "张三", 18));
    19. 		stu.add(new Student(5, "李四", 23));
    20. 		
    21. 		for (Student s : stu) {
    22. 			System.out.println(s);
    23. 		}
    24. 	}
    25.  
    26. }

    结果显示，只有一个增加进去了 

     

     那我们来试一下增加两个id不同，姓名年龄相同的，看是都能增加进去还是只能增加一个？

    1. package com.xyz.test;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Set;
    5.  
    6. import org.junit.Test;
    7.  
    8. public class SetTest {
    9. 	
    10. 	@Test
    11. 	public void test04() {
    12. 		Set<Student> stu=new HashSet<Student>();
    13. 		
    14. 		stu.add(new Student(1, "小黑", 18));
    15. 		stu.add(new Student(2, "小黑", 18));
    16. 		stu.add(new Student(3, "小黄", 16));
    17. 		stu.add(new Student(4, "小白", 24));
    18. 		stu.add(new Student(5, "张三", 18));
    19. 		stu.add(new Student(6, "李四", 23));		
    20. 		
    21.         for (Student s : stu) {
    22. 			System.out.println(s);
    23. 		}
    24. 	}
    25.  
    26. }

    结果显示：两个都增加成功了，因为id不同，说明这不是同一个人，没有人规定不能同名同龄 

     

    如果要进行排序，那么需要用到TreeSet 

    2.TreeSet            

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

    排序有两种方法，第一种是在测试类写一个比较器进行比较 ，如下面代码所示

    1. package com.xyz.test;
    2.  
    3. import java.util.Comparator;
    4. import java.util.Set;
    5. import java.util.TreeSet;
    6.  
    7. import org.junit.Test;
    8.  
    9. public class SetTest {
    10. 	
    11. 	@Test
    12. 	public void test04() {
    13. 		Set<Student> stu=new TreeSet<Student>(new Comparator<Student>() {
    14. 			@Override
    15. 			public int compare(Student o1, Student o2) {
    16. 				return o1.getSid()-o2.getSid();
    17.                 //o1代表第一个对象，o2代表第二个对象
    18. 				//o1-o2就可以实现升序
    19. 				//o2-o1就是实现降序
    20. 			}
    21. 		});
    22. 		
    23. 		stu.add(new Student(1, "小黑", 18));
    24. 		stu.add(new Student(1, "小黑", 18));
    25. 		stu.add(new Student(5, "小黄", 16));
    26. 		stu.add(new Student(6, "小白", 24));
    27. 		stu.add(new Student(3, "张三", 18));
    28. 		stu.add(new Student(4, "李四", 23));
    29. 		
    30. 		for (Student s : stu) {
    31. 			System.out.println(s);
    32. 		}
    33. 	}
    34.  
    35. }

    可以看到，这个既去重了又排序了

     

     第二种是在实体类中写一个比较器。下面代码所示

    1. package com.xyz.test;
    2.  
    3. import java.util.Comparator;
    4.  
    5. public class Student implements Comparable<Student>{
    6. 	
    7. 	private Integer sid;
    8. 	private String sname;
    9. 	private Integer age;
    10. 	
    11. 	public Integer getSid() {
    12. 		return sid;
    13. 	}
    14. 	public void setSid(Integer sid) {
    15. 		this.sid = sid;
    16. 	}
    17. 	public String getSname() {
    18. 		return sname;
    19. 	}
    20. 	public void setSname(String sname) {
    21. 		this.sname = sname;
    22. 	}
    23. 	public Integer getAge() {
    24. 		return age;
    25. 	}
    26. 	public void setAge(Integer age) {
    27. 		this.age = age;
    28. 	}
    29. 	
    30. 	@Override
    31. 	public int hashCode() {
    32. 		final int prime = 31;
    33. 		int result = 1;
    34. 		result = prime * result + ((age == null) ? 0 : age.hashCode());
    35. 		result = prime * result + ((sid == null) ? 0 : sid.hashCode());
    36. 		result = prime * result + ((sname == null) ? 0 : sname.hashCode());
    37. 		return result;
    38. 	}
    39. 	@Override
    40. 	public boolean equals(Object obj) {
    41. 		if (this == obj)
    42. 			return true;
    43. 		if (obj == null)
    44. 			return false;
    45. 		if (getClass() != obj.getClass())
    46. 			return false;
    47. 		Student other = (Student) obj;
    48. 		if (age == null) {
    49. 			if (other.age != null)
    50. 				return false;
    51. 		} else if (!age.equals(other.age))
    52. 			return false;
    53. 		if (sid == null) {
    54. 			if (other.sid != null)
    55. 				return false;
    56. 		} else if (!sid.equals(other.sid))
    57. 			return false;
    58. 		if (sname == null) {
    59. 			if (other.sname != null)
    60. 				return false;
    61. 		} else if (!sname.equals(other.sname))
    62. 			return false;
    63. 		return true;
    64. 	}
    65. 	
    66. 	@Override
    67. 	public String toString() {
    68. 		return "Student [sid=" + sid + ", sname=" + sname + ", age=" + age + "]";
    69. 	}
    70. 	
    71. 	public Student(Integer sid, String sname, Integer age) {
    72. 		super();
    73. 		this.sid = sid;
    74. 		this.sname = sname;
    75. 		this.age = age;
    76. 	}
    77.  
    78. 	@Override
    79. 	public int compareTo(Student o) {
    80. 		return this.getSid()-o.getSid();
    81. 	}
    82. 	
    83. 	
    84. }

     测试类

    1. package com.xyz.test;
    2.  
    3. import java.util.Comparator;
    4. import java.util.Set;
    5. import java.util.TreeSet;
    6.  
    7. import org.junit.Test;
    8.  
    9. public class SetTest {
    10. 	
    11. 	@Test
    12. 	public void test04() {
    13. 		Set<Student> stu=new TreeSet<Student>();
    14. 		
    15. 		stu.add(new Student(1, "小黑", 18));
    16. 		stu.add(new Student(1, "小黑", 18));
    17. 		stu.add(new Student(5, "小黄", 16));
    18. 		stu.add(new Student(6, "小白", 24));
    19. 		stu.add(new Student(3, "张三", 18));
    20. 		stu.add(new Student(4, "李四", 23));
    21. 		
    22. 		for (Student s : stu) {
    23. 			System.out.println(s);
    24. 		}
    25. 	}
    26.  
    27. }

     

    五、map集合   

     特点：

    • 键值对，键不能重复，值可以重复，        
    • 键重复则覆盖，后面的覆盖前面的，没有继承Collection接口

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

    遍历

    • 先获取所有键的Set集合，再遍历（通过键获取值）
    • 取出保存所有Entry的Set,再遍历此Set即可     

    map实现类

    1.HashMap        

    • 无序的，线程不安全，最常用，速度快

    • 内部采用数组来存放数据

     基本原理——put执行过程

     

    Table数组中的的Node           

    1.链表结构示意图

                

    2.红黑树结构示意图

    流程图中绿色标出的部分为JDK8新增的处理逻辑，目的是在Table[i]中的Node节点数量大于8时，通过红黑树提升查找速度。

    获取键的值

    1. package com.xyz.test;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Map;
    5.  
    6. import org.junit.Before;
    7. import org.junit.Test;
    8.  
    9. public class MapTest {
    10. 	
    11. 	private Map<String, String > map=new HashMap<String, String>();
    12. 	
    13. 	@Before
    14. 	public void setup() {
    15. 		map.put("1", "小黑");
    16. 		map.put("2", "小白");
    17. 		map.put("3", "嘿嘿");
    18. 		map.put("4", "小蓝");
    19. 	}
    20. 	
    21. 	/**
    22. 	 * 获取键的值
    23. 	 */
    24. 	@Test
    25. 	public void test01() {
    26. 		System.out.println(map.get("1"));
    27. 		//运行结果：小黑
    28. 	}
    29.  
    30. }

    遍历map数组

    方法一：先获取map集合的键，再用键获取值，再遍历（通过键获取值）

    1. package com.xyz.test;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Iterator;
    5. import java.util.Map;
    6.  
    7. import org.junit.Before;
    8. import org.junit.Test;
    9.  
    10. public class MapTest {
    11. 	
    12. 	private Map<String, String > map=new HashMap<String, String>();
    13. 	
    14. 	@Before
    15. 	public void setup() {
    16. 		map.put("1", "小黑");
    17. 		map.put("1", "小黄");
    18. 		map.put("2", "小白");
    19. 		map.put("3", "嘿嘿");
    20. 		map.put("4", "小蓝");
    21. 		map.putIfAbsent("1", "aa");
    22. 	}
    23. 	
    24. 	/**
    25. 	 * 遍历map数组的值
    26. 	 */
    27. 	@Test
    28. 	public void test02() {
    29. 		Iterator<String> it = map.keySet().iterator();
    30. 		while(it.hasNext()) {
    31. 			String key = it.next();
    32. 			System.out.println(map.get(key));
    33. 		}
    34. 	}
    35.  
    36. }
    • 由于小黑和小黄的键重复了，所以后面的小黄覆盖了小黑 
    • putIfAbsent是判断如果有那个键了就不增加，没有则增加

     

    方法二：用Entry直接获取键与值

    1. package com.xyz.test;
    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 MapTest {
    12. 	
    13. 	private Map<String, String > map=new HashMap<String, String>();
    14. 	
    15. 	@Before
    16. 	public void setup() {
    17. 		map.put("1", "小黑");
    18. 		map.put("1", "小黄");
    19. 		map.put("2", "小白");
    20. 		map.put("3", "嘿嘿");
    21. 		map.put("4", "小蓝");
    22. 		map.putIfAbsent("1", "aa");
    23. 	}
    24. 	
    25. 	@Test
    26. 	public void test03() {
    27. 		Iterator<Entry<String, String>> it = map.entrySet().iterator();
    28. 		while(it.hasNext()) {
    29. 			Entry<String, String> e = it.next();
    30. 			System.out.println("key:"+e.getKey()+"--value:"+e.getValue());
    31. 		}
    32. 	}
    33.  
    34. }

     

    2.HashTable            

    线程安全，不太常用     

    3.ConcurrentHashMap         

    线程安全，比HashTable性能高        

    4.TreeMap       

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

    5.LinkedHashMap           

    • 继承HashMap

    • 维护了一个双向链表            

    • LinkedHashMap是有序的，且默认为插入顺序

    1. package com.xyz.test;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Iterator;
    5. import java.util.LinkedHashMap;
    6. import java.util.Map;
    7. import java.util.Map.Entry;
    8. import java.util.Set;
    9.  
    10. import org.junit.Before;
    11. import org.junit.Test;
    12.  
    13. public class MapTest {
    14.  
    15. 	Map<String, String> linkedHashMap = new LinkedHashMap<>();
    16.  
    17. 	@Test
    18. 	public void linkedHashMap() {
    19.         linkedHashMap.put("5", "嘿嘿");
    20.         linkedHashMap.put("4", "喜喜");
    21.         linkedHashMap.put("1", "哈哈");
    22.         linkedHashMap.put("3", "呵呵");
    23.         linkedHashMap.put("3", "嗨嗨");
    24.         linkedHashMap.put("4", "喜喜");
    25.         linkedHashMap.put("1", "哈哈");
    26.         Set<Entry<String, String>> set = linkedHashMap.entrySet();
    27.         Iterator<Entry<String, String>> iterator = set.iterator();
    28.         while(iterator.hasNext()) {
    29.             Entry entry = iterator.next();
    30.             String key = (String) entry.getKey();
    31.             String value = (String) entry.getValue();
    32.             System.out.println("key:" + key + ",value:" + value);
    33.         }
    34. 	}
    35.  
    36. }

    可以看到是有序的，是我们的插入顺序 

     

    内容有点多，请大家耐心观看，就说到这啦~ 

  • 相关阅读:
    java计算机毕业设计BS高校教师考勤系统MyBatis+系统+LW文档+源码+调试部署
    B-神经网络模型复杂度分析
    英飞凌TC3xx--深度手撕HSM安全启动(三)--TC3xx HSM系统架构
    Mysql语句中select、where、groupby、having。。顺序
    分类预测 | MATLAB实现PCA-LSTM(主成分长短期记忆神经网络)分类预测
    【网络安全的神秘世界】XSS基本概念和原理介绍
    ＜顶会论文＞11月14号基于预训练的增量模型
    【Leetcode】【简单】136.只出现一次的数字
    王者荣耀图鉴皮肤怎么来的
    [SpringMVC笔记] SpringMVC-02-bean加载控制
  • 原文地址：https://blog.csdn.net/weixin_67235801/article/details/125486017