集合之ArrayList,HashSet,HashMap
结合框架的体系结构：
一、List（列表）
1. List的特点
（1）List是元素有序并且可以重复的集合，称为序列
（2）List可以精确的控制每个元素的插入位置，或删除某个位置的元素
（3）List的两个主要实现类是ArrayList和LinkList
2. ArrayList的特点
（1）ArrayList底层是由数组实现的
（2）动态增长，以满足应用程序的需求
（3）在列比饿哦尾部插入或删除数据非常有效
（4）更适合查找和更新元素
（5）ArrayList中的元素可以为null
以下是通过例题演示常用方法的使用：
在ArrayList中存储并操作字符串信息
例一需求：用ArrayList存储编程语言的名称并输出，名称报告Java，C,C++,Go,Swift
import java.util.ArrayList;
import java.util.List;
public class ListDemo1 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("java");
list.add("python");
list.add("c");
list.add("swift");
//输出list中的元素个数
System.out.println(list.size());
//遍历输出所有变成语言
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+" ");
}
System.out.println();
//移除Python
// list.remove(1); //根据indexof移除
list.remove("python"); //根据元素内容移除
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+" ");
}
}
}
在ArrayList中添加自定义的类的对象
例二需求：公告管理，公告的添加和显示，在指定位置处插入公告，删除公告，修改公告
公告类属性：编号id，标题title，创建人creator，创建时间createTime
公告类方法：构造方法，获取和设置属性值的方法（get/set方法）
import java.util.Date;
public class Notice {
//属性：id,title,crator,creatTime
private int id;
private String title;
private String creator;
private Date createTime;
public Notice(){} //无参构造
//带参构造
public Notice(int id,String title,String creator,Date createTime){
super();
this.id = id;
this.title = title;
this.creator = creator;
this.createTime = createTime;
}
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;
}
}
公告管理类的代码：package com.mpp.set;
import com.sun.tools.corba.se.idl.constExpr.Not;
import java.util.ArrayList;
import java.util.Date;
public class NoticeTest {
public static void main(String[] args) {
//创建notice的对象，生成三条公告
Notice no1 = new Notice(1,"hello word!","admin",new Date());
Notice no2 = new Notice(2,"交作业!","teacher",new Date());
Notice no3 = new Notice(3,"考勤通知","teacher",new Date());
//添加公告
ArrayList noList = new ArrayList();
noList.add(no1);
noList.add(no2);
noList.add(no3);
//显示公告
System.out.println("公告的内容为：");
for(int i=0;i<noList.size();i++){
Notice notice = (Notice)(noList.get(i));
System.out.println(i+1+"："+notice.getTitle());
}
System.out.println("************************");
//在第一条公告后面添加一条新公告
Notice no4 = new Notice(4,"在线编辑器可以使用了","admin",new Date());
noList.add(1,no4);
System.out.println("公告的内容为：");
for(int i=0;i<noList.size();i++){
Notice notice = (Notice)(noList.get(i));
System.out.println(i+1+"："+notice.getTitle());
}
System.out.println("************************");
//删除公告
noList.remove(2);
System.out.println("公告的内容为：");
for(int i=0;i<noList.size();i++){
Notice notice = (Notice)(noList.get(i));
System.out.println(i+1+"："+notice.getTitle());
}
System.out.println("************************");
//修改公告
no4.setTitle("修改title:python在线编译器可以使用了");
noList.set(1,no4); //我发现有没有这一行都不影响修改后的list的显示
System.out.println("公告的内容为：");
for(int i=0;i<noList.size();i++){
Notice notice = (Notice)(noList.get(i));
System.out.println(i+1+"："+notice.getTitle());
}
}
}
二、Set（集合）
1.Set的特点
（1）Set是元素无序并且不可以重复的集合， 被称为集
2.HashSet的特点
（1）HashSet是Set的一个重要实现类，称为哈希集
（2）HashSet中的元素无序并且不可以重复
（3）HashSet中只允许一个null元素
（4）具有良好的存取和查找性能
注意：在Set显示所有元素需要用到Iterator(迭代器）,迭代器有以下特点：
（1）Iterator接口可以以统一的方式对各种集合元素进行遍历
（2）hasNext()方法检测集合中是否还有下一个元素
（3）next()方法返回集合中的下一个元素
以下是通过例题演示常用方法的使用：
在HashSet中存储并操作字符串信息
例一需求：用HashSet存储多个标识颜色的英文单词，并输出，比如：blue,red,black，yellow等等
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class WordDemo {
public static void main(String[] args) {
//将英文档次添加到HashSet中
Set set = new HashSet();
//向集合中添加元素
set.add("red");
set.add("blue");
set.add("black");
set.add("yellow");
set.add("white");
//显示集合的内容
System.out.println("集合中的元素为：");
Iterator it = set.iterator(); //放进迭代器,使用迭代器遍历显示元素
//遍历迭代器并输出元素
while(it.hasNext()){
System.out.print(it.next()+ " ");
}
// set.add("green"); //set是无序的，所以插入就是增加
System.out.println();
set.add("red"); //set不允许插入重复元素，插入失败，但是不会报错
it = set.iterator();
System.out.println("插入重复元素后：");
while(it.hasNext()){
System.out.print(it.next()+ " ");
}
}
}
运行结果如下：
集合中的元素为：
red blue white black yellow
插入重复元素后：
red blue white black yellow
在HashSet中添加自定义的类的对象
例二需求：宠物猫信息管理
添加和显示宠物猫信息
查找某只宠物猫的信息并输出
修改宠物猫的信息
删除宠物猫的信息
宠物猫的属性：name,month,species
宠物猫的方法：构造方法，获取和设置属性值的方法（get/set)，其他方法
Cat类：
public class Cat {
private String name; //名字
private int mounth; //年龄
private String species;//品种
public Cat(String name,int mounth,String species){
super();
this.setName(name);
this.setMounth(mounth);
this.setSpecies(species);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMounth() {
return mounth;
}
public void setMounth(int mounth) {
this.mounth = mounth;
}
public String getSpecies() {
return species;
}
public void setSpecies(String species) {
this.species = species;
}
}
CatTest类：
import javax.swing.text.html.HTMLDocument;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class CatTest {
public static void main(String[] args) {
//定义宠物猫对象
Cat cafe = new Cat("cafe",12,"英短");
Cat milk = new Cat("milk",1,"蓝猫");
//将宠物猫对象放入HashSet中
Set set = new HashSet();
set.add(cafe);
set.add(milk);
//显示宠物猫的信息
Iterator it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果：
com.mpp.set.Cat@610455d6
com.mpp.set.Cat@511d50c0
这里显示的是对象再内存中的地址信息，因此我们需要在Cat类中重写toString方法
//toString方法重写
@Override
public String toString(){
return "[姓名："+name+"，年龄："+mounth+",品种："+species+"]";
}
再次运行结果：
[姓名：cafe，年龄：12,品种：英短]
[姓名：milk，年龄：1,品种：蓝猫]
添加重复的宠物猫数据
Cat类不变，CatTest类的代码修改如下：
import javax.swing.text.html.HTMLDocument;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class CatTest {
public static void main(String[] args) {
//定义宠物猫对象
Cat cafe = new Cat("cafe",12,"英短");
Cat milk = new Cat("milk",1,"蓝猫");
//将宠物猫对象放入HashSet中
Set set = new HashSet();
set.add(cafe);
set.add(milk);
//显示宠物猫的信息
Iterator it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//再添加一个与milk属性一样的猫
Cat milk01 = new Cat("milk",1,"蓝猫");
set.add(milk01);
System.out.println("添加重复数据，milk01:");
it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果：
[姓名：cafe，年龄：12,品种：英短]
[姓名：milk，年龄：1,品种：蓝猫]
添加重复数据，milk01:
[姓名：cafe，年龄：12,品种：英短]
[姓名：milk，年龄：1,品种：蓝猫]
[姓名：milk，年龄：1,品种：蓝猫]
这里的运行结果，添加重复的宠物猫信息添加成功了
再次修改Cat类的代码，重写hashCode和equals方法，CatTest类代码不动：
public class Cat {
private String name; //名字
private int mounth; //年龄
private String species;//品种
public Cat(String name,int mounth,String species){
super();
this.setName(name);
this.setMounth(mounth);
this.setSpecies(species);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMounth() {
return mounth;
}
public void setMounth(int mounth) {
this.mounth = mounth;
}
public String getSpecies() {
return species;
}
public void setSpecies(String species) {
this.species = species;
}
//toString方法重写
@Override
public String toString(){
return "[姓名："+name+"，年龄："+mounth+",品种："+species+"]";
}
@Override
public int hashCode(){
final int prime = 31;
int result = 1;
result = prime * result + mounth;
result = prime * result +((name == null)?0:name.hashCode());
result = prime * result +((species == null)?0:species.hashCode());
return result;
}
@Override
public boolean equals(Object obj){
if(this==obj){ //判断对象是都相等，相等则返回true,不用继续比较属性
return true;
}
if(obj.getClass()==Cat.class){ //判断obj是是不是Cat的对象
Cat cat = (Cat)obj;
return cat.getName().equals(name)&&(cat.getMounth()==mounth)&&(cat.getSpecies().equals(species));
}
return false;
}
}
运行结果：
[姓名：milk，年龄：1,品种：蓝猫]
[姓名：cafe，年龄：12,品种：英短]
添加重复数据，milk01:
[姓名：milk，年龄：1,品种：蓝猫]
[姓名：cafe，年龄：12,品种：英短]
查找宠物猫信息：
第一种：通过对象名查找
第二种：通过宠物猫的名字查找
在CatTest增加代码：
//重新插入一个新宠物猫
Cat cafe02 = new Cat("cafe2.0",2,"中华田园猫");
set.add(cafe02);
System.out.println("添加cafe2.0后的宠物猫信息");
it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//在集合中查找cafe的信息并输出，第一种方法:使用对象名去查找
if(set.contains(cafe)){
System.out.println("cafe找到了");
System.out.println(cafe);
}
else{
System.out.println("cafe没找到");
}
//通过宠物猫的名字查找,遍历set中的元素，取出name，和要查找的宠物名对比
System.out.println("通过宠物猫名字查找：");
boolean flag = false;
Cat c= null;
it = set.iterator();
while(it.hasNext()){
c = (Cat)(it.next());
if(c.getName().equals("cafe")){
flag = true;
break;
}
}
if(flag){
System.out.println("cafe找到了");
System.out.println(c);
}
else{
System.out.println("cafe没找到");
}
引入泛型()的概念后删除数据，代码如下：
import javax.swing.text.html.HTMLDocument;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class CatTest {
public static void main(String[] args) {
//定义宠物猫对象
Cat cafe = new Cat("cafe",12,"英短");
Cat milk = new Cat("milk",1,"蓝猫");
//将宠物猫对象放入HashSet中
Set<Cat> set = new HashSet<Cat>(); //<Cat>泛型，限制加入hashset中的元素都得是Cat类型
set.add(cafe);
set.add(milk);
//显示宠物猫的信息
Iterator<Cat> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//再添加一个与milk属性一样的猫
Cat milk01 = new Cat("milk",1,"蓝猫");
set.add(milk01);
System.out.println("添加重复数据，milk01:");
it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//重新插入一个新宠物猫
Cat cafe02 = new Cat("cafe2.0",2,"中华田园猫");
set.add(cafe02);
System.out.println("添加cafe2.0后的宠物猫信息");
it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//在集合中查找cafe的信息并输出，第一种方法:使用对象名去查找
if(set.contains(cafe)){
System.out.println("cafe找到了");
System.out.println(cafe);
}
else{
System.out.println("cafe没找到");
}
//通过宠物猫的名字查找,遍历set中的元素，取出name，和要查找的宠物名对比
System.out.println("通过宠物猫名字查找：");
boolean flag = false;
Cat c= null;
it = set.iterator();
while(it.hasNext()){
c = (it.next());
if(c.getName().equals("cafe")){
flag = true;
break;
}
}
if(flag){
System.out.println("cafe找到了");
System.out.println(c);
}
else{
System.out.println("cafe没找到");
}
//删除cafe02的信息并重新输出
for(Cat cat:set){
if("cafe2.0".equals(cat.getName())){
set.remove(cat);
}
}
System.out.println("删除cafe2.0后的数据：");
for(Cat cat:set){
System.out.println(cat);
}
//删除集合中的所有宠物猫信息
System.out.println("删除所有宠物猫信息");
boolean flag1 = set.removeAll(set);
if(set.isEmpty()){ //这里可以通过判断flag1是否为空和set.isEmpty()两种办法来判断是否删除完数据
System.out.println("猫都没了");
}
else{
System.out.println("猫还在---");
}
}
}
注意：set.remove(set) 这里的第二个set可以是set的一个子集
三、Map
- Map的特点
（1）Map中的数据是以键值对的形式存储的
（2）k-v以Entry类型的对象实例存在
（3）可以通过key值快速地查找value
（4）一个映射不能包含重复的键
（5）每个键最多只能映射到一个值
- HashMap的特点
（1）基于哈希表的Map接口的实现
（2）允许使用null值和null键
（3）key值不允许重复
（4）HashMap中的Entry对象是无序排列的
以下是通过例题演示常用方法的使用：
在HashMap中存储并操作字符串信息
例一需求：完成一个类似字典的功能
将单词以及单词的注释存储到HashMap中
显示HashMap中的内容
查找某个单词的注释并显示
import java.util.*;
public class DictionaryDemo {
public static void main(String[] args) {
//定义一个HashMap的对象
Map<String,String> animal = new HashMap<String,String>();
System.out.println("请输入三组单词对应的注释，并存放到HashMap中");
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();
animal.put(key,value);
i++;
}
//打印输出value的值（直接使用迭代器）
System.out.println("使用迭代器输出所有value：");
Iterator<String> it = animal.values().iterator();
while (it.hasNext()){
System.out.print(it.next()+" ");
}
System.out.println();
//打印输出key和value的值
//通过entrySet方法
System.out.println("通过entrySet得到k-v:");
Set<Map.Entry<String,String>> entrySet = animal.entrySet();
for(Map.Entry<String,String> entry:entrySet){
System.out.print(entry.getKey()+"-");
System.out.print(entry.getValue());
System.out.println();
}
//通过单词找到注释并输出
//使用keySet方法
System.out.println("请输入要查找的单词：");
String strSearch =console.next();
//1. 取到keySet
Set<String> keySet = animal.keySet();
//2.遍历keySet
for(String key:keySet){
if(strSearch.equals(key)){
System.out.println("找到了！键值对为："+key+animal.get(key));
break;
}
}
}
}
在HashMap中添加自定义的类的对象
例二需求：商品信息管理
使用HashMap对商品信息进行管理
其中key为商品编码，value为商品对象
对HashMap中的商品信息进行增删改查操作
商品信息类
属性：商品编号，名称，价格
方法：构造方法，获取和设置属性值的方法，其他方法
商品类：
public class Goods {
private String id;
private String name;
private double price;
public String getId() {
return id;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
public void setId(String id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setPrice(double price) {
this.price = price;
}
public Goods(String id,String name,double price){
this.id = id;
this.name = name;
this.price = price;
}
public String toString(){
return "商品编号："+id+",商品名称："+name+",商品价格："+price;
}
}
商品信息类：
import java.util.*;
public class GoodsTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//定义HashMap对象
Map<String,Goods> goodsMap = new HashMap<String,Goods>();
System.out.println("请输入三条商品信息：");
int i= 0;
while(i<3){
System.out.println("请输入第"+(i+1)+"条商品信息：");
System.out.println("请输入商品编号：");
String goodsId = sc.next();
//判断商品编号id是否已存在
if(goodsMap.containsKey(goodsId)){
System.out.println("商品编号已存在！请重新输入！");
continue;//结束当前循环，进入下一次循环
}
System.out.println("请输入商品名称：");
String goodsName = sc.next();
System.out.println("请输入商品价格：");
double goodsPrice = 0;
try{
goodsPrice = sc.nextDouble();
}
catch (InputMismatchException e){
System.out.println("商品价格的格式不正确，请输入数值型数据！");
sc.nextInt(); //如果没有这一句，出现异常时，这里输入的价格直接变成下一个输入的商品编号
continue;
}
Goods goods = new Goods(goodsId,goodsName,goodsPrice);
//将商品信息添加到HashMap中
goodsMap.put(goodsId,goods);
i++;
}
//输出商品信息
System.out.println("商品的全部信息为：");
Iterator<Goods> itGoods = goodsMap.values().iterator();
while(itGoods.hasNext()){
System.out.println(itGoods.next());
}
}
}
扫一扫
1115
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
