ToB企服应用市场:ToB评测及商务社交产业平台

标题: Java集合（完整版） [打印本页]

---

作者: 一给    时间: 2024-12-19 17:30
标题: Java集合（完整版）
集合框架

Collection集合

概念：对象的容器，界说了对多个对象进行操作的常用方法。可以实现数组的功能
和数组的区别：

• 数组的长度固定，集合长度不固定
  
• 数组可以存储基本范例和引用范例，集合只能存储引用范例
  

Collection体系集合

如图所示：

Collection：该体系结构的跟接口，代表一组对象，称为“集合”
List接口特点：有序，有下标，元素可重复
Set接口特点：无序，无下标，元素不可重复
Collection父接口

特点：代表一组恣意范例的对象，无序，无下标，不能重复
方法：

• boolean add (Object obj) // 添加一个对象
  
• boolean addAll (Collection c) // 将一个集合中的所有对象添加到此集合中
  
• void clear () // 清空此集合中的所有对象
  
• boolean contains (Object o) // 查抄此集合中是否包含o对象
  
• boolean equals (Object o) // 比较此集合是否与指定对象相等
  
• boolean isEmpty () // 判断此集合是否为空
  
• boolean remove (Object o) // 在此集合中移除o对象
  
• int size () // 返回此集合中的元素个数
  
• Object [ ] toArray () // 将此集合转换成数组
  下面是保存字符串的代码验证：
  
  1. package com.collection.Demo01;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.Iterator;
  7. public class Demo01 {
  9.     public static void main(String[] args) {
  11.         // 创建集合
  12.         // 一、 保存字符串
  13.         Collection collection = new ArrayList();
  14.         // 1. 添加元素
  15.         collection.add("苹果");
  16.         collection.add("西瓜");
  17.         collection.add("榴莲");
  18.         System.out.println("添加之后的元素个数：" + collection.size());  // 添加之后的元素个数：3
  19.         System.out.println(collection);  // [苹果, 西瓜, 榴莲]
  20.         // 2. 删除元素
  21.         // collection.remove("榴莲");
  22.         // collection.remove("西瓜");
  23.         // System.out.println("删除之后剩余的元素个数："+ collection.size());  // 删除之后剩余的元素个数：1
  24.        // 2.1 清空元素
  25. //        collection.clear();
  26. //        System.out.println("清空元素剩余：" + collection.size());  // 清空元素剩余：0
  28.         // 3. 遍历元素
  29.         // 3.1 使用增强for
  30.         System.out.println("----------3.1 使用增强for-------------");
  31.         for (Object obj:collection
  32.              ) {
  33.             System.out.println(obj);
  34.         }
  35.         /*
  36.         ----------3.1 使用增强for-------------
  37.         苹果
  38.         西瓜
  39.         榴莲
  40.          */
  41.         // 3.2 使用迭代器（迭代器是专门用来遍历集合的一种方式）
  42.         // hasNext(); 有没有下一个元素
  43.         // next(); 获取下一个元素
  44.         // remove(); 删除当前元素
  45.         System.out.println("----------3.2 使用迭代器-------------");
  46.         Iterator it = collection.iterator();
  47.         while(it.hasNext()){
  48.             String s = (String)it.next();
  49.             System.out.println(s);
  50.             // 不能使用collection删除方法
  51.             // collection.remove(s);  // ConcurrentModificationException   并发修改异常
  52.             // it.remove();     // 迭代器提供的方法
  53.         }
  54.         System.out.println("剩余的元素个数: "+ collection.size());
  55.         /*
  56.         ----------3.2 使用迭代器-------------
  57.         苹果
  58.         西瓜
  59.         榴莲
  60.         剩余的元素个数: 3
  61.          */
  62.         // 4. 判断
  63.         System.out.println(collection.contains("xigua"));  // false
  64.         System.out.println(collection.contains("西瓜"));  // true
  65.         System.out.println(collection.isEmpty());  // false     判断是否为空// null空 为 true ; not null非空 为 false
  67.     }
  70. }

  复制代码

下面是保存学生信息的代码实现：
学生类 Student：

1. package com.collection.Demo01;
3. /**
4. * 学生类
5. */
6. public class Student {
7.     private String name ;
8.     private int age ;
10.     public Student(String name, int age) {
11.         this.name = name;
12.         this.age = age;
13.     }
15.     public Student() {
17.     }
19.     public String getName() {
20.         return name;
21.     }
23.     public void setName(String name) {
24.         this.name = name;
25.     }
27.     public int getAge() {
28.         return age;
29.     }
31.     public void setAge(int age) {
32.         this.age = age;
33.     }
35.     @Override        // 重写方法
36.     public String toString() {
37.         return "学生信息：[name=" + name + ",age="+age + "]";
38.     }
40.     @Override        // 重写方法
41.     public boolean equals(Object obj) {
42.         // 1 判断是不是同一个对象
43.         if (this==obj){
44.             return true;
45.         }
46.         // 2 判断是否为空
47.         if (obj==null){
48.             return false;
49.         }
50.         // 3 判断是否是Student类型
51.         if(obj instanceof Student){
52.             Student s = (Student) obj;
53.             // 4 比较属性
54.             if (this.name.equals(s.getName())&&this.age==s.getAge()){
55.                 return true;
56.             }
57.         }
58.         // 5 不满足条件返回false
59.         return false;
60.     }
61. }

复制代码

代码验证：

1. package com.collection.Demo01;
3. import java.util.ArrayList;
4. import java.util.Collection;
5. import java.util.Iterator;
7. public class Demo02 {
8.     public static void main(String[] args) {
9.         // 新建 Collection 对象
10.         Collection collection = new ArrayList();
11.         Student s1 = new Student("张三",18);
12.         Student s2 = new Student("李四",17);
13.         Student s3 = new Student("王五",19);
14.         // 1. 添加数据
15.         collection.add(s1);
16.         collection.add(s2);
17.         collection.add(s3);
18.         System.out.println("元素个数：" + collection.size());  // 元素个数：3
19.         System.out.println(collection);  // [学生信息：[name=张三,age=18], 学生信息：[name=李四,age=17], 学生信息：[name=王五,age=19]]
20.         // 2. 删除数据
21.         // collection.remove(s2);
22.         // collection.remove(new Student("王五",19));  // 并没有删除
23.         // collection.clear();
24.         // System.out.println("删除之后的剩余元素：" + collection.size());  // 删除之后的剩余元素：0    // 只是删掉了地址
27.         // 3. 遍历
29.         // 3.1 增强for
30.         System.out.println("--------增强for------");
31.         for (Object obj:collection) {
32.                 Student s = (Student) obj;
33.             System.out.println(s.toString());
34.         }
35.         /*
36.         --------增强for------
37.         学生信息：[name=张三,age=18]
38.         学生信息：[name=李四,age=17]
39.         学生信息：[name=王五,age=19]
40.          */
42.         // 3.2 迭代器
43.         // hasNext();   next();   remove();     迭代过程中不能使用collection的删除方法
44.         System.out.println("--------迭代器------");
45.         Iterator it = collection.iterator();
46.         while (it.hasNext()){
47.             Student s = (Student)it.next();
48.             System.out.println(s);
49.         }
50.         /*
51.         --------迭代器------
52.         学生信息：[name=张三,age=18]
53.         学生信息：[name=李四,age=17]
54.         学生信息：[name=王五,age=19]
55.          */
57.         // 4. 判断
58.         System.out.println(collection.contains(s1));  // true
59.         System.out.println(collection.isEmpty());  // false
61.     }
62. }

复制代码

List子接口

特点：有序，有下标，元素可以重复
方法：

• void add (int index,Object o) // 在index位置插入对象
  
• boolean addAll (int index,Collection c) 将一个集合中的元素添加到此集合中的index 位置
  
• Object get (int index) // 返回集合中指定位置的元素
  
• List subList (int fromIndex,int toIndex) // 返回fromIndex和toIndex之间的集合元素
  

下面是字符串案例：

1. package com.collection.list;
3. import java.util.ArrayList;
4. import java.util.Iterator;
5. import java.util.List;
6. import java.util.ListIterator;
8. public class Demo01 {
9.     public static void main(String[] args) {
10.         // 先创建集合对象
11.         List list = new ArrayList();
12.         // 1. 添加元素
14.         list.add("小米");
15.         list.add("华为");
16.         list.add(0,"苹果");
17.         System.out.println("元素个数：" + list.size());  // 元素个数：3
18.         System.out.println(list.toString());  // [苹果, 小米, 华为]
19.         // 2. 删除元素
20.         // list.remove("华为");
21.         // list.remove(1);
22.         // System.out.println("删除之后还剩余：" + list.size());  // 删除之后还剩余：1
23.         // System.out.println(list);  // [苹果]
24.         // 3. 遍历
25.         // 3.1 使用for遍历
26.         System.out.println("--------使用for遍历--------");
27.         for (int i = 0; i < list.size(); i++) {
28.             System.out.println(list.get(i));
29.         }
30.         /*
31.         --------使用for遍历--------
32.         苹果
33.         小米
34.         华为
35.          */
36.         // 3.2 使用增强for
37.         System.out.println("--------使用增强for--------");
38.         for (Object obj:list
39.              ) {
40.             System.out.println(obj);
41.         }
42.         /*
43.         --------使用增强for--------
44.         苹果
45.         小米
46.         华为
47.          */
48.         // 3.3 使用迭代器
49.         Iterator it = list.iterator();
50.         System.out.println("--------使用迭代器--------");
51.         while (it.hasNext()){
52.             System.out.println(it.next());
53.         }
54.         /*
55.         --------使用迭代器--------
56.         苹果
57.         小米
58.         华为
59.          */
60.         // 3.4 使用列表迭代器，和Iterator的区别: ListIterator可以向前或者向后遍历，添加，删除，修改元素
61.         ListIterator lit = list.listIterator();
62.         System.out.println("--------使用列表迭代器==从前往后--------");
63.         while(lit.hasNext()){
64.             System.out.println(lit.nextIndex()+":" +lit.next());
65.         }
66.         /*
67.         --------使用列表迭代器==从前往后--------
68.         0:苹果
69.         1:小米
70.         2:华为
71.          */
72.         System.out.println("--------使用列表迭代器==从后往前--------");
73.         while (lit.hasPrevious()){
74.             System.out.println(lit.previousIndex()+": "+lit.previous());
75.         }
76.         /*
77.         2: 华为
78.         1: 小米
79.         0: 苹果
80.          */
81.         // 4. 判断
82.         System.out.println(list.contains("苹果"));  // true
83.         System.out.println(list.isEmpty());  // false
84.         // 5.获取位置
85.         System.out.println(list.indexOf("苹果"));  // 0
86.         System.out.println(list.indexOf("华为"));  // 2
87.     }
88. }

复制代码

下面是数字，基本范例（自动装箱）:

1. package com.collection.list;
3. import java.util.ArrayList;
4. import java.util.List;
6. public class Demo02 {
7.     public static void main(String[] args) {
8.         // 创建集合
9.         List list = new ArrayList();
10.         // 1. 添加数字数据（自动装箱）
11.         list.add(10);
12.         list.add(20);
13.         list.add(30);
14.         list.add(40);
15.         list.add(50);
16.         System.out.println("元素个数："+list.size());  // 元素个数：5
17.         System.out.println(list);  // [10, 20, 30, 40, 50]
18.         // 2. 删除操作
19.         // list.remove(2);
20.         // list.remove(new Integer(20));
21.         // list.remove((Object) 40);
22.         // System.out.println("删除元素：" + list.size());  // 删除元素：2
23.         // System.out.println(list);  // [10, 50]
24.         // 3. 补充方法：subList  返回子集合，左闭右开区间  [ )
25.         List subList = list.subList(1,4);
26.         System.out.println(subList);  // [20, 30, 40]
29.     }
30. }

复制代码

下面是学生信息：
学生类同上：

1. package com.collection.list;
3. import com.collection.Demo01.Student;
5. import java.util.ArrayList;
6. import java.util.Iterator;
7. import java.util.ListIterator;
9. public class Demo03 {
10.     public static void main(String[] args) {
11.         // 创建集合
12.         ArrayList arrayList = new ArrayList();
13.         // 1. 添加元素
14.         Student s1 = new Student("源氏",18);
15.         Student s2 = new Student("艾什",18);
16.         Student s3 = new Student("狂鼠",19);
17.         arrayList.add(s1);
18.         arrayList.add(s2);
19.         arrayList.add(s3);
20.         System.out.println("元素个数："+arrayList.size());  // 元素个数：3
21.         System.out.println(arrayList);  // [学生信息：[name=源氏,age=18], 学生信息：[name=艾什,age=18], 学生信息：[name=狂鼠,age=19]]
22.         // 2. 删除元素
23.         // arrayList.remove(new Student("狂鼠",19));  // equals(this==obj)
24.         // arrayList.remove(s2);
25.         // System.out.println("删除之后：" + arrayList.size());  // 删除之后：1
26.         // System.out.println(arrayList);  // [学生信息：[name=源氏,age=18]]
27.         // 3. 遍历元素  ⭐
28.         // 使用迭代器
29.         System.out.println("----------使用迭代器----------");
30.         Iterator it = arrayList.iterator();
31.         while (it.hasNext()){
32.             Student s = (Student) it.next();
33.             System.out.println(s.toString());
34.         }
35.         /*
36.         ----------使用迭代器----------
37.         学生信息：[name=源氏,age=18]
38.         学生信息：[name=艾什,age=18]
39.         学生信息：[name=狂鼠,age=19]
40.          */
41.         // 使用列表迭代器
42.         ListIterator lit = arrayList.listIterator();
43.         System.out.println("----------使用列表迭代器==顺序----------");
44.         while (lit.hasNext()){
45.             Student s = (Student) lit.next();
46.             System.out.println(s.toString());
47.         }
48.         /*
49.         ----------使用列表迭代器==顺序----------
50.         学生信息：[name=源氏,age=18]
51.         学生信息：[name=艾什,age=18]
52.         学生信息：[name=狂鼠,age=19]
53.          */
54.         System.out.println("----------使用列表迭代器==逆序----------");
55.         while (lit.hasPrevious()){
56.             Student s = (Student) lit.previous();
57.             System.out.println(s.toString());
58.         }
59.         /*
60.         ----------使用列表迭代器==逆序----------
61.         学生信息：[name=狂鼠,age=19]
62.         学生信息：[name=艾什,age=18]
63.         学生信息：[name=源氏,age=18]
64.          */
65.         // 4. 判断
66.         System.out.println(arrayList.contains(new Student("狂鼠",19)));  // true
67.         System.out.println(arrayList.contains(s2));  // true
68.         System.out.println(arrayList.isEmpty());  // false
69.         // 5. 查找
70.         System.out.println(arrayList.indexOf(new Student("狂鼠",19)));  // 2
71.         System.out.println(arrayList.indexOf(new Student("源氏",19)));  // -1  // 年龄应为18 ，没有查找到返回-1
75.     }
76. }

复制代码

List 实现类

• ArrayList [重点]:
  数组结构实现，查询快，增删慢
  JDK1.2版本，运行效率快，线程不安全
  
• Vector：
  数组结构实现，查询快，增删慢
  JDK1.0版本，运行效率慢，线程安全
  
• LinkedList:
  链表结构实现，增删快，查询慢
  

ArrayList

源码分析：
DEFAULT_CAPACITY = 10 ; 默认容量
​ 留意：如果没有向集合中添加任何元素时，容量为0；
​ 添加一个元素之后，容量为10；
​ 每次扩容的巨细是原来的1.5倍
elementDate 存放元素的数组
size 实际元素个数
add () 添加元素
Vector

Vector简介
Vector 是矢量队列，它是JDK1.0版本添加的类。继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口。
Vector 继承了AbstractList，实现了List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
Vector 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。
和ArrayList不同，Vector中的操作是线程安全的。
(01) Vector实际上是通过一个数组去保存数据的。当我们构造Vecotr时；若利用默认构造函数，则Vector的默认容量巨细是10。
(02) 当Vector容量不敷以容纳全部元素时，Vector的容量会增长。若容量增长系数 >0，则将容量的值增长“容量增长系数”；否则，将容量巨细增长一倍。
(03) Vector的克隆函数，便是将全部元素克隆到一个数组中。

1. package com.collection.vector;
3. import java.util.Enumeration;
4. import java.util.Vector;
6. public class Demo01 {
8.     public static void main(String[] args) {
9.         // 创建集合
10.         Vector vector = new Vector();
11.         // 1. 添加元素
12.         vector.add("苹果");
13.         vector.add("草莓");
14.         vector.add("葡萄");
15.         System.out.println("元素个数："+vector.size());  // 元素个数：3
16.         System.out.println(vector);  // [苹果, 草莓, 葡萄]
17.         // 2. 删除元素
18.         // vector.remove(0);
19.         // vector.remove("葡萄");
20.         // vector.clear();
21.         // System.out.println("元素个数：" + vector.size());  // 元素个数：0
22.         // 3. 遍历
23.         // 使用枚举器
24.         Enumeration en = vector.elements();
25.         while (en.hasMoreElements()){
26.             String str = (String)en.nextElement();
27.             System.out.println(str);
28.         }
29.         /*
30.         苹果
31.         草莓
32.         葡萄
33.          */
34.         // 4. 判断
35.         System.out.println(vector.contains("葡萄"));  // true
36.         System.out.println(vector.isEmpty());  // false
37.         // 5. 其他方法
38.         System.out.println(vector.firstElement());  // 苹果
39.         System.out.println(vector.lastElement());  // 葡萄
40.         System.out.println(vector.elementAt(1));  // 草莓
41.     }
42. }

复制代码

LinkedList

LinkedList官方文档
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，而是存储在单独的节点中，然后通过引用将节点连接起来了，因此在恣意位置插入大概删除元素时，不需要搬移元素，效率比较高。
留意：
LinkedList实现了List接口
LinkedList的底层利用了双向链表
LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
LinkedList的恣意位置插入和删除元素时效率比较高，时间复杂度为O(1)
LinkedList比较适合恣意位置插入的场景

1. package com.collection.vector;
3. import java.util.Enumeration;
4. import java.util.Vector;
6. public class Demo01 {
8.     public static void main(String[] args) {
9.         // 创建集合
10.         Vector vector = new Vector();
11.         // 1. 添加元素
12.         vector.add("苹果");
13.         vector.add("草莓");
14.         vector.add("葡萄");
15.         System.out.println("元素个数："+vector.size());  // 元素个数：3
16.         System.out.println(vector);  // [苹果, 草莓, 葡萄]
17.         // 2. 删除元素
18.         // vector.remove(0);
19.         // vector.remove("葡萄");
20.         // vector.clear();
21.         // System.out.println("元素个数：" + vector.size());  // 元素个数：0
22.         // 3. 遍历
23.         // 使用枚举器
24.         Enumeration en = vector.elements();
25.         while (en.hasMoreElements()){
26.             String str = (String)en.nextElement();
27.             System.out.println(str);
28.         }
29.         /*
30.         苹果
31.         草莓
32.         葡萄
33.          */
34.         // 4. 判断
35.         System.out.println(vector.contains("葡萄"));  // true
36.         System.out.println(vector.isEmpty());  // false
37.         // 5. 其他方法
38.         System.out.println(vector.firstElement());  // 苹果
39.         System.out.println(vector.lastElement());  // 葡萄
40.         System.out.println(vector.elementAt(1));  // 草莓
41.     }
42. }

复制代码

ArrayList和LinkedList的区别
ArrayList的物理存储空间是连续的，LinkedList物理上不一定连续。
ArrayList支持随机访问，LinkedList不支持随机访问。
ArrayList在插入和删除的时候时间复杂度O(N)，LinkedList时间复杂度O(1)；所以LinkedList适合频繁插入和删除的场景。
ArrayList空间不够需要动态扩容，LinkedList不需要。
泛型

Java泛型是JDK1.5中引入的一个新特性，其本质是参数化范例，把范例作为参数传递
常见形式有：泛型类、泛型接口、泛型方法
语法： T 称为范例占位符，表示一种引用范例
长处：1 提高代码的重（chong）用性
​ 2 防止范例转换异常，提高代码的安全性
下面是泛型类：

1. package com.collection.generic;
3. public class Generic<T> {
4.     // 泛型类：Generic<T>
5.     // 语法： 类名<T>
6.     // T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开
8.     // 使用泛型 T
9.     // 1. 创建变量
10.     // 泛型不能实例化
11.     T t ;
13.     // 2. 泛型作为方法的参数
14.     public void show(T t){
15.         System.out.println("泛型作为方法的参数：" + t);
16.     }
18.     // 3. 泛型作为方法的返回值
19.     public T getT(){
20.         // return (T)("泛型作为方法的返回值" + t);
21.          return t;
22.     }
23. }

复制代码

下面是泛型方法：

1. package com.collection.generic;
4. /**
5. *
6. * 泛型方法
7. * 语法：<T>返回值类型
8. *
9. */
10. public class GenericMethod {
11.     // 泛型方法
12.     public <T> T show(T t){
13.         System.out.println("泛型方法 "+ t);
14.         return t;
15.     }
16. }

复制代码

下面是泛型接口：

1. 接口
2. package com.collection.generic;
4. /**
5. * 泛型接口
6. * 语法：接口名<T>
7. * 注意：不能创建静态常量
8. * @param <T>
9. */
10. public interface GenericService<T> {
11.     String name = "张三";
13.     T server(T t);
14. }

复制代码

1. package com.collection.generic;
3. public class GenericServiceImpl implements GenericService<String>{
5.     @Override
6.     public String server(String t) {
7.         System.out.println(t);
8.         return t;
9.     }
10. }

复制代码

1. package com.collection.generic;
3. public class GenericServiceImpl2<T> implements GenericService<T>{
5.     @Override
6.     public T server(T t) {
7.         System.out.println(t);
8.         return t;
9.     }
10. }

复制代码

泛型测试：

1. package com.collection.generic;
3. public class TestGeneric {
4.     public static void main(String[] args) {
5.         // 使用泛型类创建对象
6.         /*
7.         注意：
8.         1. 泛型只能使用引用类型
9.         2. 不同泛型类型对象之间不能相互赋值
10.          */
11.         Generic<String> generic = new Generic<String>();
12.         generic.t = "Java";
13.         generic.show("我爱学习Java，大家加油！");  // 泛型作为方法的参数：我爱学习Java，大家加油！
14.         String string = generic.getT();
15.         System.out.println(string);  // Java
17.         Generic<Integer> generic1 = new Generic<>();
18.         generic1.t = 18;
19.         generic1.show(180);  // 泛型作为方法的参数：180
20.         Integer integer = generic1.getT();
21.         System.out.println(integer);  // 18
23.         // 泛型接口
24.         GenericService gs = new GenericServiceImpl();
25.         gs.server("java");  // java
27.         GenericService gs2 = new GenericServiceImpl2();
28.         gs2.server(10086);  // 10086
30.         // 泛型方法
31.         GenericMethod gm = new GenericMethod();
32.         gm.show("java is best!");  // 泛型方法 java is best!
33.         gm.show(10086);  // 泛型方法 10086
34.         gm.show(3.1415926);  // 泛型方法 3.1415926
36.     }
37. }

复制代码

泛型集合
概念：参数化范例、范例安全的集合、逼迫集合元素的范例必须同等
特点：

• 编译时即可查抄，而非运营时抛出异常
  
• 访问时，不必范例转换（拆箱）
  
• 不同泛型之间引用不能相互赋值，泛型不存在多态
  

Set子接口

• Set 接口是Collection的子接口，相当于数学上的集合
  
• 特点：
  
  
  
  • 不答应元素重复，添加雷同的元素，返回false
    
  • 无序，无下标。不会记载元素的先后添加顺序
    
  • 判断俩个元素是否相等用的是equals方法
    
  
  
• 方法：全部继承自Collection中的方法
  

Set实现类

• HashSet 是Set 最长用的接口，底层利用Hash（散列）算法，查询和插入速度较快
  
• HashSet 判断俩个对象是否相等，equals比较
  
• 对象的HashCode值决定了在Hash表中的位置
  
  
  • 判断添加对象和集合元素对象HashCode值
    
    
    • 不等： 直接将新添加对象存储导对应位置
      
    • 相等： 再继承判断新对象和集合中对象的具体值：
      
      
      • HashCode 雷同，equals true ，则是同一个对象，则不保存hashtable中
        
      • HashCode 雷同，equals false，存储到同槽的链表上
        
      
      
    
    
  
  

• 基于HashCode计算元素存放位置
  
• 当存入元素的哈希码雷同时，会调用equals进行确认，如果为true 则拒绝后者存入
  

测试Set接口的利用：

1. package com.collection.set;
3. import java.util.HashSet;
4. import java.util.Iterator;
5. import java.util.Set;
7. /**
8. *
9. * 测试Set接口的使用
10. * 特点：无序、无下标 且 不能重复
11. *
12. */
13. public class Demo01 {
14.     public static void main(String[] args) {
15.         // 创建集合
16.         Set<String> set = new HashSet<>();
17.         // 1. 添加数据
18.         set.add("苹果");
19.         set.add("小米");
20.         set.add("华为");
21.         // set.add("华为");  // 不能重复的
22.         System.out.println("元素个数: "+ set.size());  // 元素个数: 3
23.         System.out.println(set.toString());  // [苹果, 华为, 小米]  // 是无序的
25.         // 2. 删除数据
26.         // set.remove("华为");
27.         // System.out.println(set);  // [苹果, 小米]
29.         // 3. 遍历  ⭐
30.         // 3.1 使用增强for
31.         System.out.println("--------使用增强for---------");
32.         for (Object obj:set
33.              ) {
34.             System.out.println(obj);
35.         }
36.         /*
37.         --------使用增强for---------
38.         苹果
39.         华为
40.         小米
41.          */
42.         // 3.2 使用迭代器
43.         System.out.println("--------使用迭代器---------");
44.         Iterator<String> it = set.iterator();
45.         while (it.hasNext()){
46.             System.out.println(it.next());
47.         }
48.         /*
49.         --------使用迭代器---------
50.         苹果
51.         华为
52.         小米
53.          */
54.         // 4. 判断
55.         System.out.println(set.contains("苹果"));  // true
56.         System.out.println(set.isEmpty());  // false
59.     }
60. }

复制代码

HashSet集合的利用 1 ：

1. package com.collection.set;
3. import java.util.HashSet;
4. import java.util.Iterator;
6. /**
7. *
8. * HashSet集合的使用
9. * 存储结构：哈希表（数组＋链表＋红黑树）
10. */
11. public class Demo02 {
12.     public static void main(String[] args) {
13.         // 新建集合
14.         HashSet<String> hashSet = new HashSet<>();
15.         // 1. 添加元素
16.         hashSet.add("源氏");
17.         hashSet.add("闪光");
18.         hashSet.add("狂鼠");
19.         hashSet.add("艾什");
20.         hashSet.add("小美");
21.         // hashSet.add("小美");  // 重复的不添加
22.         System.out.println("元素个数："+hashSet.size());  // 元素个数：5
23.         System.out.println(hashSet.toString());  // [狂鼠, 源氏, 艾什, 小美, 闪光]
24.         // 2. 删除
25.         // hashSet.remove("源氏");
26.         // System.out.println(hashSet.toString());  // [狂鼠, 艾什, 小美, 闪光]
27.         // hashSet.clear();
28.         // System.out.println(hashSet);  // []
29.         // 3. 遍历
30.         // 3.1 使用增强for
31.         System.out.println("------使用增强for--------");
32.         for (String s:hashSet
33.              ) {
34.             System.out.println(s);
35.         }
36.         /*
37.         ------使用增强for--------
38.         狂鼠
39.         源氏
40.         艾什
41.         小美
42.         闪光
43.          */
44.         // 3.2 使用迭代器
45.         System.out.println("------使用迭代器--------");
46.         Iterator it = hashSet.iterator();
47.         while (it.hasNext()){
48.             System.out.println(it.next());
49.         }
50.         /*
51.         ------使用迭代器--------
52.         狂鼠
53.         源氏
54.         艾什
55.         小美
56.         闪光
57.          */
58.         // 4. 判断
59.         System.out.println(hashSet.contains("死神"));  // false
60.         System.out.println(hashSet.contains("源氏"));  // true
61.         System.out.println(hashSet.isEmpty());   // false
63.     }
64. }

复制代码

HashSet集合的利用 2 :

1. package com.collection.set;
3. import java.util.HashSet;
4. import java.util.Iterator;
6. /**
7. * HashSet集合的使用
8. * 存储结构：哈希表（数组＋链表＋红黑树）
9. * 存储过程：
10. *      1. 根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空则执行第二步
11. *      2. 再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表
12. */
14. public class Demo03 {
15.     public static void main(String[] args) {
16.         // 创建集合
17.         HashSet<Person> people = new HashSet<>();
18.         // 1. 添加数据
19.         Person p1 = new Person("源氏",18);
20.         Person p2 = new Person("艾什",19);
21.         Person p3 = new Person("闪光",20);
22.         Person p4 = new Person("狂鼠",21);
24.         people.add(p1);
25.         people.add(p2);
26.         people.add(p3);
27.         people.add(p4);
28.         // people.add(p4);  // 重复 不添加
29.         people.add(new Person("狂鼠",21));  // 重写了hashcode方法与equals方法
30.         System.out.println("元素个数："+ people.size());  // 元素个数：4
31.         System.out.println(people.toString());  // [Person{name='闪光', age=20}, Person{name='艾什', age=19}, Person{name='源氏', age=18}, Person{name='狂鼠', age=21}]
33.         // 2. 删除
34.         // people.remove(p1);
35.         // people.remove(new Person("狂鼠",21));  // 因为重写hashcode方法与equals方法，所以也可以
36.         // System.out.println("删除后："+people.size());  // 删除后：2
37.         // System.out.println(people);  // [Person{name='闪光', age=20}, Person{name='艾什', age=19}]
39.         // 3. 遍历  ⭐
40.         // 3.1 使用增强for
41.         System.out.println("------使用增强for--------");
42.         for (Person person:people
43.              ) {
44.             System.out.println(person.toString());
45.         }
46.         /*
47.         ------使用增强for--------
48.         Person{name='闪光', age=20}
49.         Person{name='艾什', age=19}
50.         Person{name='源氏', age=18}
51.         Person{name='狂鼠', age=21}
52.          */
53.         // 3.2 使用迭代器
54.         System.out.println("------使用迭代器--------");
55.         Iterator<Person> it = people.iterator();
56.         while (it.hasNext()){
57.             System.out.println(it.next());
58.         }
59.         /*
60.         ------使用迭代器--------
61.         Person{name='闪光', age=20}
62.         Person{name='艾什', age=19}
63.         Person{name='源氏', age=18}
64.         Person{name='狂鼠', age=21}
65.          */
66.         // 4. 判断
67.         System.out.println(people.contains(new Person("狂鼠",21)));  // true
68.         System.out.println(people.contains(p2));  // true
69.         System.out.println(people.isEmpty());  // false
71.     }
72. }

复制代码

1. Person类
3. package com.collection.set;
5. import java.util.Objects;
7. public class Person {
8.     private String name ;
9.     private int age;
11.     public Person() {
13.     }
15.     public Person(String name, int age) {
16.         super();
17.         this.name = name;
18.         this.age = age;
19.     }
21.     public String getName() {
22.         return name;
23.     }
25.     public void setName(String name) {
26.         this.name = name;
27.     }
29.     public int getAge() {
30.         return age;
31.     }
33.     public void setAge(int age) {
34.         this.age = age;
35.     }
37.     @Override
38.     public String toString() {
39.         return "Person{" +
40.                 "name='" + name + '\'' +
41.                 ", age=" + age +
42.                 '}';
43.     }
45.     // 快捷键 快速 重写equals 和 hashCode 方法
46.     @Override
47.     public boolean equals(Object o) {
48.         if (this == o) return true;
49.         if (o == null || getClass() != o.getClass()) return false;
50.         Person person = (Person) o;
51.         return age == person.age && Objects.equals(name, person.name);
52.     }
54.     @Override
55.     public int hashCode() {
56.         return Objects.hash(name, age);
57.     }
58.    
59.    
60. //    @Override
61. //    public boolean equals(Object o) {
62. //        if (this == o)
63. //        {
64. //            return true;
65. //        }
66. //        if (o == null ){
67. //            return false;
68. //        }
69. //        if (o instanceof Person){
70. //            Person p = (Person) o;
71. //            if (this.name.equals(p.getName())&&this.age==p.getAge()){
72. //                return true;
73. //            }
74. //        }
75. //        return false;
76. //    }
77. //
78. //    @Override
79. //    public int hashCode() {
80. //        int n1 = this.name.hashCode();
81. //        int n2 = this.age;
82. //        return n1+n2;
83. //    }
85. }

复制代码

TreeSet

• 基于排序顺序实现元素不重复
  
• 实现了SortedSet接口，对集合元素自动排序
  
• 元素对象的范例必须实现Comparable接口，指定排序规则
  
• 通过CompareTo方法确定是否为重复元素
  

下面是TreeSet的利用

1. package com.collection.treeset;
3. import java.util.Iterator;
4. import java.util.TreeSet;
5. /**
6. * TreeSet 的使用
7. * 存储结构：红黑树
8. */
9. public class Demo01 {
10.     public static void main(String[] args) {
11.         // 创建集合
12.         TreeSet<String> treeSet = new TreeSet<>();
13.         // 1. 添加元素
14.         treeSet.add("xyz");
15.         treeSet.add("abc");
16.         treeSet.add("java");
17.         treeSet.add("c++");
18.         treeSet.add("java");  // 元素重复不添加
19.         System.out.println("元素个数："+treeSet.size());  // 元素个数：4
20.         System.out.println(treeSet.toString());  // [abc, c++, java, xyz]
21.         // 2. 删除元素
22. //        treeSet.remove("java");
23. //        treeSet.remove("c++");
24. //        System.out.println("删除元素："+ treeSet.size());  // 删除元素：2
25. //        System.out.println(treeSet.toString());  // [abc, xyz]
26.         // 3. 遍历
27.         // 3.1 使用增强for
28.         System.out.println("---------使用增强for--------");
29.         for (String s: treeSet) {
30.             System.out.println(s);
31.         }
32.         /*
33.         ---------使用增强for--------
34.         abc
35.         c++
36.         java
37.         xyz
38.          */
39.         // 3.2 使用迭代器
40.         System.out.println("---------使用迭代器--------");
41.         Iterator<String> it = treeSet.iterator();
42.         while (it.hasNext()){
43.             System.out.println(it.next());
44.         }
45.         /*
46.         ---------使用迭代器--------
47.         abc
48.         c++
49.         java
50.         xyz
51.          */
52.         // 4. 判断
53.         System.out.println(treeSet.contains("java"));  // true
54.         System.out.println(treeSet.contains("php"));  // false
55.         System.out.println(treeSet.isEmpty());  // false
56.     }
57. }

复制代码

利用TreeSet保存数据

1. package com.collection.treeset;
3. import com.collection.set.Person;
4. import java.util.Iterator;
5. import java.util.TreeSet;
6. /**
7. * 使用TreeSet保存数据
8. * 要求：
9. *  元素必须要实现Comparable接口，compareTo();方法返回值为0，认为是重复元素
10. */
11. public class Demo02 {
13.     public static void main(String[] args) {
14.         // 创建集合
15.         TreeSet<Person> persons = new TreeSet<>();
16.         // 1. 添加元素
17.         Person p1 = new Person("java",18);
18.         Person p2 = new Person("php",19);
19.         Person p3 = new Person("c++",20);
20.         Person p4 = new Person("xyz",21);
21.         Person p5 = new Person("java",1970);
22.         persons.add(p1);
23.         persons.add(p2);
24.         persons.add(p3);
25.         persons.add(p4);
26.         persons.add(p5);
27.         System.out.println("元素个数：" + persons.size());  // 元素个数：5
28.         System.out.println(persons);  // [Person{name='c++', age=20}, Person{name='java', age=18}, Person{name='java', age=1970}, Person{name='php', age=19}, Person{name='xyz', age=21}]
29.         // 2. 删除
30. //        persons.remove(p2);
31. //        persons.remove(new Person("xyz",21));
32. //        System.out.println("删除元素："+persons.size());   // 删除元素：3
33. //        System.out.println(persons.toString());  //  [Person{name='c++', age=20}, Person{name='java', age=18}, Person{name='java', age=1970}]
35.         // 3. 遍历
36.         // 3.1 使用增强for
37.         System.out.println("---------使用增强for--------");
38.         for (Person p: persons
39.              ) {
40.             System.out.println(p);
41.         }
42.         /*
43.         ---------使用增强for--------
44.         Person{name='c++', age=20}
45.         Person{name='java', age=18}
46.         Person{name='java', age=1970}
47.         Person{name='php', age=19}
48.         Person{name='xyz', age=21}
49.          */
50.         // 3.2 使用迭代器
51.         System.out.println("---------使用迭代器--------");
52.         Iterator<Person> it = persons.iterator();
53.         while (it.hasNext()){
54.             System.out.println(it.next());
55.         }
56.         /*
57.         ---------使用迭代器--------
58.         Person{name='c++', age=20}
59.         Person{name='java', age=18}
60.         Person{name='java', age=1970}
61.         Person{name='php', age=19}
62.         Person{name='xyz', age=21}
63.          */
64.         // 4. 判断
65.         System.out.println(persons.contains(p1));  // true
66.         System.out.println(persons.contains(new Person("javase",1970)));  // false
67.         System.out.println(persons.isEmpty());  // false
69.     }
70. }
75. 引用了Person类，重写 compareTo(); 方法
76. // 先按姓名比，然后再按年龄比
77.     @Override
78.     public int compareTo(Person o) {
79.         int n1 = this.getName().compareTo(o.getName());
80.         int n2 = this.age-o.getAge();
81.         return  n1==0?n2:n1;
82.     }

复制代码

TreeSet集合的利用

1. package com.collection.treeset;
3. import com.collection.set.Person;
4. import java.util.Comparator;
5. import java.util.TreeSet;
6. /**
7. * TreeSet 集合的使用
8. * Comparator ： 实现比较定制 （他是一个比较器）
9. * Comparable ： 可比较的
10. */
11. public class Demo03 {
12.     // 创建集合
13.     public static void main(String[] args) {
14.         TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {  // new Comparator<Person>() 匿名内部类
15.             @Override
16.             public int compare(Person o1, Person o2) {
17.                 int n1 = o1.getAge() - o2.getAge();
18.                 int n2 = o1.getName().compareTo(o2.getName());
19.                 return n1 == 0 ? n2 : n1 ;
20.             }
21.         });
23.         Person p1 = new Person("java",24);
24.         Person p2 = new Person("php",26);
25.         Person p3 = new Person("c++",20);
26.         Person p4 = new Person("xyz",17);
27.         Person p5 = new Person("abc",17);
28.         persons.add(p1);
29.         persons.add(p2);
30.         persons.add(p3);
31.         persons.add(p4);
32.         persons.add(p5);
33.         System.out.println(persons);
35.     }
36. }
39. 结果：
40.         [Person{name='xyz', age=17}, Person{name='c++', age=20}, Person{name='java', age=24}, Person{name='php', age=26}]
41.         先比较的age，再比较name
42.         添加p5之后 ，age相同，比较name
43.         [Person{name='abc', age=17}, Person{name='xyz', age=17}, Person{name='c++', age=20}, Person{name='java', age=24}, Person{name='php', age=26}]

复制代码

案例：
要求：利用TreeSet集合实现字符串按照长度进行排序
​ helloworld zhangsan lisi xian beijing nanjing haerbin
​ Comparator 接口实现定制比较
代码实现：

1. package com.collection.treeset;
4. import java.util.Comparator;
5. import java.util.TreeSet;
6. /**
7. * 案例：
8. * 要求：使用TreeSet集合实现字符串按照长度进行排序
9. * helloworld   zhangsan    lisi    xian    beijing   nanjing   haerbin
10. * Comparator 接口实现定制比较
11. */
12. public class Demo04 {
13.     public static void main(String[] args) {
14.         // 创建集合 并指定比较规则
15.         TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
16.             @Override
17.             public int compare(String o1, String o2) {
18.                 int n1 = o1.length() - o2.length();
19.                 int n2 = o1.compareTo(o2);
20.                 return n1 == 0 ? n2 : n1;
21.             }
22.         });
24.         // 添加数据
25.         treeSet.add("helloworld");
26.         treeSet.add("zhangsan");
27.         treeSet.add("lisi");
28.         treeSet.add("xian");
29.         treeSet.add("beijing");
30.         treeSet.add("nanjing");
31.         treeSet.add("haerbin");
32.         System.out.println(treeSet.toString());
34.     }
35. }
37. 结果：
38.         先比较长度，长度相同，则比较name
39.         [lisi, xian, beijing, haerbin, nanjing, zhangsan, helloworld]

复制代码

Map集合

Map体系集合

Map接口的特点：
1.用于存储恣意键值对（Key–Value）
2.键：无序、无下标、不答应重复（唯一）
3.值：无序、无下标、答应重复
Map 父接口

特点：
存储一对数据（Key–Value），无序、无下标，键不可重复，值可重复
方法：

• V put (K key , V value) // 将对象存入到集合中，关联键值。key重复则覆盖原值
  
• Object get (Object key) // 根据键获取对应的值
  
• Set // 返回所有key
  
• Collection values ( ) // 返回包含所有值的Collection集合
  
• Set <Map.Entry<K,V>> // 键值匹配的Set集合
  

代码演示：

1. package com.collection.map;
4. import java.util.HashMap;
5. import java.util.Map;
6. import java.util.Set;
8. /**
9. * Map 接口的使用
10. * 特点：
11. * 1. 存储 键值对 （一对一对的数据）
12. * 2. 键 不能重复，值 可以重复
13. * 3. 无序 没有下标
14. */
15. public class Demo01 {
16.     public static void main(String[] args) {
17.         // 创建 Map 集合
18.         Map<String,String> map = new HashMap<>();
19.         // 1. 添加元素
20.         map.put("cn" , "中国");
21.         map.put("uk" , "英国");
22.         map.put("usa" , "美国");
23.         map.put("cn" , "zhongguo");  // k 相同，覆盖掉 v
24.         System.out.println("元素个数：" + map.size());  // 元素个数：3
25.         System.out.println(map.toString());  // {usa=美国, uk=英国, cn=zhongguo}
27.         // 2. 删除
28.         // map.remove("usa","美国");
29.         // map.remove("usa");
30.         // System.out.println("删除："+map.size());  // 删除：2
31.         // System.out.println(map);  // {uk=英国, cn=zhongguo}
33.         // 3. 遍历
34.         // 3.1 使用 keySet();
35.         System.out.println("-----------keySet()---------");
36.         Set<String> keySet = map.keySet();
37.         for (String key:map.keySet()
38.              ) {
39.             System.out.println(key+"-----"+map.get(key));
40.         }
41.         /*
42.         -----------keySet()---------
43.         usa-----美国
44.         uk-----英国
45.         cn-----zhongguo
46.          */
47.         // 3.2 使用 entrySet();
48.         System.out.println("-----------entrySet()---------");
49.         Set<Map.Entry<String, String>> entries = map.entrySet();
50.         for (Map.Entry<String,String> entry:
51.              map.entrySet()) {
52.             System.out.println(entry.getKey()+"-----"+entry.getValue());
53.         }
54.         /*
55.         -----------entrySet()---------
56.         usa-----美国
57.         uk-----英国
58.         cn-----zhongguo
59.          */
61.         // 4. 判断
62.         System.out.println(map.containsKey("cn"));  // true
63.         System.out.println(map.containsValue("意大利"));  // false
64.     }
65. }

复制代码

HashMap集合

在Java中，HashMap 是一个常用的数据结构，它实现了Map接口，答应我们通过键值对的形式存储和快速查找数据。HashMap的底层是基于哈希表（hash table）的实现，它的高效性和灵活性使其在各种编程场景中广受欢迎。
HashMap是Map接口的一个实现类（HashMap实现了Map的接口），它具有Map的特点。HashMap的底层是哈希表结构。
在 JDK 1.2版本中，线程不安全，运行效率快；答应用null 作为 key 或 value
下面是代码展示：

1. package com.collection.map;
4. import java.util.HashMap;
5. import java.util.Map;
6. import java.util.Set;
8. /**
9. * HashMap集合的使用
10. * 存储结构：哈希表（数组+链表+红黑树）
11. * 使用key 可以hashcode和equals作为重复
12. */
13. public class Demo02 {
14.     public static void main(String[] args) {
15.         // 创建集合
16.         HashMap<Student, String> students= new HashMap<Student,String>();
17.         // 刚创建 hashMap之后没有添加元素  table = null   size = 0 目的：节省空间
18.         // 1. 添加元素
19.         Student s1 = new Student("小李", 00001);
20.         Student s2 = new Student("小王", 00002);
21.         Student s3 = new Student("小赵", 00003);
22.         Student s4 = new Student("小孙", 00004);
23.         students.put(s1,"北京");
24.         students.put(s2,"天津");
25.         students.put(s3,"南京");
26.         students.put(s4,"上海");
27.         // students.put(s4,"杭州");  // 不会新添加，会覆盖
28.         System.out.println("元素个数："+students.size());  // 元素个数：4
29.         System.out.println(students);  // {Student{name='小赵', stId=3}=南京, Student{name='小王', stId=2}=天津, Student{name='小李', stId=1}=北京, Student{name='小孙', stId=4}=杭州}
30.         // 2. 删除
31. //        students.remove(s1);
32. //        students.remove(new Student("小孙", 00004));
33. //        System.out.println("删除之后："+students.size());  // 删除之后：3
34. //        System.out.println(students);  // {Student{name='小赵', stId=3}=南京, Student{name='小王', stId=2}=天津, Student{name='小孙', stId=4}=上海}
35.         // 3. 遍历
36.         // 3.1 使用 keySet();
37.         System.out.println("-----------使用 keySet()---------------");
38.         Set<Student> keySet = students.keySet();
39.         for (Student s:
40.              keySet) {
41.             System.out.println(s+"----"+students.get(s));
42.         }
43.         /*
44.         -----------使用 keySet()---------------
45.         Student{name='小赵', stId=3}-----南京
46.         Student{name='小王', stId=2}-----天津
47.         Student{name='小李', stId=1}-----北京
48.         Student{name='小孙', stId=4}-----上海
49.          */
50.         // 3.2 使用 entrySet();
51.         System.out.println("-----------使用entrySet()--------------");
52.         Set<Map.Entry<Student, String>> entries = students.entrySet();
53.         for (Map.Entry<Student, String> s :
54.                 entries) {
55.             System.out.println(s.getKey()+"-----"+s.getValue());
56.         }
57.         /*
58.         -----------使用entrySet()--------------
59.         Student{name='小赵', stId=3}-----南京
60.         Student{name='小王', stId=2}-----天津
61.         Student{name='小李', stId=1}-----北京
62.         Student{name='小孙', stId=4}-----上海
63.          */
65.         // 4. 判断
66.         System.out.println(students.containsKey(s1));  // true
67.         System.out.println(students.containsKey(new Student("小赵", 00003)));  // true
68.         System.out.println(students.containsValue("新疆"));  // false
69.         System.out.println(students.isEmpty());  // false
71.     }
72. }

复制代码

学生类：

1. package com.collection.map;
3. import java.util.Objects;
5. public class Student implements Comparable<Student>{
6.     private String name ;
7.     private int stId;
9.     public Student() {
11.     }
13.     public Student(String name, int stId) {
14.         this.name = name;
15.         this.stId = stId;
16.     }
18.     public String getName() {
19.         return name;
20.     }
22.     public void setName(String name) {
23.         this.name = name;
24.     }
26.     public int getStId() {
27.         return stId;
28.     }
30.     public void setStId(int stId) {
31.         this.stId = stId;
32.     }
34.     @Override
35.     public String toString() {
36.         return "Student{" +
37.                 "name='" + name + '\'' +
38.                 ", stId=" + stId +
39.                 '}';
40.     }
42.     @Override
43.     public boolean equals(Object o) {
44.         if (this == o) return true;
45.         if (o == null || getClass() != o.getClass()) return false;
46.         Student student = (Student) o;
47.         return stId == student.stId && Objects.equals(name, student.name);
48.     }
50.     @Override
51.     public int hashCode() {
52.         return Objects.hash(name, stId);
53.     }
55.     @Override
56.     public int compareTo(Student o) {
57.         int n = this.stId - o.getStId();
58.         return n;
59.     }
61. }

复制代码

源码分析：

1. 源码分析:
2.     1. static final int DEFAULT_INTTIAL_CAPACITY = 1 << 4 ;
3.     hashMap的初始容量大小
4.     2. static final int MAXIMUM_CAPACITY = 1 << 30 ;
5.     hashMap的数组最大容量
6.     3. static final float DEFAULT_LOAD_FACTOR = 0.75f ;
7.     默认加载因子
8.     4. static final int TREEIFY_THRESHOLD = 8 ;
9.     JDK 1.8 当链表长度大于8时,调整成红黑树
10.     5. static final int UNTREEIFY_THRESHOLD = 6 ;
11.     JDK 1.8 当链表长度大于6时,调整成链表
12.     6. static final int MIN_TREEIFY_CAPACITY = 64 ;
13.     JDK 1.8 当链表长度大于8时,并且集合元素个数大于等于64时,调整成红黑树
14.     7. transient Node<K,V>[] table ;
15.     哈希表中的数组
16.     8. size ;
17.     元素个数

复制代码

总结：

1. 1. HashMap刚创建时,table是null,为了节省空间,当添加第一个元素时,table容量调整为16
2. 2. 当元素个数大于阈值(16*0.75=12)时,会进行扩容,扩容后大小为原来的2倍。目的是减少调整元素的个数
3. 3. jdk 1.8 当每个链表长度大于8,并且数组元素个数大于等于64时,会调整为红黑树,目的是提高执行效率
4. 4. jdk 1.8 当链表长度小于6时,调整成链表
5. 5. jdk 1.8 以前是链表头插入,1.8 以后是尾插入

复制代码

Hashtable与Properties

Hashtable :
​ JDK1.0版本，线程安全，运行效率慢，不答应null作为key或是value
Properties：
​ Hashtable 的子类，要求key和value都是String。通常用于配置文件的读取
TreeMap

实现了SortedMap接口（是Map的子接口），可以对key自动排序
代码演示：

1. package com.collection.map;
4. import java.util.Map;
5. import java.util.TreeMap;
7. /**
8. * TreeMap 的使用
9. * 存储结构： 红黑树
10. */
11. public class Demo03 {
12.     public static void main(String[] args) {
13.         // 新建集合 （也可以使用定制）
14.         TreeMap<Student, String> treeMap = new TreeMap<>();
15.         // 1. 添加元素
16.         Student s1 = new Student("小李", 00001);
17.         Student s2 = new Student("小王", 00002);
18.         Student s3 = new Student("小赵", 00003);
19.         Student s4 = new Student("小孙", 00004);
20.         treeMap.put(s1,"北京");
21.         treeMap.put(s2,"上海");
22.         treeMap.put(s3,"广州");
23.         treeMap.put(s4,"深圳");
24.         // treeMap.put(s3,"香港");  // 无法插入数据，但会把value值替换掉
25.         System.out.println("元素个数："+treeMap.size());  // 元素个数：4
26.         System.out.println(treeMap);  // {Student{name='小李', stId=1}=北京, Student{name='小王', stId=2}=上海, Student{name='小赵', stId=3}=香港, Student{name='小孙', stId=4}=深圳}
28.         // 2. 删除
29. //        treeMap.remove(s1);
30. //        treeMap.remove(new Student("小孙", 00004));
31. //        System.out.println("删除之后："+treeMap.size());  // 删除之后：2
32. //        System.out.println(treeMap);  // {Student{name='小王', stId=2}=上海, Student{name='小赵', stId=3}=广州}
34.         // 3. 遍历
35.         // 3.1 使用 keySet();
36.         System.out.println("-------使用 keySet()---------");
37.         for (Student key:
38.              treeMap.keySet()) {
39.             System.out.println(key+"-----"+treeMap.get(key));
40.         }
41.         /*
42.         -------使用 keySet()---------
43.         Student{name='小李', stId=1}-----北京
44.         Student{name='小王', stId=2}-----上海
45.         Student{name='小赵', stId=3}-----广州
46.         Student{name='小孙', stId=4}-----深圳
47.          */
48.         // 3.2 使用 entrySet();
49.         System.out.println("-------使用 entrySet()---------");
50.         for (Map.Entry<Student, String> entry :
51.                 treeMap.entrySet()) {
52.             System.out.println(entry.getKey()+"----"+entry.getValue());
53.         }
54.         /*
55.         -------使用 entrySet()---------
56.         Student{name='小李', stId=1}----北京
57.         Student{name='小王', stId=2}----上海
58.         Student{name='小赵', stId=3}----广州
59.         Student{name='小孙', stId=4}----深圳
60.          */
61.         // 4. 判断
62.         System.out.println(treeMap.containsKey(s2));  // true
63.         System.out.println(treeMap.containsKey(new Student("小王", 00002)));  // true
64.         System.out.println(treeMap.containsValue("南京"));  // false
65.         System.out.println(treeMap.isEmpty());  // false
66.     }
67. }

复制代码

Collections工具类

概念：集合工具类，界说了除了存取以外的集合常用方法
方法：

• public static void reverse (List<?> list) // 反转集合中元素的顺序
  
• public static void shuffer (List<?> list) // 随机重置集合元素的顺序
  
• public static void sort (List<?> list) // 升序顺序（元素范例必须实现Comparable接口）
  

代码演示：

1. package com.collection.map;
3. import java.util.ArrayList;
4. import java.util.Arrays;
5. import java.util.Collections;
6. import java.util.List;
8. /**
9. * Collections工具类的使用
10. */
11. public class Demo04 {
12.     public static void main(String[] args) {
13.         List<Integer> list = new ArrayList<>();
14.         list.add(58);
15.         list.add(41);
16.         list.add(77);
17.         list.add(26);
18.         list.add(18);
20.         // sort 排序
21.         System.out.println("----------sort---------");
22.         System.out.println("排序之前："+list);  // 排序之前：[58, 41, 77, 26, 18]
23.         Collections.sort(list);
24.         System.out.println("排序之后："+list);  // 排序之后：[18, 26, 41, 58, 77]
26.         // binarySearch 二分查找
27.         System.out.println("--------binarySearch----------");
28.         int i = Collections.binarySearch(list,25);  // -2
29.         int i1 = Collections.binarySearch(list,58);  // 3
30.         System.out.println(i);
31.         System.out.println(i1);
33.         // copy 复制
34.         System.out.println("------copy------");
35.         List<Integer> dest = new ArrayList<>();
36.         for (int j = 0 ; j < list.size() ; j++){
37.             dest.add(0);
38.         }
39.         Collections.copy(dest,list);
40.         System.out.println(dest);  // [18, 26, 41, 58, 77]
42.         // reverse 反转
43.         System.out.println("-------reverse-------------");
44.         Collections.reverse(list);
45.         System.out.println("反转之后："+list);  // 反转之后：[77, 58, 41, 26, 18]
47.         // shuffle 打乱
48.         System.out.println("--------shuffle--------");
49.         Collections.shuffle(list);
50.         System.out.println("打乱之后："+list);  // 打乱之后：[41, 77, 58, 26, 18]
52.         // 补充：
53.         // list转数组
54.         System.out.println("--------list转数组-------");
55.         Integer[] arr = list.toArray(new Integer[2]);
56.         Integer[] arr1 = list.toArray(new Integer[10]);
57.         System.out.println(arr.length);  // 5
58.         System.out.println(Arrays.toString(arr));  // [77, 41, 58, 26, 18]
59.         System.out.println(Arrays.toString(arr1));  // [18, 41, 58, 26, 77, null, null, null, null, null]
61.         // 数组转集合
62.         System.out.println("---------数组转集合----------");
63.         String[] names = {"张三","李四","王五","赵六"};
64.         // 集合是一个受限集合，不能添加和删除
65.         List<String> list2 = Arrays.asList(names);
66.         // list2.add("小李");  UnsupportedOperationException
67.         // list2.remove(2);  UnsupportedOperationException
68.         System.out.println(list2);  // [张三, 李四, 王五, 赵六]
69.         // 把基本类型数组转成集合时，需要修改为包装类型
70.         Integer[] nums = {100,200,300,400,500,600};
71.         List<Integer> list3 = Arrays.asList(nums);
72.         System.out.println(list3);  // [100, 200, 300, 400, 500, 600]
74.     }
75. }

复制代码

集合总结

• 集合的概念：
  
  
  
  • 对象的容器，和数组类似，界说了对多个对象进行操作的常用方法
    
  
  
• List集合
  
  
  
  • 有序、有下标、元素可以重复。（Arraylist、LinkedList、Vector）
    
  
  
• Set集合
  
  
  
  • 无序、无下标、元素不可重复。（HashSet、TreeSet）
    
  
  
• Map集合
  
  
  
  • 存储一对数据，无序、无下标，键不可重复，值可重复。（HashMap、HashTable、TreeMap）
    
  
  
• Collections
  
  
  
  • 集合工具类，界说了除了存取以外的集合常用方法。
    
  
  

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

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4