Java集合框架
目录
- 一、Java集合框架包含的内容
- 二、关于Collection与Map
- 三、关于List与Set的异同
-
- 1、关于List
-
- （一）、关于List的分支
- （二）、关于List的分支的ArrayList
- （三）、ArrayList实现add、 size、 get、 contains、 remove
- （四）、ArrayList拓展
- （五）、LinkedList的特殊方法
- （六）、LinkedList的部分方法代码实现
- （七）、ArrayList与LinkedList对比
- 2、关于Set
-
- （一）、Set的分支结构
- （二）、Set的分支结构之HashSet的特点
- （三）、Set接口方法说明
- （四）、HashSet接口的代码说明
- 四、关于Map
-
- 1、Map的分支结构
- 2、Map的简单介绍
- 3、HashMap类的特点
- 4、Map存储示意图
- 5、Map接口的常用方法（不是所有的方法）
- 6、HashMap方法的使用
- 五、Collections集合操作工具类
-
- 1、Collections简介及特性
- 2、Collections的常用方法（不是所有的方法）
- 3、Collections的方法使用
- 4、Collections中compareTo复写的使用
一、Java集合框架包含的内容
Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中
图示中List与Set继承于Collection，Map较为特殊Map是没有继承Collection接口的，Map提供key到value的映射
二、关于Collection与Map
List与Set继承于Collection接口
Collection
List
Set
ArrayList
LinkedList
HashSet
TreeSet
Map是没有继承Collection接口的
Map
HashMap
TreeMap
三、关于List与Set的异同
| 方法名 | 是否唯一 | 是否有序 |
|---|---|---|
| List | 不唯一 | 有序 |
| Set | 唯一 | 无序 |
| Collection | 不唯一 | 无序 |
List内存储图示（其内部有序，但是不需要保证是否为唯一的值）
如果有相同的序号的值写入，则直接覆盖
Set内存储图示（其内部无需，但是值唯一）
如果有相同的值存入，将会直接覆盖
1、关于List
（一）、关于List的分支
| 方法名 | 说 明 |
|---|---|
| boolean add(Object o) | 在列表的末尾顺序添加元素， 起始索引位置从0开始 |
| void add(int index,Object o) | 在指定的索引位置添加元素。 索引位置必须介于0和列表中元素个数之间 |
| int size() | 返回列表中的元素个数 |
| Object get(int index) | 返回指定索引位置处的元素。 取出的元素是Object类型， 使用前需要进行强制类型转换 |
| boolean contains(Object o) | 判断列表中是否存在指定元素 |
| boolean remove(Object o) | 从列表中删除元素 |
| Object remove(int index) | 从列表中删除指定位置元素， 起始索引位置从0开始 |
List
ArrayList
Linked
特性
优点
ArrayList
实现了长度可变的数组，在内存中分配连续的空间
遍历元素和随机访问元素的效率比较高
特性
优点
Linked
采用链表存储方式
插入、删除元素时效率比较高
（二）、关于List的分支的ArrayList
创建ArrayList的基本语法1（该方法存在弊端，使用其中数据时需要进行强制数据类型转换）
// 创建ArrayList对象
List a = new ArrayList();
// 向ArrayList对象中添加参数
a.add("树木");
// 强制转换数据，然后进行赋值
String s = (String)a;
创建ArrayList的基本语法2（该方法通过范型集合的方式，可以避免后期使用强制类型转换的问题）
// 创建ArrayList对象
List<String> a = new ArrayList<>();
// 向ArrayList对象中添加参数
a.add("树木");
// 直接赋值
String s = a;
（三）、ArrayList实现add、 size、 get、 contains、 remove
代码示例
类源码：
package com.bdqn.ready;
/**
* @authorDesc 收获源于是每一分的努力
* @author Jule_zhou
* @date 2022-08-05 17:15:16
* @version
* @description
*/
public class Pet {
/**
* 名字
*/
private String name;
/**
* 年龄
*/
private int age;
/**
* @description 有参构造
* @author Jule_zhou
* @date 2022-08-05 17:16:58
* @param name
* @param age
* @return {@link null}
*/
public Pet(String name, int age) {
this.name = name;
this.age = age;
}
/**
* @description 无参构造
* @author Jule_zhou
* @date 2022-08-05 17:17:09
* @param
* @return {@link null}
*/
public Pet() {
}
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;
}
}
测试类源码：
package com.bdqn.ready;
import java.util.ArrayList;
import java.util.List;
/**
* @authorDesc 收获源于是每一分的努力
* @author Jule_zhou
* @date 2022-08-05 17:17:39
* @version
* @description 测试类
*/
public class Test {
public static void main(String[] args) {
// 创建多个宠物
Pet pet1 = new Pet("小虎",5);
Pet pet2 = new Pet("小黄",7);
Pet pet3 = new Pet("小志",9);
Pet pet4 = new Pet("小黑",2);
// 创建ArrayList对象
List<Pet> petList = new ArrayList<>();
System.out.println("------------向ArrayList中添加值------------");
// 向ArrayList中添加值
petList.add(pet1);
petList.add(pet2);
petList.add(pet3);
petList.add(pet4);
// 查看添加结果
petList.forEach(pet -> System.out.println("宠物的名字：" + pet.getName() + "\t宠物的年龄：" + pet.getAge()));
// 输出结果
/*
宠物的名字：小虎 宠物的年龄：5
宠物的名字：小黄 宠物的年龄：7
宠物的名字：小志 宠物的年龄：9
宠物的名字：小黑 宠物的年龄：2
*/
System.out.println("------------根据索引位置添加值------------");
// 根据索引位置添加值
petList.add(2,pet4);
// 查看添加结果
petList.forEach(pet -> System.out.println("宠物的名字：" + pet.getName() + "\t宠物的年龄：" + pet.getAge()));
// 输出结果
/*
宠物的名字：小虎 宠物的年龄：5
宠物的名字：小黄 宠物的年龄：7
宠物的名字：小黑 宠物的年龄：2
宠物的名字：小志 宠物的年龄：9
宠物的名字：小黑 宠物的年龄：2
*/
System.out.println("------------返回列表中的元素个数------------");
// 返回列表中的元素个数
System.out.println("列表中的元素个数为：" + petList.size());
// 输出结果
/*
列表中的元素个数为：5
*/
System.out.println("------------判断列表中是否存在指定元素------------");
// 判断列表中是否存在指定元素
System.out.println("是否存在\"" + petList.get(1) + "\"这个元素：" + petList.contains(petList.get(1)));
// 输出结果
/*
是否存在"com.bdqn.ready.Pet@6d311334"这个元素：true
*/
System.out.println("------------从列表中删除元素------------");
// 从列表中删除元素(根据对象删除)
petList.remove(petList.get(1));
// 查看结果
petList.forEach(pet -> System.out.println("宠物的名字：" + pet.getName() + "\t宠物的年龄：" + pet.getAge()));
// 输出结果
/*
宠物的名字：小虎 宠物的年龄：5
宠物的名字：小黑 宠物的年龄：2
宠物的名字：小志 宠物的年龄：9
宠物的名字：小黑 宠物的年龄：2
*/
System.out.println("------------从列表中删除元素(根据索引位置删除)------------");
// 从列表中删除元素(根据索引位置删除)
petList.remove(1);
// 查看结果
petList.forEach(pet -> System.out.println("宠物的名字：" + pet.getName() + "\t宠物的年龄：" + pet.getAge()));
// 输出结果
/*
宠物的名字：小虎 宠物的年龄：5
宠物的名字：小志 宠物的年龄：9
宠物的名字：小黑 宠物的年龄：2
*/
}
}
（四）、ArrayList拓展
ArrayList的默认长度为10
（五）、LinkedList的特殊方法
| 方法名 | 说 明 |
|---|---|
| void addFirst(Object o) | 在列表的首部添加元素 |
| void addLast(Object o) | 在列表的末尾添加元素 |
| Object getFirst() | 返回列表中的第一个元素 |
| Object getLast() | 返回列表中的最后一个元素 |
| Object removeFirst() | 删除并返回列表中的第一个元素 |
| Object removeLast() | 删除并返回列表中的最后一个元素 |
（六）、LinkedList的部分方法代码实现
类源码
package com.bdqn.day11.practice3;
/**
* @authorDesc 收获源于是每一分的努力
* @author Jule_zhou
* @date 2022-08-04 15:42:07
* @version
* @description 新闻类
*/
public class News {
/**
* 新闻
*/
private String news;
public News(){}
public News(String news) {
this.news = news;
}
public String getNews() {
return news;
}
public void setNews(String news) {
this.news = news;
}
}
测试类源码
package com.bdqn.day11.practice3;
import java.util.LinkedList;
/**
* @authorDesc 收获源于是每一分的努力
* @author Jule_zhou
* @date 2022-08-04 15:42:27
* @version
* @description 测试类
*/
public class Test {
public static void main(String[] args) {
News news0 = new News("头条和末条新闻已添加");
News news2 = new News("华为麒麟最强芯片980问世");
News news3 = new News("看看上海怎样垃圾分类");
News news4 = new News("2019河南本科一批平行志愿正式开挡");
News news5 = new News("美国一意孤行要加中国关税");
System.out.println(news0.getNews());
System.out.println();
System.out.println("头条的新闻标题为：" + news2.getNews());
System.out.println("排在最后的新闻标题为：" + news5.getNews());
System.out.println();
// 创建LinkedList对象
LinkedList<News> newsList = new LinkedList<>();
// 向LinkedList对象中添加值
newsList.add(news2);
newsList.add(news3);
newsList.add(news4);
newsList.add(news5);
System.out.println("删除的头条新闻标题为：" + newsList.getFirst().getNews());
newsList.remove(newsList.getFirst());
System.out.println("删除的末条新闻标题为：" + newsList.getLast().getNews());
newsList.remove(newsList.getLast());
System.out.println("删除后剩余的新闻条数：" + newsList.size());
System.out.println();
System.out.println("遍历所有新闻标题：");
newsList.forEach(news -> System.out.println("新闻标题名称：" + news.getNews()));
}
}
输出结果：
头条和末条新闻已添加
头条的新闻标题为：华为麒麟最强芯片980问世
排在最后的新闻标题为：美国一意孤行要加中国关税
删除的头条新闻标题为：华为麒麟最强芯片980问世
删除的末条新闻标题为：美国一意孤行要加中国关税
删除后剩余的新闻条数：2
遍历所有新闻标题：
新闻标题名称：看看上海怎样垃圾分类
新闻标题名称：2019河南本科一批平行志愿正式开挡
（七）、ArrayList与LinkedList对比
| ArrayList | LinkedList | |
|---|---|---|
| 存储方式的区别 | ArrayList实现了长度可变的数组，在内存中分配连续的空间。 | LinkedList采用链表存储方式。 |
| 使用场合的区别 | ArrayList遍历元素和随机访问元素的效率比较高，插入、删除、修改操作频繁时性能低下。 | LinkedList插入、删除、修改元素时效率较高，查找效率较低。 |
2、关于Set
（一）、Set的分支结构
Set
HashSet
TreeSet
Set 接口存储一组唯一，无序的对象
（二）、Set的分支结构之HashSet的特点
- 集合内的元素是无序排列且不允许重复。
- HashSet集合的查找效率高。
- 允许集合元素值为null。
（三）、Set接口方法说明
| 方法名 | 说 明 |
|---|---|
| boolean add(Object o) | 如果Set中尚未包含指定元素o,则添加指定元素o |
| void clear() | 从Set中移除所有元素 |
| int size() | 返回Set中的元素个数 |
| boolean isEmpty() | 如果Set不包含任何元素，则返回true |
| boolean contains(Object o) | 如果Set包含指定元素o，则返回true |
| boolean remove(Object o) | 如果Set包含指定元素o，则将其移除。 |
（四）、HashSet接口的代码说明
// 1、创建四个狗狗对象
Dog ououDog = new Dog("欧欧", "雪娜瑞");
Dog yayaDog = new Dog("亚亚", "拉布拉多");
Dog meimeiDog = new Dog("美美", "雪娜瑞");
Dog feifeiDog = new Dog("菲菲", "拉布拉多");
// 2、创建HashSet集合对象并把四个狗狗对象放入其中
Set dogs = new HashSet();
dogs.add(ououDog);
dogs.add(yayaDog);
dogs.add(meimeiDog);
dogs.add(feifeiDog);
// 3、输出集合中狗狗的数量
System.out.println("共计有" + dogs.size() + "条狗狗");
System.out.println("美美是否存在："+dogs.contains(meimeiDog));
dogs.remove(meimeiDog);
System.out.println("美美对象已经删除");
System.out.println("删除后，还有" + dogs.size() + "条狗狗");
System.out.println("集合是否为空：" + dogs.isEmpty());
四、关于Map
1、Map的分支结构
Map
HashSet
TreeSet
2、Map的简单介绍
Map接口存储一组键值对象，提供key到value的映射
Map接口常用的实现类HashMap
3、HashMap类的特点
- 不保证映射的顺序，特别是不保证顺序恒久不变（无序，且不为恒定）
- 数据添加到HashMap集合后，所有数据的数据类型将转换为Object类型，所以从其中获取数据时需要进行强制类型转换。（数据类型为Object，获取数据需要强转）
4、Map存储示意图
5、Map接口的常用方法（不是所有的方法）
| 方法名 | 说 明 |
|---|---|
| Object put(Object key, Object val) | 以“键-值对”的方式进行存储 |
| Object get (Object key) | 根据键返回相关联的值，如果不存在指定的键，返回null |
| Object remove (Object key) | 删除由指定的键映射的“键-值对” |
| int size() | 返回元素个数 |
| Set keySet () | 返回键的集合 |
| Collection values () | 返回值的集合 |
| boolean containsKey (Object key) | 如果存在由指定的键映射的“键-值对”，返回true |
6、HashMap方法的使用
package com.bdqn.day12.practice1;
/**
* @authorDesc 收获源于是每一分的努力
* @author Jule_zhou
* @date 2022-08-05 14:43:43
* @version
* @description 宠物类
*/
public class Pets {
/**
* 名字
*/
private String name;
/**
* 种类
*/
private String type;
public Pets() {
}
public Pets(String name, String type) {
this.name = name;
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
测试类
package com.bdqn.day12.practice1;
import java.util.HashMap;
import java.util.Map;
/**
* @authorDesc 收获源于是每一分的努力
* @author Jule_zhou
* @date 2022-08-05 14:43:54
* @version
* @description 测试类
*/
public class Test {
public static void main(String[] args) {
Pets pet1 = new Pets("欧欧","雪纳瑞");
Pets pet2 = new Pets("佩佩","藏獒");
Pets pet3 = new Pets("欢欢","二哈");
Pets pet4 = new Pets("豆豆","柴犬");
// 创建HashMap对象
Map<String,Pets> petsMap = new HashMap<>(16);
petsMap.put(pet1.getName(),pet1);
petsMap.put(pet2.getName(),pet2);
petsMap.put(pet3.getName(),pet3);
petsMap.put(pet4.getName(),pet4);
// 返回键的集合
System.out.println("Map中存在的Key：" + petsMap.keySet());
// 返回值的集合
System.out.println("Map中存在的value：" + petsMap.values());
System.out.println("循环遍历：");
petsMap.forEach((String name,Pets pet)-> System.out.println(name + "\t\t" + pet.getType()));
System.out.println("Map中存在指定对象，对象信息如下：");
// get(key)根据键返回相关联的值，如果不存在指定的键，返回null
System.out.println("欧欧\t\t" + petsMap.get("欧欧").getType());
}
}
五、Collections集合操作工具类
1、Collections简介及特性
- Collections类是Java提供的一个集合操作工具类。
- Collections类定义了一系列用于操作集合的静态方法，用于实现对集合元素的排序、查找和替换等操作。
- Collections和Collection是不同的，前者是集合的操作类，后者是集合接口
2、Collections的常用方法（不是所有的方法）
| 方法 | 作用 |
|---|---|
| sort() | 排序 |
| binarySearch() | 查找 |
| max()\min() | 查找最大\最小值 |
3、Collections的方法使用
实现一个类的对象之间比较大小，该类要实现Comparable
- 重写 public int compareTo(T o)方法。
- 如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
4、Collections中compareTo复写的使用
类文件
package com.bdqn.ready;
/**
* @authorDesc 收获源于是每一分的努力
* @author Jule_zhou
* @date 2022-08-05 17:15:16
* @version
* @description
*/
public class Pet implements Comparable {
/**
* 年龄
*/
private int age;
public Pet() {
}
public Pet(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
/**
* 复写
* @description
* @author Jule_zhou
* @date 2022-08-06 10:41:39
* @param o
* @return {@link int}
*/
@Override
public int compareTo(Object o) {
int i = (int) o;
if (i < this.age){
return -1;
} else if (i > this.age) {
return 1;
}
return 0;
}
}
测试类文件
package com.bdqn.ready;
/**
* @authorDesc 收获源于是每一分的努力
* @author Jule_zhou
* @date 2022-08-06 10:06:29
* @version
* @description
*/
public class Test extends Pet{
public static void main(String[] args) {
Pet pet1 = new Pet(1);
Pet pet2 = new Pet(5);
// 返回值为1
System.out.println(pet1.compareTo(pet2.getAge()));
}
}
运行结果
