本文深入讲解Java集合框架，包括List、Set、Map等核心接口及其典型实现类的特点与应用场景，通过具体案例展示如何运用这些集合类解决实际问题。
什么是java集合？
java中的集合是工具类，可以存储任意数量的具有共同属性的对象
集合和数组的区别？
数组：存储固定长度的信息
集合：长度不固定，适用于数据动态变化的场景
集合应用场景：
- 无法预测数据存储的数量
- 同时存储具有一对一关系的数据
- 需要进行数据的增删
- 数据重复问题
集合框架的体系结构
List（列表 ）
- List是元素有序并且可以重复的集合，称为序列
- List可以精确的控制每个元素的插入位置，或删除某个位置的元素
- List的两个主要实现类是ArrayList和LinkedList
ArrayList概述
- -ArrayList底层是由数组实现的
- -动态增长，以满足应用程序的需求
- -在列表尾部插入或删除数据非常有效
- -更适合查找和更新元素
- -ArrayList中的元素可以为null
方法的简单案例1：
package com.demo.day8.list;
import java.util.ArrayList;
import java.util.List;
public class ListDemo1 {
public static void main(String[] args) {
// 用ArrayList存储编程语言的名称，并输出
List list=new ArrayList();
list.add("Java");
list.add("C");
list.add("C++");
list.add("Go");
list.add("Swift");
//输出列表中元素的个
System.out.println("列表中元素的个数为:"+list.size());
System.out.println("***********************");
//输出列表中的元素
System.out.println("列表中的元素为:");
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+",");
}
//移除列表中的++
list.remove(2);
//list.remove("C++");
System.out.println();
System.out.println("移除C++后的列表元素为:");
//增强for循环遍历序列
// for(Object str:list) {
// System.out.print(str+",");
// }
for(int i=0;i<list.size();i++){
System.out.print("第"+(i+1)+"个为"+list.get(i)+",");
}
}
}
输出：
列表中元素的个数为:5
***********************
列表中的元素为:
Java,C,C++,Go,Swift,
移除C++后的列表元素为:
第1个为Java,第2个为C,第3个为Go,第4个为Swift,
案例2：公告管理
需求：
- -公告的添加和显示
- -在指定位置处插入公告
- -删除公告
- -修改公告
公告属性：
- -编号id
- -标题title
- -创建人creator
- -创建时间creatTime
公告类方法：
- -构造方法
- -获取和设置属性的方法
Notice.java
package com.demo.day8.list;
import java.util.Date;
public class Notice {
/*
* 需求：
* -公告的添加和显示
* -在指定位置处插入公告
* -删除公告
* -修改公告
*/
/*
* 公告属性：
* -编号id
* -标题title
* -创建人creator
* -创建时间creatTime
* 公告类方法：
* -构造方法
* -获取和设置属性的方法
*/
private int id;
private String title;
private String creator;
private Date createTime;
//带参参构造函数
public Notice(int id,String title,String creator,Date createTime) {
this.setCreateTime(createTime);
this.setCreator(creator);
this.setId(id);
this.setTitle(title);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getCreator() {
return creator;
}
public void setCreator(String creator) {
this.creator = creator;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public static void main(String[] args) {
//
}
}
NoticeTest.java
package com.demo.day8.list;
import java.util.ArrayList;
import java.util.Date;
public class NoticeTest {
public static void main(String[] args) {
// 创建公告对象
Notice notice1=new Notice(1,"我是公告1","1",new Date());//取系统当前时间
Notice notice2=new Notice(2,"我是公告2","2",new Date());
Notice notice3=new Notice(3,"我是公告3","3",new Date());
ArrayList noticeList=new ArrayList();
//添加公告
noticeList.add(notice1);
noticeList.add(notice2);
noticeList.add(notice3);
//显示公告
System.out.println("这里是公告");
for(int i=0;i<noticeList.size();i++)
{ //强制类型转换成Notice用getTitle的方式显示标题
System.out.println((i+1)+"、"+((Notice)(noticeList.get(i))).getTitle());
}
System.out.println("=========指定添加========");
//在第一条公告后面添加新的一条公告
Notice notice4=new Notice(4,"我是公告4","4",new Date());
noticeList.add(1, notice4);
for(int i=0;i<noticeList.size();i++)
{ //强制类型转换成Notice用getTitle的方式显示标题
System.out.println((i+1)+"、"+((Notice)(noticeList.get(i))).getTitle());
}
System.out.println("=========删除=========");
//删除公告
noticeList.remove(2);
for(int i=0;i<noticeList.size();i++)
{ //强制类型转换成Notice用getTitle的方式显示标题
System.out.println((i+1)+"、"+((Notice)(noticeList.get(i))).getTitle());
}
System.out.println("=========修改=========");
notice4.setTitle("我是公告2");
noticeList.set(1, notice4);
for(int i=0;i<noticeList.size();i++)
{ //强制类型转换成Notice用getTitle的方式显示标题
System.out.println((i+1)+"、"+((Notice)(noticeList.get(i))).getTitle());
}
}
}
输出结果：
这里是公告
1、我是公告1
2、我是公告2
3、我是公告3
=========指定添加========
1、我是公告1
2、我是公告4
3、我是公告2
4、我是公告3
=========删除=========
1、我是公告1
2、我是公告4
3、我是公告3
=========修改=========
1、我是公告1
2、我是公告2
3、我是公告3
Set
set是元素无序并且不可以重复的集合，被称为集
HashSet
- HashSet是Set的一个重要实现类，称为哈希集
- HashSet的元素无序并且不可以重复
- HashSet中只允许一个null元素
- 具有良好的存取和查找性能
案例：用HashSet存储多个表示颜色额英文单词，并输出
- 单词包括：“blue”、“red”、“black”、“yellow”和“white”
Iterator(迭代器)
- Iterator接口可以统一的方式对各种集合元素进行遍历
- hasNext()方法检查集合中是否还有下一个元素
- next()方法返回集合中的下一个元素
WordDemo.java
package com.demo.day8.list;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class WordDemo {
public static void main(String[] args) {
// 将英文单词添加到HashSet中
//用Set的引用指向HashSet的对象
Set set=new HashSet();
//向集合添加元素
set.add("blue");
set.add("red");
set.add("black");
set.add("yellow");
set.add("white");
//显示集合的内容
System.out.println("显示集合内容");
//迭代器
Iterator it=set.iterator();
//遍历迭代器并输出元素 has.Next()检查集合中是否还有下一个元素
while(it.hasNext())
{
System.out.print(it.next()+"、");
}
System.out.println();
//在集合中插入一个新的单词
set.add("white");
it=set.iterator();
while(it.hasNext()) {
System.out.print(it.next()+"、");
}
//插入失败。但是不会报错
}
}
案例：宠物猫信息管理
需求：
- -添加和显示宠物猫的信息
- -查找某只宠物猫的信息并输出
- -修改宠物猫的信息
- -删除宠物猫的信息
属性：
- -名字name
- -年龄month
- -品种species
方法：
- -构造方法
- -获取和设置属性值的方法
- -其他方法
Cat.java
package com.demo.day8.list;
public class Cat {
// 宠物猫的案例
private String name;
private int age;
private String sex;
private String species;
public Cat() {
}
// Cat有参构造
public Cat(String name, int age, String sex, String species) {
this.setAge(age);
this.setSpecies(species);
this.setName(name);
this.setSex(sex);
}
public static void main(String[] args) {
}
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;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getSpecies() {
return species;
}
public void setSpecies(String species) {
this.species = species;
}
// 重写hashCode的方法和equals方法
//如果两个对象hashCode不相等，就是不相等
//如果两个对象hashCode相等，还要用equals还确定他们属性是否相等
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((sex == null) ? 0 : sex.hashCode());
result = prime * result + ((species == null) ? 0 : species.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj.getClass() == Cat.class) {
Cat cat = (Cat) obj;
return (cat.getAge()==age)&&cat.getName().equals(name) && cat.getSex().equals(sex) && cat.getSpecies().equals(species);
}
return false;
}
// 重写toString的方法
@Override
public String toString() {
return "Cat [姓名=" + name + ", 年龄=" + age + ", 性别=" + sex + ", 品种=" + species + "]";
}
}
CatTest.java
package com.demo.day8.list;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class CatTest {
public static void main(String[] args) {
System.out.println("===========添加和显示猫的信息===========");
// 添加和显示猫的信息
Cat one=new Cat("tutu",1,"男","中华田园猫");
Cat two=new Cat("huahua",2,"女","波斯猫");
Cat three=new Cat("niuniu",3,"女","本地猫");
Set<Cat> set=new HashSet<Cat>();
//添加信息
set.add(one);
set.add(two);
set.add(three);
//显示信息 迭代器 //<Cat>限制换型
Iterator<Cat> it=set.iterator();
while(it.hasNext()) {
System.out.println(it.next()+",");//重写toString显示字符串
}
System.out.println("===========添加重复的一只猫的信息===========");
Cat four=new Cat("niuniu",3,"女","本地猫");
set.add(four);
//显示信息 迭代器
//自定义类重写hashCode和equals方法
Iterator<Cat> it2=set.iterator();
while(it2.hasNext()) {
System.out.println(it2.next()+",");//重写toString显示字符串
}
System.out.println("===========查找的一只猫的信息并显示===========");
//通过该名字查找
boolean flag=false;
Cat c=null;
//放到迭代器中
it=set.iterator();
//遍历内容
while(it.hasNext()) {
c=(Cat)it.next();//强制转换
if(c.getName().equals("huahua")) {
flag=true;//找到了
break;
}
}
if(flag)
{ System.out.println("找到了");
System.out.println(c);//输出查到的结果
}
else
System.out.println("没找到");
System.out.println("===========删除的指定名字为huahua的猫的信息并重新显示===========");
//增强for循环
for(Cat cat:set) {
if("huahua".equals(cat.getName()))
set.remove(cat);break;
}
for(Cat cat:set) {
System.out.println(cat);
}
System.out.println("===========删除的指定某个范围猫的信息并重新显示===========");
//删除年龄小于3的
Set<Cat> set1=new HashSet<Cat>();
for(Cat cat:set) {
if(cat.getAge()<3)
{
set1.add(cat);//将查询到的装到一个新的序列对象中
}
}
set.removeAll(set1);//通过remove一个新的序列对象，来删除这一块
for(Cat cat:set) {
System.out.println(cat);
}
//
// System.out.println("===========删除的所有只猫的信息并重新显示===========");
// boolean flag1=set.removeAll(set);
// if(flag1)
// System.out.println("猫都不见了");
// else
// System.out.println("猫还在");
}
}
输出结果：
===========添加和显示猫的信息===========
Cat [姓名=tutu, 年龄=1, 性别=男, 品种=中华田园猫],
Cat [姓名=huahua, 年龄=2, 性别=女, 品种=波斯猫],
Cat [姓名=niuniu, 年龄=3, 性别=女, 品种=本地猫],
===========添加重复的一只猫的信息===========
Cat [姓名=tutu, 年龄=1, 性别=男, 品种=中华田园猫],
Cat [姓名=huahua, 年龄=2, 性别=女, 品种=波斯猫],
Cat [姓名=niuniu, 年龄=3, 性别=女, 品种=本地猫],
===========查找的一只猫的信息并显示===========
找到了
Cat [姓名=huahua, 年龄=2, 性别=女, 品种=波斯猫]
===========删除的指定名字为huahua的猫的信息并重新显示===========
Cat [姓名=tutu, 年龄=1, 性别=男, 品种=中华田园猫]
Cat [姓名=huahua, 年龄=2, 性别=女, 品种=波斯猫]
Cat [姓名=niuniu, 年龄=3, 性别=女, 品种=本地猫]
===========删除的指定某个范围猫的信息并重新显示===========
Cat [姓名=niuniu, 年龄=3, 性别=女, 品种=本地猫]
Map概述
- Map中的数据是以键值对(Key-value)的形式存储
- Key-value以Entry类型的对象实例存在
- 可以通过Key值快速地查找value
- 一个映射不能包含重复的键
- 每个键最多只能映射到一个值
HashMap
- 基于哈希表的Map接口的实现
- 允许使用null值和null键
- key值不允许重复
- HashMap中Entry的对象是无序排列的
增强for循环：
语法格式：
for(数据类型 变量名 :遍历的目标){ //数据类型 变量名:声明一个变量用来接收遍历目标遍历后的元素 }
HashMap案例：
/*完成一个类似字典功能
* 1、添加单词以及单词的注释存储在HashMap当中
* 2、显示HashMap中的内容
* 3、查找某个单词的注释并显示
*/
MapDemo.java
package com.demo.day8.list;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
public class MapDemo {
/*完成一个类似字典功能
* 1、添加单词以及单词的注释存储在HashMap当中
* 2、显示HashMap中的内容
* 3、查找某个单词的注释并显示
*/
public static void main(String[] args) {
// map引用指向HaspMap对象 Map<K,V> 泛值
Map<String,String> map=new HashMap<String,String>();
System.out.println("请输入三组单词对应的注释，并存放到HashMao中");
Scanner console=new Scanner(System.in);
//从键盘中输入值
//添加
int i=0;
while(i<3) {
System.out.println("请输入key值:");
String key=console.next();
System.out.println("请输入value值:");
String value=console.next();
map.put(key, value);//将键值存档map中
i++;
}
//打印输出value的值(直接使用迭代器)
Iterator<String> it=map.values().iterator();
while(it.hasNext()) {
System.out.print(it.next()+" ");
}
System.out.println();
System.out.println("=========================");
System.out.println("打印输出key-value的值 通过entrySet方法得到key-value");
//打印输出key-value的值 通过entrySet方法得到key-value
Set<Entry<String,String>> entrySet=map.entrySet();
for(Entry<String,String>entry:entrySet)
{
//entry.getValue();
//entry.getKey();
System.out.println(entry.getKey()+"-"+entry.getValue());
}
//通过单词找到注释并输出
System.out.println("请输入你要找的vaule对应的key！");
String strSearch=console.next();
boolean flag=false;
//使用KeySet()
//1取得keySet
Set<String> keySet=map.keySet();
//2遍历keySet
for(String key:keySet) {
if(strSearch.equals(key)) {
flag=true;
System.out.println("找到了!键值对为"+key+"-"+map.get(key));
break;
}
}
if(!flag)
System.out.println("找不到！");
}
}
输出结果:
请输入三组单词对应的注释，并存放到HashMao中
请输入key值:
a
请输入value值:
A
请输入key值:
b
请输入value值:
B
请输入key值:
c
请输入value值:
C
A B C
=========================
打印输出key-value的值 通过entrySet方法得到key-value
a-A
b-B
c-C
a
找到了!键值对为a-A
案例2：商品信息管理
/*
* 分析商品信息类
* 属性：
* -商品编号:id
* -商品名称:name
* -商品价格：price
* 方法：
* -构造方法
* -获取和设置属性值的方法
* -其他方法
*/
package com.demo.day8.list;
/*
* 分析商品信息类
* 属性：
* -商品编号:id
* -商品名称:name
* -商品价格：price
* 方法：
* -构造方法
* -获取和设置属性值的方法
* -其他方法
*/
public class Goods {
private String goodsId;
private String goodsName;
private double goodsPrice;
public Goods(String goodsId,String goodsName,double goodsPrice) {
this.setGoodsId(goodsId);
this.setGoodsName(goodsName);
this.setGoodsPrice(goodsPrice);
}
public String getGoodsId() {
return goodsId;
}
public void setGoodsId(String goodsId) {
this.goodsId = goodsId;
}
public String getGoodsName() {
return goodsName;
}
public void setGoodsName(String goodsName) {
this.goodsName = goodsName;
}
public double getGoodsPrice() {
return goodsPrice;
}
public void setGoodsPrice(double goodsPrice) {
this.goodsPrice = goodsPrice;
}
//toString方法
public String toString() {
String str="商品编号:"+goodsId+" "+"商品名称:"+goodsName+" "+"商品价格:"+goodsPrice;
return str;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
GoodsTest.java
package com.demo.day8.list;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
public class GoodsTest {
/*
* 使用HashMap对商品信息进行管理
* -其中key为商品编号，value为商品对象
* HashMap中的商品信息进行增、删、改、查
*/
public static void main(String[] args) {
Scanner console=new Scanner(System.in);
// 定义HashMap对象
Map<String,Goods> map=new HashMap<String,Goods>();
System.out.println("请输入三条商品信息:");
int i=0;
while(i<3) {
System.out.println("请输入第"+(i+1)+"条商品信息");
System.out.println("请输入商品的编号：");
String goodsId=console.next();
if(map.containsKey(goodsId)) {//如果编号已经存在
System.out.println("商品编号已经存在");
continue;//程序继续执行上一条
}
System.out.println("请输入商品的的名称：");
String goodsName=console.next();
try {//如果有需要错误的id，会处理这个异常，不影响程序正常运行
System.out.println("请输入商品的的价格：");
}catch(Exception e) {
System.out.println("商品价格输入格式错误");
console.next();
continue;
}
double goodsPrice=console.nextDouble();
Goods goods=new Goods(goodsId, goodsName, goodsPrice);
//将商品信息添加到HashMap中
map.put(goodsId,goods);
i++;
}
//遍历Map，输出商品信息
System.out.println("商品全部信息为:");
Iterator<Goods> it=map.values().iterator();
while(it.hasNext())
System.out.println(it.next());
}
}
输出：
请输入三条商品信息:
请输入第1条商品信息
请输入商品的编号：
1
请输入商品的的名称：
1
请输入商品的的价格：
1
请输入第2条商品信息
请输入商品的编号：
2
请输入商品的的名称：
2
请输入商品的的价格：
2
请输入第3条商品信息
请输入商品的编号：
3
请输入商品的的名称：
3
请输入商品的的价格：
3
商品全部信息为:
商品编号:1 商品名称:1 商品价格:1.0
商品编号:2 商品名称:2 商品价格:2.0
商品编号:3 商品名称:3 商品价格:3.0
扫一扫
830
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
