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 () // 将此集合转换成数组

下面是保存字符串的代码验证：

java">package com.collection.Demo01;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;public class Demo01 {public static void main(String[] args) {// 创建集合// 一、 保存字符串Collection collection = new ArrayList();// 1. 添加元素collection.add("苹果");collection.add("西瓜");collection.add("榴莲");System.out.println("添加之后的元素个数：" + collection.size());  // 添加之后的元素个数：3System.out.println(collection);  // [苹果, 西瓜, 榴莲]// 2. 删除元素// collection.remove("榴莲");// collection.remove("西瓜");// System.out.println("删除之后剩余的元素个数："+ collection.size());  // 删除之后剩余的元素个数：1// 2.1 清空元素
//        collection.clear();
//        System.out.println("清空元素剩余：" + collection.size());  // 清空元素剩余：0// 3. 遍历元素// 3.1 使用增强forSystem.out.println("----------3.1 使用增强for-------------");for (Object obj:collection) {System.out.println(obj);}/*----------3.1 使用增强for-------------苹果西瓜榴莲*/// 3.2 使用迭代器（迭代器是专门用来遍历集合的一种方式）// hasNext(); 有没有下一个元素// next(); 获取下一个元素// remove(); 删除当前元素System.out.println("----------3.2 使用迭代器-------------");Iterator it = collection.iterator();while(it.hasNext()){String s = (String)it.next();System.out.println(s);// 不能使用collection删除方法// collection.remove(s);  // ConcurrentModificationException   并发修改异常// it.remove();     // 迭代器提供的方法}System.out.println("剩余的元素个数: "+ collection.size());/*----------3.2 使用迭代器-------------苹果西瓜榴莲剩余的元素个数: 3*/// 4. 判断System.out.println(collection.contains("xigua"));  // falseSystem.out.println(collection.contains("西瓜"));  // trueSystem.out.println(collection.isEmpty());  // false     判断是否为空// null空 为 true ; not null非空 为 false}}

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

学生类 Student：

java">package com.collection.Demo01;/*** 学生类*/
public class Student {private String name ;private int age ;public Student(String name, int age) {this.name = name;this.age = age;}public Student() {}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Override	// 重写方法public String toString() {return "学生信息：[name=" + name + ",age="+age + "]";}@Override	// 重写方法public boolean equals(Object obj) {// 1 判断是不是同一个对象if (this==obj){return true;}// 2 判断是否为空if (obj==null){return false;}// 3 判断是否是Student类型if(obj instanceof Student){Student s = (Student) obj;// 4 比较属性if (this.name.equals(s.getName())&&this.age==s.getAge()){return true;}}// 5 不满足条件返回falsereturn false;}
}

代码验证：

java">package com.collection.Demo01;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;public class Demo02 {public static void main(String[] args) {// 新建 Collection 对象Collection collection = new ArrayList();Student s1 = new Student("张三",18);Student s2 = new Student("李四",17);Student s3 = new Student("王五",19);// 1. 添加数据collection.add(s1);collection.add(s2);collection.add(s3);System.out.println("元素个数：" + collection.size());  // 元素个数：3System.out.println(collection);  // [学生信息：[name=张三,age=18], 学生信息：[name=李四,age=17], 学生信息：[name=王五,age=19]]// 2. 删除数据// collection.remove(s2);// collection.remove(new Student("王五",19));  // 并没有删除// collection.clear();// System.out.println("删除之后的剩余元素：" + collection.size());  // 删除之后的剩余元素：0    // 只是删掉了地址// 3. 遍历// 3.1 增强forSystem.out.println("--------增强for------");for (Object obj:collection) {Student s = (Student) obj;System.out.println(s.toString());}/*--------增强for------学生信息：[name=张三,age=18]学生信息：[name=李四,age=17]学生信息：[name=王五,age=19]*/// 3.2 迭代器// hasNext();   next();   remove();     迭代过程中不能使用collection的删除方法System.out.println("--------迭代器------");Iterator it = collection.iterator();while (it.hasNext()){Student s = (Student)it.next();System.out.println(s);}/*--------迭代器------学生信息：[name=张三,age=18]学生信息：[name=李四,age=17]学生信息：[name=王五,age=19]*/// 4. 判断System.out.println(collection.contains(s1));  // trueSystem.out.println(collection.isEmpty());  // false}
}

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之间的集合元素

下面是字符串案例：

java">package com.collection.list;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;public class Demo01 {public static void main(String[] args) {// 先创建集合对象List list = new ArrayList();// 1. 添加元素list.add("小米");list.add("华为");list.add(0,"苹果");System.out.println("元素个数：" + list.size());  // 元素个数：3System.out.println(list.toString());  // [苹果, 小米, 华为]// 2. 删除元素// list.remove("华为");// list.remove(1);// System.out.println("删除之后还剩余：" + list.size());  // 删除之后还剩余：1// System.out.println(list);  // [苹果]// 3. 遍历// 3.1 使用for遍历System.out.println("--------使用for遍历--------");for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}/*--------使用for遍历--------苹果小米华为*/// 3.2 使用增强forSystem.out.println("--------使用增强for--------");for (Object obj:list) {System.out.println(obj);}/*--------使用增强for--------苹果小米华为*/// 3.3 使用迭代器Iterator it = list.iterator();System.out.println("--------使用迭代器--------");while (it.hasNext()){System.out.println(it.next());}/*--------使用迭代器--------苹果小米华为*/// 3.4 使用列表迭代器，和Iterator的区别: ListIterator可以向前或者向后遍历，添加，删除，修改元素ListIterator lit = list.listIterator();System.out.println("--------使用列表迭代器==从前往后--------");while(lit.hasNext()){System.out.println(lit.nextIndex()+":" +lit.next());}/*--------使用列表迭代器==从前往后--------0:苹果1:小米2:华为*/System.out.println("--------使用列表迭代器==从后往前--------");while (lit.hasPrevious()){System.out.println(lit.previousIndex()+": "+lit.previous());}/*2: 华为1: 小米0: 苹果*/// 4. 判断System.out.println(list.contains("苹果"));  // trueSystem.out.println(list.isEmpty());  // false// 5.获取位置System.out.println(list.indexOf("苹果"));  // 0System.out.println(list.indexOf("华为"));  // 2}
}

下面是数字，基本类型（自动装箱）:

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

下面是学生信息：

学生类同上：

java">package com.collection.list;import com.collection.Demo01.Student;import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;public class Demo03 {public static void main(String[] args) {// 创建集合ArrayList arrayList = new ArrayList();// 1. 添加元素Student s1 = new Student("源氏",18);Student s2 = new Student("艾什",18);Student s3 = new Student("狂鼠",19);arrayList.add(s1);arrayList.add(s2);arrayList.add(s3);System.out.println("元素个数："+arrayList.size());  // 元素个数：3System.out.println(arrayList);  // [学生信息：[name=源氏,age=18], 学生信息：[name=艾什,age=18], 学生信息：[name=狂鼠,age=19]]// 2. 删除元素// arrayList.remove(new Student("狂鼠",19));  // equals(this==obj)// arrayList.remove(s2);// System.out.println("删除之后：" + arrayList.size());  // 删除之后：1// System.out.println(arrayList);  // [学生信息：[name=源氏,age=18]]// 3. 遍历元素  ⭐// 使用迭代器System.out.println("----------使用迭代器----------");Iterator it = arrayList.iterator();while (it.hasNext()){Student s = (Student) it.next();System.out.println(s.toString());}/*----------使用迭代器----------学生信息：[name=源氏,age=18]学生信息：[name=艾什,age=18]学生信息：[name=狂鼠,age=19]*/// 使用列表迭代器ListIterator lit = arrayList.listIterator();System.out.println("----------使用列表迭代器==顺序----------");while (lit.hasNext()){Student s = (Student) lit.next();System.out.println(s.toString());}/*----------使用列表迭代器==顺序----------学生信息：[name=源氏,age=18]学生信息：[name=艾什,age=18]学生信息：[name=狂鼠,age=19]*/System.out.println("----------使用列表迭代器==逆序----------");while (lit.hasPrevious()){Student s = (Student) lit.previous();System.out.println(s.toString());}/*----------使用列表迭代器==逆序----------学生信息：[name=狂鼠,age=19]学生信息：[name=艾什,age=18]学生信息：[name=源氏,age=18]*/// 4. 判断System.out.println(arrayList.contains(new Student("狂鼠",19)));  // trueSystem.out.println(arrayList.contains(s2));  // trueSystem.out.println(arrayList.isEmpty());  // false// 5. 查找System.out.println(arrayList.indexOf(new Student("狂鼠",19)));  // 2System.out.println(arrayList.indexOf(new Student("源氏",19)));  // -1  // 年龄应为18 ，没有查找到返回-1}
}

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的克隆函数，即是将全部元素克隆到一个数组中。

java">package com.collection.vector;import java.util.Enumeration;
import java.util.Vector;public class Demo01 {public static void main(String[] args) {// 创建集合Vector vector = new Vector();// 1. 添加元素vector.add("苹果");vector.add("草莓");vector.add("葡萄");System.out.println("元素个数："+vector.size());  // 元素个数：3System.out.println(vector);  // [苹果, 草莓, 葡萄]// 2. 删除元素// vector.remove(0);// vector.remove("葡萄");// vector.clear();// System.out.println("元素个数：" + vector.size());  // 元素个数：0// 3. 遍历// 使用枚举器Enumeration en = vector.elements();while (en.hasMoreElements()){String str = (String)en.nextElement();System.out.println(str);}/*苹果草莓葡萄*/// 4. 判断System.out.println(vector.contains("葡萄"));  // trueSystem.out.println(vector.isEmpty());  // false// 5. 其他方法System.out.println(vector.firstElement());  // 苹果System.out.println(vector.lastElement());  // 葡萄System.out.println(vector.elementAt(1));  // 草莓}
}

LinkedList

LinkedList官方文档
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，而是存储在单独的节点中，然后通过引用将节点连接起来了，因此在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。

注意：

LinkedList实现了List接口
LinkedList的底层使用了双向链表
LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)
LinkedList比较适合任意位置插入的场景

java">package com.collection.vector;import java.util.Enumeration;
import java.util.Vector;public class Demo01 {public static void main(String[] args) {// 创建集合Vector vector = new Vector();// 1. 添加元素vector.add("苹果");vector.add("草莓");vector.add("葡萄");System.out.println("元素个数："+vector.size());  // 元素个数：3System.out.println(vector);  // [苹果, 草莓, 葡萄]// 2. 删除元素// vector.remove(0);// vector.remove("葡萄");// vector.clear();// System.out.println("元素个数：" + vector.size());  // 元素个数：0// 3. 遍历// 使用枚举器Enumeration en = vector.elements();while (en.hasMoreElements()){String str = (String)en.nextElement();System.out.println(str);}/*苹果草莓葡萄*/// 4. 判断System.out.println(vector.contains("葡萄"));  // trueSystem.out.println(vector.isEmpty());  // false// 5. 其他方法System.out.println(vector.firstElement());  // 苹果System.out.println(vector.lastElement());  // 葡萄System.out.println(vector.elementAt(1));  // 草莓}
}

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

泛型

Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递

常见形式有：泛型类、泛型接口、泛型方法

语法： T 称为类型占位符，表示一种引用类型

好处：1 提高代码的重（chong）用性

2 防止类型转换异常，提高代码的安全性

下面是泛型类：

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

下面是泛型方法：

java">package com.collection.generic;/**** 泛型方法* 语法：<T>返回值类型**/
public class GenericMethod {// 泛型方法public <T> T show(T t){System.out.println("泛型方法 "+ t);return t;}
}

下面是泛型接口：

java">接口
package com.collection.generic;/*** 泛型接口* 语法：接口名<T>* 注意：不能创建静态常量* @param <T>*/
public interface GenericService<T> {String name = "张三";T server(T t);
}

java">package com.collection.generic;public class GenericServiceImpl implements GenericService<String>{@Overridepublic String server(String t) {System.out.println(t);return t;}
}

java">package com.collection.generic;public class GenericServiceImpl2<T> implements GenericService<T>{@Overridepublic T server(T t) {System.out.println(t);return t;}
}

泛型测试：

java">package com.collection.generic;public class TestGeneric {public static void main(String[] args) {// 使用泛型类创建对象/*注意：1. 泛型只能使用引用类型2. 不同泛型类型对象之间不能相互赋值*/Generic<String> generic = new Generic<String>();generic.t = "Java";generic.show("我爱学习Java，大家加油！");  // 泛型作为方法的参数：我爱学习Java，大家加油！String string = generic.getT();System.out.println(string);  // JavaGeneric<Integer> generic1 = new Generic<>();generic1.t = 18;generic1.show(180);  // 泛型作为方法的参数：180Integer integer = generic1.getT();System.out.println(integer);  // 18// 泛型接口GenericService gs = new GenericServiceImpl();gs.server("java");  // javaGenericService gs2 = new GenericServiceImpl2();gs2.server(10086);  // 10086// 泛型方法GenericMethod gm = new GenericMethod();gm.show("java is best!");  // 泛型方法 java is best!gm.show(10086);  // 泛型方法 10086gm.show(3.1415926);  // 泛型方法 3.1415926}
}

泛型集合

概念：参数化类型、类型安全的集合、强制集合元素的类型必须一致

特点：

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

Set子接口

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

Set实现类

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

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

测试Set接口的使用：

java">package com.collection.set;import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;/**** 测试Set接口的使用* 特点：无序、无下标 且 不能重复**/
public class Demo01 {public static void main(String[] args) {// 创建集合Set<String> set = new HashSet<>();// 1. 添加数据set.add("苹果");set.add("小米");set.add("华为");// set.add("华为");  // 不能重复的System.out.println("元素个数: "+ set.size());  // 元素个数: 3System.out.println(set.toString());  // [苹果, 华为, 小米]  // 是无序的// 2. 删除数据// set.remove("华为");// System.out.println(set);  // [苹果, 小米]// 3. 遍历  ⭐// 3.1 使用增强forSystem.out.println("--------使用增强for---------");for (Object obj:set) {System.out.println(obj);}/*--------使用增强for---------苹果华为小米*/// 3.2 使用迭代器System.out.println("--------使用迭代器---------");Iterator<String> it = set.iterator();while (it.hasNext()){System.out.println(it.next());}/*--------使用迭代器---------苹果华为小米*/// 4. 判断System.out.println(set.contains("苹果"));  // trueSystem.out.println(set.isEmpty());  // false}
}

HashSet集合的使用 1 ：

java">package com.collection.set;import java.util.HashSet;
import java.util.Iterator;/**** HashSet集合的使用* 存储结构：哈希表（数组＋链表＋红黑树）*/
public class Demo02 {public static void main(String[] args) {// 新建集合HashSet<String> hashSet = new HashSet<>();// 1. 添加元素hashSet.add("源氏");hashSet.add("闪光");hashSet.add("狂鼠");hashSet.add("艾什");hashSet.add("小美");// hashSet.add("小美");  // 重复的不添加System.out.println("元素个数："+hashSet.size());  // 元素个数：5System.out.println(hashSet.toString());  // [狂鼠, 源氏, 艾什, 小美, 闪光]// 2. 删除// hashSet.remove("源氏");// System.out.println(hashSet.toString());  // [狂鼠, 艾什, 小美, 闪光]// hashSet.clear();// System.out.println(hashSet);  // []// 3. 遍历// 3.1 使用增强forSystem.out.println("------使用增强for--------");for (String s:hashSet) {System.out.println(s);}/*------使用增强for--------狂鼠源氏艾什小美闪光*/// 3.2 使用迭代器System.out.println("------使用迭代器--------");Iterator it = hashSet.iterator();while (it.hasNext()){System.out.println(it.next());}/*------使用迭代器--------狂鼠源氏艾什小美闪光*/// 4. 判断System.out.println(hashSet.contains("死神"));  // falseSystem.out.println(hashSet.contains("源氏"));  // trueSystem.out.println(hashSet.isEmpty());   // false}
}

HashSet集合的使用 2 :

java">package com.collection.set;import java.util.HashSet;
import java.util.Iterator;/*** HashSet集合的使用* 存储结构：哈希表（数组＋链表＋红黑树）* 存储过程：*      1. 根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空则执行第二步*      2. 再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表*/public class Demo03 {public static void main(String[] args) {// 创建集合HashSet<Person> people = new HashSet<>();// 1. 添加数据Person p1 = new Person("源氏",18);Person p2 = new Person("艾什",19);Person p3 = new Person("闪光",20);Person p4 = new Person("狂鼠",21);people.add(p1);people.add(p2);people.add(p3);people.add(p4);// people.add(p4);  // 重复 不添加people.add(new Person("狂鼠",21));  // 重写了hashcode方法与equals方法System.out.println("元素个数："+ people.size());  // 元素个数：4System.out.println(people.toString());  // [Person{name='闪光', age=20}, Person{name='艾什', age=19}, Person{name='源氏', age=18}, Person{name='狂鼠', age=21}]// 2. 删除// people.remove(p1);// people.remove(new Person("狂鼠",21));  // 因为重写hashcode方法与equals方法，所以也可以// System.out.println("删除后："+people.size());  // 删除后：2// System.out.println(people);  // [Person{name='闪光', age=20}, Person{name='艾什', age=19}]// 3. 遍历  ⭐// 3.1 使用增强forSystem.out.println("------使用增强for--------");for (Person person:people) {System.out.println(person.toString());}/*------使用增强for--------Person{name='闪光', age=20}Person{name='艾什', age=19}Person{name='源氏', age=18}Person{name='狂鼠', age=21}*/// 3.2 使用迭代器System.out.println("------使用迭代器--------");Iterator<Person> it = people.iterator();while (it.hasNext()){System.out.println(it.next());}/*------使用迭代器--------Person{name='闪光', age=20}Person{name='艾什', age=19}Person{name='源氏', age=18}Person{name='狂鼠', age=21}*/// 4. 判断System.out.println(people.contains(new Person("狂鼠",21)));  // trueSystem.out.println(people.contains(p2));  // trueSystem.out.println(people.isEmpty());  // false}
}

java">Person类package com.collection.set;import java.util.Objects;public class Person {private String name ;private int age;public Person() {}public Person(String name, int age) {super();this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}// 快捷键 快速 重写equals 和 hashCode 方法@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;return age == person.age && Objects.equals(name, person.name);}@Overridepublic int hashCode() {return Objects.hash(name, age);}//    @Override
//    public boolean equals(Object o) {
//        if (this == o)
//        {
//            return true;
//        }
//        if (o == null ){
//            return false;
//        }
//        if (o instanceof Person){
//            Person p = (Person) o;
//            if (this.name.equals(p.getName())&&this.age==p.getAge()){
//                return true;
//            }
//        }
//        return false;
//    }
//
//    @Override
//    public int hashCode() {
//        int n1 = this.name.hashCode();
//        int n2 = this.age;
//        return n1+n2;
//    }}

TreeSet

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

下面是TreeSet的使用

java">package com.collection.treeset;import java.util.Iterator;
import java.util.TreeSet;
/*** TreeSet 的使用* 存储结构：红黑树*/
public class Demo01 {public static void main(String[] args) {// 创建集合TreeSet<String> treeSet = new TreeSet<>();// 1. 添加元素treeSet.add("xyz");treeSet.add("abc");treeSet.add("java");treeSet.add("c++");treeSet.add("java");  // 元素重复不添加System.out.println("元素个数："+treeSet.size());  // 元素个数：4System.out.println(treeSet.toString());  // [abc, c++, java, xyz]// 2. 删除元素
//        treeSet.remove("java");
//        treeSet.remove("c++");
//        System.out.println("删除元素："+ treeSet.size());  // 删除元素：2
//        System.out.println(treeSet.toString());  // [abc, xyz]// 3. 遍历// 3.1 使用增强forSystem.out.println("---------使用增强for--------");for (String s: treeSet) {System.out.println(s);}/*---------使用增强for--------abcc++javaxyz*/// 3.2 使用迭代器System.out.println("---------使用迭代器--------");Iterator<String> it = treeSet.iterator();while (it.hasNext()){System.out.println(it.next());}/*---------使用迭代器--------abcc++javaxyz*/// 4. 判断System.out.println(treeSet.contains("java"));  // trueSystem.out.println(treeSet.contains("php"));  // falseSystem.out.println(treeSet.isEmpty());  // false}
}

使用TreeSet保存数据

java">package com.collection.treeset;import com.collection.set.Person;
import java.util.Iterator;
import java.util.TreeSet;
/*** 使用TreeSet保存数据* 要求：*  元素必须要实现Comparable接口，compareTo();方法返回值为0，认为是重复元素*/
public class Demo02 {public static void main(String[] args) {// 创建集合TreeSet<Person> persons = new TreeSet<>();// 1. 添加元素Person p1 = new Person("java",18);Person p2 = new Person("php",19);Person p3 = new Person("c++",20);Person p4 = new Person("xyz",21);Person p5 = new Person("java",1970);persons.add(p1);persons.add(p2);persons.add(p3);persons.add(p4);persons.add(p5);System.out.println("元素个数：" + persons.size());  // 元素个数：5System.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}]// 2. 删除
//        persons.remove(p2);
//        persons.remove(new Person("xyz",21));
//        System.out.println("删除元素："+persons.size());   // 删除元素：3
//        System.out.println(persons.toString());  //  [Person{name='c++', age=20}, Person{name='java', age=18}, Person{name='java', age=1970}]// 3. 遍历// 3.1 使用增强forSystem.out.println("---------使用增强for--------");for (Person p: persons) {System.out.println(p);}/*---------使用增强for--------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}*/// 3.2 使用迭代器System.out.println("---------使用迭代器--------");Iterator<Person> it = persons.iterator();while (it.hasNext()){System.out.println(it.next());}/*---------使用迭代器--------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}*/// 4. 判断System.out.println(persons.contains(p1));  // trueSystem.out.println(persons.contains(new Person("javase",1970)));  // falseSystem.out.println(persons.isEmpty());  // false}
}引用了Person类，重写 compareTo(); 方法
// 先按姓名比，然后再按年龄比@Overridepublic int compareTo(Person o) {int n1 = this.getName().compareTo(o.getName());int n2 = this.age-o.getAge();return  n1==0?n2:n1;}

TreeSet集合的使用

java">package com.collection.treeset;import com.collection.set.Person;
import java.util.Comparator;
import java.util.TreeSet;
/*** TreeSet 集合的使用* Comparator ： 实现比较定制 （他是一个比较器）* Comparable ： 可比较的*/
public class Demo03 {// 创建集合public static void main(String[] args) {TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {  // new Comparator<Person>() 匿名内部类@Overridepublic int compare(Person o1, Person o2) {int n1 = o1.getAge() - o2.getAge();int n2 = o1.getName().compareTo(o2.getName());return n1 == 0 ? n2 : n1 ;}});Person p1 = new Person("java",24);Person p2 = new Person("php",26);Person p3 = new Person("c++",20);Person p4 = new Person("xyz",17);Person p5 = new Person("abc",17);persons.add(p1);persons.add(p2);persons.add(p3);persons.add(p4);persons.add(p5);System.out.println(persons);}
}结果：[Person{name='xyz', age=17}, Person{name='c++', age=20}, Person{name='java', age=24}, Person{name='php', age=26}]先比较的age，再比较name添加p5之后 ，age相同，比较name[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 接口实现定制比较

代码实现：

java">package com.collection.treeset;import java.util.Comparator;
import java.util.TreeSet;
/*** 案例：* 要求：使用TreeSet集合实现字符串按照长度进行排序* helloworld   zhangsan    lisi    xian    beijing   nanjing   haerbin* Comparator 接口实现定制比较*/
public class Demo04 {public static void main(String[] args) {// 创建集合 并指定比较规则TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {int n1 = o1.length() - o2.length();int n2 = o1.compareTo(o2);return n1 == 0 ? n2 : n1;}});// 添加数据treeSet.add("helloworld");treeSet.add("zhangsan");treeSet.add("lisi");treeSet.add("xian");treeSet.add("beijing");treeSet.add("nanjing");treeSet.add("haerbin");System.out.println(treeSet.toString());}
}结果：先比较长度，长度相同，则比较name[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集合

代码演示：

java">package com.collection.map;import java.util.HashMap;
import java.util.Map;
import java.util.Set;/*** Map 接口的使用* 特点：* 1. 存储 键值对 （一对一对的数据）* 2. 键 不能重复，值 可以重复* 3. 无序 没有下标*/
public class Demo01 {public static void main(String[] args) {// 创建 Map 集合Map<String,String> map = new HashMap<>();// 1. 添加元素map.put("cn" , "中国");map.put("uk" , "英国");map.put("usa" , "美国");map.put("cn" , "zhongguo");  // k 相同，覆盖掉 vSystem.out.println("元素个数：" + map.size());  // 元素个数：3System.out.println(map.toString());  // {usa=美国, uk=英国, cn=zhongguo}// 2. 删除// map.remove("usa","美国");// map.remove("usa");// System.out.println("删除："+map.size());  // 删除：2// System.out.println(map);  // {uk=英国, cn=zhongguo}// 3. 遍历// 3.1 使用 keySet();System.out.println("-----------keySet()---------");Set<String> keySet = map.keySet();for (String key:map.keySet()) {System.out.println(key+"-----"+map.get(key));}/*-----------keySet()---------usa-----美国uk-----英国cn-----zhongguo*/// 3.2 使用 entrySet();System.out.println("-----------entrySet()---------");Set<Map.Entry<String, String>> entries = map.entrySet();for (Map.Entry<String,String> entry:map.entrySet()) {System.out.println(entry.getKey()+"-----"+entry.getValue());}/*-----------entrySet()---------usa-----美国uk-----英国cn-----zhongguo*/// 4. 判断System.out.println(map.containsKey("cn"));  // trueSystem.out.println(map.containsValue("意大利"));  // false}
}

HashMap集合

在Java中，HashMap 是一个常用的数据结构，它实现了Map接口，允许我们通过键值对的形式存储和快速查找数据。HashMap的底层是基于哈希表（hash table）的实现，它的高效性和灵活性使其在各种编程场景中广受欢迎。

HashMap是Map接口的一个实现类（HashMap实现了Map的接口），它具有Map的特点。HashMap的底层是哈希表结构。

在 JDK 1.2版本中，线程不安全，运行效率快；允许用null 作为 key 或 value

下面是代码展示：

java">package com.collection.map;import java.util.HashMap;
import java.util.Map;
import java.util.Set;/*** HashMap集合的使用* 存储结构：哈希表（数组+链表+红黑树）* 使用key 可以hashcode和equals作为重复*/
public class Demo02 {public static void main(String[] args) {// 创建集合HashMap<Student, String> students= new HashMap<Student,String>();// 刚创建 hashMap之后没有添加元素  table = null   size = 0 目的：节省空间// 1. 添加元素Student s1 = new Student("小李", 00001);Student s2 = new Student("小王", 00002);Student s3 = new Student("小赵", 00003);Student s4 = new Student("小孙", 00004);students.put(s1,"北京");students.put(s2,"天津");students.put(s3,"南京");students.put(s4,"上海");// students.put(s4,"杭州");  // 不会新添加，会覆盖System.out.println("元素个数："+students.size());  // 元素个数：4System.out.println(students);  // {Student{name='小赵', stId=3}=南京, Student{name='小王', stId=2}=天津, Student{name='小李', stId=1}=北京, Student{name='小孙', stId=4}=杭州}// 2. 删除
//        students.remove(s1);
//        students.remove(new Student("小孙", 00004));
//        System.out.println("删除之后："+students.size());  // 删除之后：3
//        System.out.println(students);  // {Student{name='小赵', stId=3}=南京, Student{name='小王', stId=2}=天津, Student{name='小孙', stId=4}=上海}// 3. 遍历// 3.1 使用 keySet();System.out.println("-----------使用 keySet()---------------");Set<Student> keySet = students.keySet();for (Student s:keySet) {System.out.println(s+"----"+students.get(s));}/*-----------使用 keySet()---------------Student{name='小赵', stId=3}-----南京Student{name='小王', stId=2}-----天津Student{name='小李', stId=1}-----北京Student{name='小孙', stId=4}-----上海*/// 3.2 使用 entrySet();System.out.println("-----------使用entrySet()--------------");Set<Map.Entry<Student, String>> entries = students.entrySet();for (Map.Entry<Student, String> s :entries) {System.out.println(s.getKey()+"-----"+s.getValue());}/*-----------使用entrySet()--------------Student{name='小赵', stId=3}-----南京Student{name='小王', stId=2}-----天津Student{name='小李', stId=1}-----北京Student{name='小孙', stId=4}-----上海*/// 4. 判断System.out.println(students.containsKey(s1));  // trueSystem.out.println(students.containsKey(new Student("小赵", 00003)));  // trueSystem.out.println(students.containsValue("新疆"));  // falseSystem.out.println(students.isEmpty());  // false}
}

学生类：

java">package com.collection.map;import java.util.Objects;public class Student implements Comparable<Student>{private String name ;private int stId;public Student() {}public Student(String name, int stId) {this.name = name;this.stId = stId;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getStId() {return stId;}public void setStId(int stId) {this.stId = stId;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", stId=" + stId +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return stId == student.stId && Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, stId);}@Overridepublic int compareTo(Student o) {int n = this.stId - o.getStId();return n;}}

源码分析：

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

总结：

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

Hashtable与Properties

Hashtable :

JDK1.0版本，线程安全，运行效率慢，不允许null作为key或是value

Properties：

Hashtable 的子类，要求key和value都是String。通常用于配置文件的读取

TreeMap

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

代码演示：

java">package com.collection.map;import java.util.Map;
import java.util.TreeMap;/*** TreeMap 的使用* 存储结构： 红黑树*/
public class Demo03 {public static void main(String[] args) {// 新建集合 （也可以使用定制）TreeMap<Student, String> treeMap = new TreeMap<>();// 1. 添加元素Student s1 = new Student("小李", 00001);Student s2 = new Student("小王", 00002);Student s3 = new Student("小赵", 00003);Student s4 = new Student("小孙", 00004);treeMap.put(s1,"北京");treeMap.put(s2,"上海");treeMap.put(s3,"广州");treeMap.put(s4,"深圳");// treeMap.put(s3,"香港");  // 无法插入数据，但会把value值替换掉System.out.println("元素个数："+treeMap.size());  // 元素个数：4System.out.println(treeMap);  // {Student{name='小李', stId=1}=北京, Student{name='小王', stId=2}=上海, Student{name='小赵', stId=3}=香港, Student{name='小孙', stId=4}=深圳}// 2. 删除
//        treeMap.remove(s1);
//        treeMap.remove(new Student("小孙", 00004));
//        System.out.println("删除之后："+treeMap.size());  // 删除之后：2
//        System.out.println(treeMap);  // {Student{name='小王', stId=2}=上海, Student{name='小赵', stId=3}=广州}// 3. 遍历// 3.1 使用 keySet();System.out.println("-------使用 keySet()---------");for (Student key:treeMap.keySet()) {System.out.println(key+"-----"+treeMap.get(key));}/*-------使用 keySet()---------Student{name='小李', stId=1}-----北京Student{name='小王', stId=2}-----上海Student{name='小赵', stId=3}-----广州Student{name='小孙', stId=4}-----深圳*/// 3.2 使用 entrySet();System.out.println("-------使用 entrySet()---------");for (Map.Entry<Student, String> entry :treeMap.entrySet()) {System.out.println(entry.getKey()+"----"+entry.getValue());}/*-------使用 entrySet()---------Student{name='小李', stId=1}----北京Student{name='小王', stId=2}----上海Student{name='小赵', stId=3}----广州Student{name='小孙', stId=4}----深圳*/// 4. 判断System.out.println(treeMap.containsKey(s2));  // trueSystem.out.println(treeMap.containsKey(new Student("小王", 00002)));  // trueSystem.out.println(treeMap.containsValue("南京"));  // falseSystem.out.println(treeMap.isEmpty());  // false}
}

Collections工具类

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

方法：

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

代码演示：

java">package com.collection.map;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;/*** Collections工具类的使用*/
public class Demo04 {public static void main(String[] args) {List<Integer> list = new ArrayList<>();list.add(58);list.add(41);list.add(77);list.add(26);list.add(18);// sort 排序System.out.println("----------sort---------");System.out.println("排序之前："+list);  // 排序之前：[58, 41, 77, 26, 18]Collections.sort(list);System.out.println("排序之后："+list);  // 排序之后：[18, 26, 41, 58, 77]// binarySearch 二分查找System.out.println("--------binarySearch----------");int i = Collections.binarySearch(list,25);  // -2int i1 = Collections.binarySearch(list,58);  // 3System.out.println(i);System.out.println(i1);// copy 复制System.out.println("------copy------");List<Integer> dest = new ArrayList<>();for (int j = 0 ; j < list.size() ; j++){dest.add(0);}Collections.copy(dest,list);System.out.println(dest);  // [18, 26, 41, 58, 77]// reverse 反转System.out.println("-------reverse-------------");Collections.reverse(list);System.out.println("反转之后："+list);  // 反转之后：[77, 58, 41, 26, 18]// shuffle 打乱System.out.println("--------shuffle--------");Collections.shuffle(list);System.out.println("打乱之后："+list);  // 打乱之后：[41, 77, 58, 26, 18]// 补充：// list转数组System.out.println("--------list转数组-------");Integer[] arr = list.toArray(new Integer[2]);Integer[] arr1 = list.toArray(new Integer[10]);System.out.println(arr.length);  // 5System.out.println(Arrays.toString(arr));  // [77, 41, 58, 26, 18]System.out.println(Arrays.toString(arr1));  // [18, 41, 58, 26, 77, null, null, null, null, null]// 数组转集合System.out.println("---------数组转集合----------");String[] names = {"张三","李四","王五","赵六"};// 集合是一个受限集合，不能添加和删除List<String> list2 = Arrays.asList(names);// list2.add("小李");  UnsupportedOperationException// list2.remove(2);  UnsupportedOperationExceptionSystem.out.println(list2);  // [张三, 李四, 王五, 赵六]// 把基本类型数组转成集合时，需要修改为包装类型Integer[] nums = {100,200,300,400,500,600};List<Integer> list3 = Arrays.asList(nums);System.out.println(list3);  // [100, 200, 300, 400, 500, 600]}
}

集合总结

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