集合之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

package com.mpp.set;

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方法）

公告类的代码：

package com.mpp.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;

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等等

package com.mpp.set;

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类：

package com.mpp.set;

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类：

package com.mpp.set;

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类的代码修改如下：

package com.mpp.set;

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类代码不动：

package com.mpp.set;

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没找到");
        }

引入泛型(<Cat>)的概念后删除数据，代码如下：

package com.mpp.set;

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

1. Map的特点

（1）Map中的数据是以键值对的形式存储的

（2）k-v以Entry类型的对象实例存在

（3）可以通过key值快速地查找value

（4）一个映射不能包含重复的键

（5）每个键最多只能映射到一个值

2. HashMap的特点

（1）基于哈希表的Map接口的实现

（2）允许使用null值和null键

（3）key值不允许重复

（4）HashMap中的Entry对象是无序排列的

以下是通过例题演示常用方法的使用：

在HashMap中存储并操作字符串信息

例一需求：完成一个类似字典的功能

　　将单词以及单词的注释存储到HashMap中

　　显示HashMap中的内容

　　查找某个单词的注释并显示

package com.mpp.set;

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中的商品信息进行增删改查操作

商品信息类

属性：商品编号，名称，价格

方法：构造方法，获取和设置属性值的方法，其他方法

商品类：

package com.mpp.set;

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

}

商品信息类：

package com.mpp.set;

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++;
        }
        //比那里Map，输出商品信息
        System.out.println("商品的全部信息为：");
        Iterator<Goods> itGoods = goodsMap.values().iterator();
        while(itGoods.hasNext()){
            System.out.println(itGoods.next());
        }
    }
}