导学

在现实生活中，我们一直在接触集合的概念，比如体育课上老师会喊集合！在数学中也会有着集合的概念。那么在Java中，集合是一个什么样的概念呢？

Java中的集合是工具类，可以存储任意数量的具有共同属性的对象

其实在某种程度上而言，集合和数组有着很大的相似之处。但为什么不使用数组，而用集合呢？这是因为数组的长度是固定的，而集合的长度可以动态变化。

用数组存储固定长度的数据，用集合存储动态变化的数据

所以，集合的应用场景有哪些呢：

  • 无法预测存储数据的数量(集合解决动态问题,数组解决静态问题)
  • 同时存储具有一对一关系的数据
  • 需要进行数据的增删改查

  • 解决数据重复问题

    集合框架体系

    4. 集合 - 图1

  • Collection：存储类的对象Collection有三个子接口，List(序列)、Queue(队列)、Set(集)

    • List：（序列） 有序的、允许重复的 主要实现类：ArrayList：长度动态增长的数组
    • Queue：（队列） 有序的、允许重复的 主要实现类：LinkedList：链表的内容
    • Set：（集）无序的、不允许重复的 主要实现类：HashSet：哈希集
  • Map：键值对内容什么是键值对：比如学生都有对应的学号，通过学号就可以指向某个具体的学生。
    • Map实现类HashMap(哈希表的意思，存储以键值对表示的形式)

      List集合

      List是元素有序并且可以重复的集合，称为序列。
      List可以精确地控制每个元素的插入位置，或删除某个位置的元素。
      List的两个主要实现类：ArrayList和LinkedList，本节课主要讲解ArrayList，这是因为ArrayList使用的比较多，而且ArrayList和LinkedList这两个实现类中的方法几乎都是相同的。
      ArrayList底层是由数组实现的，长度动态增长。ArrayList中的元素可以为null且可以有多个。在列表尾部插入或删除数据非常有效，但是在中间则需要进行大量的数组复制，耗费较多资源。所以更适合查找和更新元素。
      Collection接口和List接口中方法：
方法 作用
add(E e) 将元素添加到集合中
clear() 清空集合中的元素
contains(Object o) 判断集合中是否存在参数
isEmpty() 判断集合中是否存在元素
iterator() 迭代器方法，可用于集合遍历
remove(Object o) 移除集合中的某个元素
size() 返回集合中元素的数量
toArray() 用于将集合转变为数组
get(int index) 返回集合中指定位置处的元素
indexOf(Object o) 返回某个对象在集合中第一次出现的位置
sort(Comparator<? super E> c) 集合排序方法

实现类ArrayList中构造器及方法：

构造器和方法 作用
ArrayList() 创建初始容量为十的列表
ArrayList(Collection<? extends E) c) 利用一个已经存在的集合去创建集合
ArrayList(int length) 创建一个指定初始容量的列表
toArray() 将集合转变为数组

简单List集合应用

案例：利用List存储编程语言名称并输出
存储内容：Java,C,C++,Go,Swift

/
ArrayList
特点：有序 可重复
新增
- add(obj) 依次插入
- add(index,obj) 往指定索引位置插入
- addAll(collection) 合并两个list
- addAll(index,collection) 往指定索引位置插入list
查找
- contains(Object o) 是否包含元素
- indexOf(Object o) 获取元素索引
删除
- clear() 清空list
- remove(int index) 删除指定索引位置的元素
- remove(Object o) 删除指定元素
修改
- set(int index,E element) 替换指定位置元素
/

迭代器删除元素
Iterator it = list.iterator();
while(it.hasNext()) {
String next = it.next();
if(“element”.equals(next)) {
it.remove();
}
}

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. public class ListDemo1 {
  4.     public static void main(String[] args) {
  5.         //有序  可重复
  6.         /*
  7.         ArrayList
  8.         特点：有序  可重复
  9.         新增
  10.             - add(obj)                  依次插入
  11.             - add(index,obj)            往指定索引位置插入
  12.             - addAll(collection)        合并两个list
  13.             - addAll(index,collection)  往指定索引位置插入list
  14.         查找
  15.             - contains(Object o)        是否包含元素
  16.             - indexOf(Object o)         获取元素索引
  17.         删除
  18.             - clear()                   清空list
  19.             - remove(int index)         删除指定索引位置的元素
  20.             - remove(Object o)          删除指定元素
  21.         修改
  22.             - set(int index,E element)  替换指定位置元素
  23.         */
  24.         //<String>泛型，list里面只能存放String类型的数据
  25.         //List<String> list = new ArrayList<>();
  26.         List list = new ArrayList();
  27.         list.add("Java");
  28.         list.add("C");
  29.         list.add("C++");
  30.         list.add("Go");
  31.         list.add("Swift");
  32.         //输出列表中元素的个数
  33.         System.out.println("列表中元素的个数为：" + list.size());
  35.         //遍历输出所有的集合元素
  36.         System.out.println("*****************************");
  37.         for(int i = 0; i < list.size(); i++) {
  38.             System.out.print(list.get(i) + ",");
  39.         }
  41.         //移除列表中的C++
  42.         System.out.println("\n*****************************");
  43.         //list.remove(2);
  44.         list.remove("C++");
  45.         System.out.println("移除列表中的C++元素后，集合元素为：");
  46.         for(int i = 0; i < list.size(); i++) {
  47.             System.out.print(list.get(i) + ",");
  48.         }
  49.     }
  50. }

内存中，集合的存储和数组类似：
4. 集合 - 图2

List集合案例

案例：公告管理
需求：（增删改查）

  • 公告的添加与显示
  • 在指定位置处插入公告
  • 删除公告
  • 修改公告

任务：

  • 创建公告类
    • 公告类属性：编号 id，标题 title，创建人 creater，创建时间createTime
    • 公告类方法：构造方法，对应get set方法
      1. package com.ntdodoke.set;
      2. import java.util.ArrayList;
      3. import java.util.Date;
      4. import java.util.List;
      5. public class NoticeTest {
      6. public static void main(String[] args) {
      7.    // 创建三条公告
      8.    Notice no1 = new Notice(1, "欢迎来到渡课学习Java", "管理员", new Date());
      9.    Notice no2 = new Notice(2, "请同学按时提交作业", "老师", new Date());
      10.    Notice no3 = new Notice(3, "考勤通知", "班主任", new Date());
      11.    // 添加公告
      12.    List list = new ArrayList();
      13.    list.add(no1);
      14.    list.add(no2);
      15.    list.add(no3);
      16.    // 显示公告
      17.    System.out.println("公告的内容为：");
      18.    for (int i = 0; i < list.size(); i++) {
      19.        System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
      20.    }
      21.    System.out.println("******************************");
      22.    // 在第一条公告后面添加一条新公告
      23.    Notice no4 = new Notice(4, "线上学习可以进行啦", "管理员", new Date());
      24.    list.add(1, no4);
      25.    // 显示公告
      26.    System.out.println("公告的内容为：");
      27.    for (int i = 0; i < list.size(); i++) {
      28.        System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
      29.    }
      30.    System.out.println("******************************");
      31.    // 删除按时完成作业公告
      32.    list.remove(2);
      33.    // 显示公告
      34.    System.out.println("删除后公告的内容为：");
      35.    for (int i = 0; i < list.size(); i++) {
      36.        System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
      37.    }
      38.    System.out.println("******************************");
      39.    // 将线上学习可以进行啦改为Java线上学习可以开始啦
      40.    // 修改第二条公告中的title的值
      41.    no4.setTitle("Java线上学习可以开始啦");
      42.    list.set(1, no4);// 使用新对象替换对应索引的旧对象
      43.    // 显示公告
      44.    System.out.println("修改后公告的内容为：");
      45.    for (int i = 0; i < list.size(); i++) {
      46.        System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
      47.    }
      48. }
      49. }

      Set集合

      Set中元素无序且不可以重复，称为集。
      HashSet是Set的一个重要实现类，称为哈希集。HashSet中的元素无序且不可以重复，HashSet中只允许一个null元素。HashSet底层是HashMap实现。HashSet具有良好的存取和查找性能，所以适合存取和查找的情况。
      HashSet 类是按照哈希算法来存储集合中的元素，使用哈希算法可以提高集合元素的存储速度，当向 Set 集合中添加一个元素时，HashSet 会调用该元素的 hashCode() 方法，获取其哈希码，然后根据这个哈希码计算出该元素在集合中的存储位置。
      Set接口和其实现类中的方法与之前List集合比较类似，所以本节课，不再过多介绍，结合jdk学习。

      简单Set集合应用

      案例：利用HashSet存储多个表示颜色的英文单词，并输出。
      单词：bule，red，black，yellow，white
      说明：当调用add（Object）方法时候，首先会调用Object的hashCode方法判断hashCode是否已经存在，如不存在则直接插入元素；如果已存在则调用Object对象的equals()方法判断是否返回true，如果为true则说明元素已经存在，如为false则插入元素。
      HashSet是借助HashMap来实现的，利用HashMap中Key的唯一性，来保证HashSet中不出现重复值。

/
HashSet
特点：无序的 不可以有重复元素[最多只能有一个null]
新增
- add()
查找
- contains(Object o)
删除
- remove(Object o)
/

  1. package com.ntdodoke.set;
  2. import java.util.HashSet;
  3. import java.util.Iterator;
  4. import java.util.Set;
  5. public class WordDemo {
  6.     public static void main(String[] args) {
  7.         /*
  8.         HashSet
  9.         特点：无序的  不可以有重复元素[最多只能有一个null]
  10.         新增
  11.             - add()
  12.         查找
  13.             - contains(Object o)
  14.         删除
  15.             - remove(Object o)
  16.         修改
  17.         */
  18.         // 将单词添加到集合中
  19.         Set set = new HashSet();
  20.         set.add("blue");
  21.         set.add("red");
  22.         set.add("black");
  23.         set.add("yellow");
  24.         set.add("white");
  25.         // 显示集合的内容
  26.         System.out.println("集合中的元素为：");
  27.         // 在Set集合中没有取元素的方法
  28.         // 获取迭代器接口
  29.         Iterator it = set.iterator();
  30.         // 遍历迭代器并输出元素
  31.         while (it.hasNext()) {
  32.             System.out.print(it.next() + " ");
  33.         }
  34.         // 在集合中插入新的单词
  35.         set.add("green");
  36.         set.add("green");// 没有报错
  37.         System.out.println("\n插入重复元素后的输出结果为：");
  38.         it = set.iterator();
  39.         // 遍历迭代器并输出元素
  40.         while (it.hasNext()) {
  41.             //向HashSet()中插入重复元素不会报错，因为系统并不会把重复元素插入到集合中.
  42.             System.out.print(it.next() + " ");
  43.         }
  44.     }
  45. }

Set接口、HashSet类中都没有显示元素的get方法，要想显示元素：
1、Iterator(迭代器)：Iterator接口可以以统一的方式对各种集合元素进行遍历,
2、hasNext()方法检测集合中是否还有下一关元素，它的返回值是boolean类型。
3、next()方法返回集合中的下一个元素，返回Object类型的对象。
4. 集合 - 图3
换言之，元素存贮在迭代器中，再通过遍历迭代器来遍历存贮在迭代器中的元素，然后通过hasNext()判断迭代器中是否还有下一个元素，返回ture时再通过next()方法打印出集合中所有元素。

Set集合案例

案例：宠物猫信息管理
需求：（增删改查）

  • 添加和显示宠物猫的信息
  • 查找某只宠物猫的信息并输出
  • 修改宠物猫的信息
  • 删除宠物猫的信息

任务：宠物猫类

  • 属性：名字 name，月份 month，品种 species
  • 方法：构造方法，get set方法，其他方法

说明：
HashSet中，是无法添加相同的对象的。所以这里要注意，什么是相同的对象了。
问：用相同的属性对对象进行初始化，它们是相同的对象吗？如：
Cat cat1 = new Cat(“花花”, 12, “英国短毛猫”);
Cat cat2 = new Cat(“花花”, 12, “英国短毛猫”);
答：不是。
所以这样的两个对象，是可以加入的HashSet中的。这往往与我们的期望是不符的，我们认为他们应该是”相同的”，不应该重复加入。
程序是通过调用hashCode和equals两个方法来判断对象是否相等的。
所以，对于上面提到的问题，我们可以通过重写这两个方法来实现我们需求。
equals方法思路：1）先判断对象是否相等，相等返回true，不用继续比较属性；2）判断obj是否为目标类的对象，若是则通过强制类型转换为目标类对象后继续比较属性值是否相同；3）以上都不满足则返回false：

  1. package com.ntdodoke.set;
  2. public class Cat {
  3.     private String name;
  5.     private int month;
  7.     private String species;
  8.     public String getName() {
  9.         return name;
  10.     }
  11.     public void setName(String name) {
  12.         this.name = name;
  13.     }
  14.     public int getMonth() {
  15.         return month;
  16.     }
  17.     public void setMonth(int month) {
  18.         this.month = month;
  19.     }
  20.     public String getSpecies() {
  21.         return species;
  22.     }
  23.     public void setSpecies(String species) {
  24.         this.species = species;
  25.     }
  26.     public Cat(String name, int month, String species) {
  27.         super();
  28.         this.name = name;
  29.         this.month = month;
  30.         this.species = species;
  31.     }
  32.     public Cat() {
  33.         super();
  34.     }
  35.     @Override
  36.     public String toString() {
  37.         return "Cat [姓名=" + name + ", 月份=" + month + ", 品种=" + species + "]";
  38.     }
  39.     @Override
  40.     public int hashCode() {
  41.         final int prime = 31;
  42.         int result = 1;
  43.         result = prime * result + month;
  44.         result = prime * result + ((name == null) ? 0 : name.hashCode());
  45.         result = prime * result + ((species == null) ? 0 : species.hashCode());
  46.         return result;
  47.     }
  48.     @Override
  49.     public boolean equals(Object obj) {
  50.         if (this == obj) {
  51.             return true;
  52.         }
  54.         if (obj.getClass() == Cat.class) {
  55.             Cat cat = (Cat)obj;
  56.             return cat.getName().equals(this.getName()) && (cat.getMonth() == this.getMonth()) && cat.getSpecies().equals(this.getSpecies());
  57.         } else {
  58.             return false;
  59.         }
  60.     }
  61. }
  1. package com.ntdodoke.set;
  2. import java.util.HashSet;
  3. import java.util.Iterator;
  4. import java.util.Set;
  5. public class CatTest {
  6.     public static void main(String[] args) {
  7.         // 定义宠物猫对象
  8.         Cat huahua = new Cat("花花", 12, "英短");
  9.         Cat fanfan = new Cat("凡凡", 3, "中华田园猫");
  10.         // 将对象放入HashSet
  11.         Set<Cat> set = new HashSet<Cat>();
  12.         set.add(huahua);
  13.         set.add(fanfan);
  14.         // 显示元素信息
  15.         Iterator<Cat> it = set.iterator();
  16.         while (it.hasNext()) {
  17.             // System.out.println(((Cat)(it.next())).getName());
  18.             System.out.println(it.next());
  19.         }
  20.         // 再添加一个与花花属性一致的猫
  21.         Cat huahua2 = new Cat("花花", 12, "英短");
  22.         set.add(huahua2);
  23.         System.out.println("*****************************");
  24.         System.out.println("添加重复数据后集合的元素为：");// 如果没有重写hashCode和equals方法，会怎样
  25.         it = set.iterator();
  26.         while(it.hasNext()) {
  27.             System.out.println(it.next());
  28.         }
  29.         // 重新插入一个新的宠物猫信息
  30.         Cat huahua3 = new Cat("花花2代", 2, "英短");
  31.         set.add(huahua3);
  32.         System.out.println("添加花花二代后的集合元素为：");
  33.         it = set.iterator();
  34.         while(it.hasNext()) {
  35.             System.out.println(it.next());
  36.         }
  37.         // 在集合中查找花花的信息，并输出
  38.         System.out.println("*****************************");
  39.         if(set.contains(huahua)) {
  40.             System.out.println("花花找到了");
  41.             System.out.println(huahua);
  42.         } else {
  43.             System.out.println("花花没找到");
  44.         }
  46.         // 使用名字查找
  47.         System.out.println("*****************************");
  48.         System.out.println("通过名字查找");
  49.         boolean flag = false;
  50.         Cat c = null;
  51.         it = set.iterator();
  52.         while(it.hasNext()) {
  53.             c = (Cat) it.next();
  54.             if (c.getName().equals("花花")) {
  55.                 flag = true;// 找到了
  56.                 break;
  57.             }
  58.         }
  59.         if(flag) {
  60.             System.out.println("花花找到了");
  61.             System.out.println(c);
  62.         } else {
  63.             System.out.println("花花没找到");
  64.         }
  65.         /**
  66.          * 查找元素
  67.          * 1、直接通过对象查找，使用contains方法
  68.          * 2、通过属性查找，遍历集合中所有对象，并使用get方法结合equals方法来寻找符合条件的对象
  69.          * 注意每次重新使用迭代器都需重置迭代器，否则迭代器会一直指向末尾
  70.          */
  72.         //删除花花二代的信息，并重新输出
  73.         for(Cat cat : set) {
  74.             if("花花2代".equals(cat.getName())) {
  75.                 set.remove(cat);
  76.             }
  77.         }
  78.         System.out.println("**************************");
  79.         System.out.println("删除花花二代后的数据为：");
  80.         for(Cat cat : set) {
  81.             System.out.println(cat);
  82.         }
  84.         //删除集合中的所有宠物猫信息
  85.         System.out.println("删除所有集合后的信息：");
  86.         boolean flag2 = set.removeAll(set);
  87.         if(set.isEmpty()){
  88.             System.out.println("都被删除了");
  89.         } else {
  90.             System.out.println("猫还在");
  91.         }
  93.         //如果不删除花花二代，而是删除花花呢？
  94.         set.add(huahua);
  95.         set.add(fanfan);
  96.         set.add(huahua3);
  97.         /*for(Cat cat : set) {
  98.             if("花花".equals(cat.getName())) {
  99.                 set.remove(cat);
  100.                 //break;
  101.             }
  102.         }
  103.         System.out.println("**************************");
  104.         System.out.println("删除花花二代后的数据为：");
  105.         for(Cat cat : set) {
  106.             System.out.println(cat);
  107.         }*/
  108.         it = set.iterator();
  109.         while(it.hasNext()) {
  110.             Cat cat = it.next();
  111.             if("花花".equals(cat.getName())) {
  112.                 it.remove();//利用迭代器删除
  113.             }
  114.         }
  115.         System.out.println("**************************");
  116.         System.out.println("删除花花后的数据为：");
  117.         for(Cat cat : set) {
  118.             System.out.println(cat);
  119.         }
  120.     }
  121. }

总结：

  1. 泛型消除了安全隐患，不需要强制类型转换。另外使用泛型后，还可以使用增强型for循环来遍历集合。
  2. 集合（包括List，Set，Map）在读取数据的时候（通过循环遍历）删除数据要注意，如果删除数据后继续遍历了，则会报错，因为此时集合结构已经改变了。可以在删除指定的数据后马上break跳出遍历循环，就不会报错了。注意如果是删除的最后一个数据那么不会报错，因为不会再继续遍历了。
    注意以上情况是针对删除一条数据的情况，如果要删除多条数据，可以使用removeAll()方法。例如：
    有一个set集，想要删除其中2条满足情况的数据，可以先遍历这个set，在遍历的过程中，向新集set2中添加满足情况的数据。然后set.removeAll(set2); 就可以了。注意set.removeAll(set); 是删除set集自己中的所有元素。
  3. 集合中元素的删除主要还是依靠迭代器的remove()方法

    Map集合

    Map
  • Map中的数据是以键值对（key-value）的形式存储的；
  • key-value以Entry类型的对象实例存在；
  • 可以通过key值快速地查找value；
  • 一个映射不能包含重复的键；
  • 每个键最对只能映射到一个值。

HashMap实现类

  • 基于哈希表的Map接口的实现；
  • 允许使用null值和null键；
  • key值不允许重复；
  • HashMap中的Entry对象是无序排列的。

具体方法不在过多介绍，结合文档与案例了解

简单Map集合应用

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

  • 将单词以及单词的注释存储到HashMap中
  • 显示HashMap中的内容
  • 查找某个单词的注释并显示

/
HashMap
特点：键值对 所有key是一个set集合
entrySet()获取所有key集合 keySet() values()
新增
- put(K key,V value)
- putAll(Map<?extends K,? extends V> m)
查找
- containsKey(Object key)
- containsValue(Object value)
- get(Object key)
删除
- remove(Object key)
- remove(Object key,Object value)
修改
- replace(K key,V value)
/
/
Set keys = map.keySrt();//获取到map的所有key的集合
//获取map里面所有key的value值
//方法一
for(String key : keys){
System.out.print(map.get(key));
}
//方法二
Interator it = keys.iterator();
while(it.hasNext()){
String next = it.next();
System.out.print(map.get(next));
}
/

  1. package com.ntdodoke.set;
  2. import java.util.HashMap;
  3. import java.util.Iterator;
  4. import java.util.Map;
  5. import java.util.Map.Entry;
  6. import java.util.Scanner;
  7. import java.util.Set;
  8. public class DictionaryDemo {
  9.     public static void main(String[] args) {
  10.         /*
  11.            HashMap
  12.         特点：键值对 所有key是一个set集合
  13.         entrySet()获取所有key集合  keySet()  values()
  14.         新增
  15.             - put(K key,V value)                   
  16.             - putAll(Map<?extends K,? extends V> m)   
  17.         查找
  18.             - containsKey(Object key)        
  19.             - containsValue(Object value)        
  20.             - get(Object key)
  21.         删除
  22.             - remove(Object key)                    
  23.             - remove(Object key,Object value)       
  24.         修改
  25.             - replace(K key,V value)
  26.         */
  27.         /*
  28.         Set<String> keys = map.keySrt();//获取到map的所有key的集合
  29.         //获取map里面所有key的value值
  30.         //方法一
  31.         for(String key : keys){
  32.             System.out.print(map.get(key));
  33.         }
  34.         //方法二
  35.         Interator<String> it = keys.iterator();
  36.         while(it.hasNext()){
  37.             String next = it.next();
  38.             System.out.print(map.get(next));
  39.         }
  40.         */
  41.         Map<String, String> map = new HashMap<String, String>();
  42.         System.out.println("请输入三组单词对应的注释，并存放到HashMap中");
  43.         Scanner sc = new Scanner(System.in);
  44.         int i = 0;
  45.         while (i < 3) {
  46.             System.out.println("请输入key值（单词）：");
  47.             String key = sc.next();
  48.             System.out.println("请输入value值（注释）：");
  49.             String value = sc.next();
  50.             // 向map集合中添加元素
  51.             map.put(key, value);
  52.             i++;
  53.         }
  54.         // 打印输出value的值（直接使用迭代器）
  55.         System.out.println("**********************************");
  56.         System.out.println("使用迭代器输出所有的value");
  57.         // 利用values()方法返回map中值的集合
  58.         Iterator<String> it = map.values().iterator();
  59.         while (it.hasNext()) {
  60.             System.out.print(it.next() + " ");
  61.         }
  62.         System.out.println("\n**********************************");
  63.         // 打印输出key和value的值
  64.         // 通过entrySet()方法
  65.         System.out.println("通过entrySet()方法得到key-value值");
  66.         Set<Entry<String, String>> entrySet = map.entrySet();
  67.         for (Entry<String, String> entry : entrySet) {
  68.             System.out.print(entry.getKey() + "-");
  69.             System.out.println(entry.getValue());
  70.         }
  71.         // 打印输出value的值（使用keySet()）
  72.         System.out.println("**********************************");
  73.         System.out.println("通过keySet()方法得到key值");
  74.         Set<String> keySet =  map.keySet();
  75.         for(String str : keySet) {
  76.             System.out.print(str + "-");
  77.             //利用get()获取集合中对应key的value值
  78.             System.out.println(map.get(str));
  79.         }
  81.         System.out.println("**********************************");
  82.         System.out.println("请输入要查找的单词：");
  83.         //通过单词找到注释并输出
  84.         //使用keySet()方法
  85.         String searchKey = sc.next();
  86.         //1. 取得keySet
  87.         Set<String> keySet1 = map.keySet();
  88.         //2. 遍历keySet
  89.         for(String key:keySet1) {
  90.             System.out.println(key);
  91.             if(searchKey.equals(key)) {
  92.             System.out.println("找到了！"+"键值对："+key+"-"+map.get(key));
  93.                 break;
  94.             }
  95.         }
  96.     }
  97. }

Map集合案例

案例：商品信息管理
需求：

  • 使用HashMap对商品信息进行管理
    • 其中key为商品编号，value为商品对象
  • 对HashMap中的商品对象进行增，删，改，查操作

任务：

  • 属性：商品编号 id， 商品名称 name， 商品价格 price

  • 方法：构造方法、get/set方法、其他方法

    1. import java.util.HashMap;
    2. import java.util.InputMismatchException;
    3. import java.util.Iterator;
    4. import java.util.Map;
    5. import java.util.Scanner;
    6. public class GoodsTest {
    7.   public static void main(String[] args) {
    8.       Scanner sc = new Scanner(System.in);
    9.       //定义商品对象并保存到HashMap中
    10.       Map<String,Goods> map = new HashMap<String,Goods>();
    11.       System.out.println("请输入三条商品信息");
    12.       int i = 0;
    13.       while(i < 3) {
    14.           System.out.println("请输入第" + (i + 1) + "条商品信息");
    15.           System.out.println("请输入商品编号");
    16.           String id = sc.next();
    17.           //防止商品编号重复
    18.           if(map.containsKey(id)) {
    19.               System.out.println("该商品编号已经存在，请重新输入！");
    20.               continue;
    21.           }
    22.           System.out.println("请输入商品名称");
    23.           String name = sc.next();
    24.           System.out.println("请输入商品价格");
    25.           double price = 0;
    26.           try {
    27.               price = sc.nextDouble();
    28.           }catch(InputMismatchException e) {
    29.               System.out.println("商品价格格式不正确，请重新输入！");
    30.               sc.next();
    31.               i--;
    32.               continue;
    33.           }
    34.           Goods goods = new Goods(id,name,price);
    35.           map.put(id,goods);
    36.           i++;
    37.       }
    39.       //遍历map，输出商品信息
    40.       System.out.println("商品的全部信息为：");
    41.       Iterator it = map.values().iterator();
    42.       while(it.hasNext()) {
    43.           System.out.println(it.next());
    44.       }
    46.       //删除一条商品信息
    47.       System.out.println("请输入售罄商品编号：");
    48.       while(true) {
    49.           String nid = sc.next();
    50.           if(map.containsKey(nid)) {
    51.               map.remove(nid);
    52.               break;
    53.           } else {
    54.               System.out.println("不存在该商品编号，请重新输入！");
    55.           }
    56.       }
    57.       System.out.println("清空售罄商品后的全部信息为：");
    58.       it = map.values().iterator();
    59.       while(it.hasNext()) {
    60.           System.out.println(it.next());
    61.       }
    62.   }
    63. }