Java集合（完整版）

一给 · 7 天前

集合框架

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：

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 不满足条件返回false
return false;
}
}

复制代码

代码验证：

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()); // 元素个数：3
System.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 增强for
System.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)); // true
System.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之间的集合元素

下面是字符串案例：

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()); // 元素个数：3
System.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 使用增强for
System.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("苹果")); // true
System.out.println(list.isEmpty()); // false
// 5.获取位置
System.out.println(list.indexOf("苹果")); // 0
System.out.println(list.indexOf("华为")); // 2
}
}

复制代码

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

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()); // 元素个数：5
System.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]
}
}

复制代码

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

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()); // 元素个数：3
System.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))); // true
System.out.println(arrayList.contains(s2)); // true
System.out.println(arrayList.isEmpty()); // false
// 5. 查找
System.out.println(arrayList.indexOf(new Student("狂鼠",19))); // 2
System.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的克隆函数，便是将全部元素克隆到一个数组中。

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()); // 元素个数：3
System.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("葡萄")); // true
System.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比较适合恣意位置插入的场景

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()); // 元素个数：3
System.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("葡萄")); // true
System.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 防止范例转换异常，提高代码的安全性
下面是泛型类：

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;
}
}

复制代码

下面是泛型方法：

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

复制代码

下面是泛型接口：

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

复制代码

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

复制代码

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

复制代码

泛型测试：

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); // Java
Generic<Integer> generic1 = new Generic<>();
generic1.t = 18;
generic1.show(180); // 泛型作为方法的参数：180
Integer integer = generic1.getT();
System.out.println(integer); // 18
// 泛型接口
GenericService gs = new GenericServiceImpl();
gs.server("java"); // java
GenericService gs2 = new GenericServiceImpl2();
gs2.server(10086); // 10086
// 泛型方法
GenericMethod gm = new GenericMethod();
gm.show("java is best!"); // 泛型方法 java is best!
gm.show(10086); // 泛型方法 10086
gm.show(3.1415926); // 泛型方法 3.1415926
}
}

复制代码

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

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

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接口的利用：

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()); // 元素个数: 3
System.out.println(set.toString()); // [苹果, 华为, 小米] // 是无序的
// 2. 删除数据
// set.remove("华为");
// System.out.println(set); // [苹果, 小米]
// 3. 遍历 ⭐
// 3.1 使用增强for
System.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("苹果")); // true
System.out.println(set.isEmpty()); // false
}
}

复制代码

HashSet集合的利用 1 ：

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()); // 元素个数：5
System.out.println(hashSet.toString()); // [狂鼠, 源氏, 艾什, 小美, 闪光]
// 2. 删除
// hashSet.remove("源氏");
// System.out.println(hashSet.toString()); // [狂鼠, 艾什, 小美, 闪光]
// hashSet.clear();
// System.out.println(hashSet); // []
// 3. 遍历
// 3.1 使用增强for
System.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("死神")); // false
System.out.println(hashSet.contains("源氏")); // true
System.out.println(hashSet.isEmpty()); // false
}
}

复制代码

HashSet集合的利用 2 :

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()); // 元素个数：4
System.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 使用增强for
System.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))); // true
System.out.println(people.contains(p2)); // true
System.out.println(people.isEmpty()); // false
}
}

复制代码

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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
// 快捷键快速重写equals 和 hashCode 方法
@Override
public 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);
}
@Override
public 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的利用

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()); // 元素个数：4
System.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 使用增强for
System.out.println("---------使用增强for--------");
for (String s: treeSet) {
System.out.println(s);
}
/*
---------使用增强for--------
abc
c++
java
xyz
*/
// 3.2 使用迭代器
System.out.println("---------使用迭代器--------");
Iterator<String> it = treeSet.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
/*
---------使用迭代器--------
abc
c++
java
xyz
*/
// 4. 判断
System.out.println(treeSet.contains("java")); // true
System.out.println(treeSet.contains("php")); // false
System.out.println(treeSet.isEmpty()); // false
}
}

复制代码

利用TreeSet保存数据

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()); // 元素个数：5
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}]
// 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 使用增强for
System.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)); // true
System.out.println(persons.contains(new Person("javase",1970))); // false
System.out.println(persons.isEmpty()); // false
}
}
引用了Person类，重写 compareTo(); 方法
// 先按姓名比，然后再按年龄比
@Override
public int compareTo(Person o) {
int n1 = this.getName().compareTo(o.getName());
int n2 = this.age-o.getAge();
return n1==0?n2:n1;
}

复制代码

TreeSet集合的利用

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>() 匿名内部类
@Override
public 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 接口实现定制比较
代码实现：

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>() {
@Override
public 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集合

代码演示：

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 相同，覆盖掉 v
System.out.println("元素个数：" + map.size()); // 元素个数：3
System.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")); // true
System.out.println(map.containsValue("意大利")); // false
}
}

复制代码

HashMap集合

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

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()); // 元素个数：4
System.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)); // true
System.out.println(students.containsKey(new Student("小赵", 00003))); // true
System.out.println(students.containsValue("新疆")); // false
System.out.println(students.isEmpty()); // false
}
}

复制代码

学生类：

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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", stId=" + stId +
'}';
}
@Override
public 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);
}
@Override
public int hashCode() {
return Objects.hash(name, stId);
}
@Override
public int compareTo(Student o) {
int n = this.stId - o.getStId();
return n;
}
}

复制代码

源码分析：

源码分析:
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自动排序
代码演示：

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()); // 元素个数：4
System.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)); // true
System.out.println(treeMap.containsKey(new Student("小王", 00002))); // true
System.out.println(treeMap.containsValue("南京")); // false
System.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接口）

代码演示：

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); // -2
int i1 = Collections.binarySearch(list,58); // 3
System.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); // 5
System.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); UnsupportedOperationException
System.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
- 集合工具类，界说了除了存取以外的集合常用方法。

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

		自动登录	找回密码
密码			立即注册

Java集合（完整版）

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云