devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java集合 学习_50米体育课教学思维导图

作者：你好赵伟 | 2024-08-13 08:13:05

赞

踩

50米体育课教学思维导图

思维导图

在这里插入图片描述

导学

在现实生活中，我们一直在接触集合的概念，比如体育课上老师会喊集合！在数学中也会有着集合的概念。那么在Java中，集合是一个什么样的概念呢？
Java中的集合是工具类，可以存储任意数量的具有共同属性的对象
其实在某种程度上而言，集合和数组有着很大的相似之处。但为什么不使用数组，而用集合呢？这是因为数组的长度是固定的，而集合的长度可以动态变化。
用数组存储固定长度的数据，用集合存储动态变化的数据
所以，集合的应用场景有哪些呢：

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

集合框架体系

在这里插入图片描述

  • 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接口中方法：
在这里插入图片描述
实现类ArrayList中构造器及方法：
在这里插入图片描述

简单List集合应用

案例：利用List存储编程语言名称并输出
存储内容：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("C");
		list.add("C++");
		list.add("Go");
		list.add("Swift");
		//输出列表中元素的个数
		System.out.println("列表中元素的个数为：" + list.size());
		
		//遍历输出所有的集合元素
		System.out.println("*****************************");
		for(int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i) + ",");
		}
		
		//移除列表中的C++
		System.out.println("\n*****************************");
		//list.remove(2);
		list.remove("C++");
		System.out.println("移除列表中的C++元素后，集合元素为：");
		for(int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i) + ",");
		}
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

内存中，集合的存储和数组类似：
在这里插入图片描述

List集合案例

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

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

任务：

  • 创建公告类
    公告类属性：编号 id，标题 title，创建人 creater，创建时间createTime
    公告类方法：构造方法，对应get set方法
package com.ntdodoke.set;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class NoticeTest {

	public static void main(String[] args) {
		// 创建三条公告
		Notice no1 = new Notice(1, "欢迎来到渡课学习Java", "管理员", new Date());
		Notice no2 = new Notice(2, "请同学按时提交作业", "老师", new Date());
		Notice no3 = new Notice(3, "考勤通知", "班主任", new Date());

		// 添加公告
		List list = new ArrayList();
		list.add(no1);
		list.add(no2);
		list.add(no3);

		// 显示公告
		System.out.println("公告的内容为：");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
		}

		System.out.println("******************************");
		// 在第一条公告后面添加一条新公告
		Notice no4 = new Notice(4, "线上学习可以进行啦", "管理员", new Date());
		list.add(1, no4);
		// 显示公告
		System.out.println("公告的内容为：");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
		}

		System.out.println("******************************");
		// 删除按时完成作业公告
		list.remove(2);
		// 显示公告
		System.out.println("删除后公告的内容为：");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
		}

		System.out.println("******************************");
		// 将线上学习可以进行啦改为Java线上学习可以开始啦
		// 修改第二条公告中的title的值
		no4.setTitle("Java线上学习可以开始啦");
		list.set(1, no4);// 使用新对象替换对应索引的旧对象
		// 显示公告
		System.out.println("修改后公告的内容为：");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
		}
	}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58

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中不出现重复值。

package com.ntdodoke.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class WordDemo {
	public static void main(String[] args) {
		// 将单词添加到集合中
		Set set = new HashSet();
		set.add("blue");
		set.add("red");
		set.add("black");
		set.add("yellow");
		set.add("white");
		// 显示集合的内容
		System.out.println("集合中的元素为：");
		// 在Set集合中没有取元素的方法
		// 获取迭代器接口
		Iterator it = set.iterator();
		// 遍历迭代器并输出元素
		while (it.hasNext()) {
			System.out.print(it.next() + " ");
		}
		// 在集合中插入新的单词
		set.add("green");
		set.add("green");// 没有报错
		System.out.println("\n插入重复元素后的输出结果为：");
		it = set.iterator();
		// 遍历迭代器并输出元素
		while (it.hasNext()) {
			//向HashSet()中插入重复元素不会报错，因为系统并不会把重复元素插入到集合中.
			System.out.print(it.next() + " ");
		}
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

Set接口、HashSet类中都没有显示元素的get方法，要想显示元素：
1、Iterator(迭代器)：Iterator接口可以以统一的方式对各种集合元素进行遍历,
2、hasNext()方法检测集合中是否还有下一关元素，它的返回值是boolean类型。
3、next()方法返回集合中的下一个元素，返回Object类型的对象。
在这里插入图片描述
换言之，元素存贮在迭代器中，再通过遍历迭代器来遍历存贮在迭代器中的元素，然后通过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：

package com.ntdodoke.set;

public class Cat {
	private String name;
	
	private int month;
	
	private String species;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public String getSpecies() {
		return species;
	}

	public void setSpecies(String species) {
		this.species = species;
	}

	public Cat(String name, int month, String species) {
		super();
		this.name = name;
		this.month = month;
		this.species = species;
	}

	public Cat() {
		super();
	}

	@Override
	public String toString() {
		return "Cat [姓名=" + name + ", 月份=" + month + ", 品种=" + species + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + month;
		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) {
			return true;
		}
			
		if (obj.getClass() == Cat.class) {
			Cat cat = (Cat)obj;
			return cat.getName().equals(this.getName()) && (cat.getMonth() == this.getMonth()) && cat.getSpecies().equals(this.getSpecies());
		} else {
			return false;
		}
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
package com.ntdodoke.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class CatTest {

	public static void main(String[] args) {
		// 定义宠物猫对象
		Cat huahua = new Cat("花花", 12, "英短");
		Cat fanfan = new Cat("凡凡", 3, "中华田园猫");
		// 将对象放入HashSet
		Set<Cat> set = new HashSet<Cat>();
		set.add(huahua);
		set.add(fanfan);
		// 显示元素信息
		Iterator<Cat> it = set.iterator();
		while (it.hasNext()) {
			// System.out.println(((Cat)(it.next())).getName());
			System.out.println(it.next());
		}

		// 再添加一个与花花属性一致的猫
		Cat huahua2 = new Cat("花花", 12, "英短");
		set.add(huahua2);
		System.out.println("*****************************");
		System.out.println("添加重复数据后集合的元素为：");// 如果没有重写hashCode和equals方法，会怎样
		it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}

		// 重新插入一个新的宠物猫信息
		Cat huahua3 = new Cat("花花2代", 2, "英短");
		set.add(huahua3);
		System.out.println("添加花花二代后的集合元素为：");
		it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}

		// 在集合中查找花花的信息，并输出
		System.out.println("*****************************");
		if(set.contains(huahua)) {
			System.out.println("花花找到了");
			System.out.println(huahua);
		} else {
			System.out.println("花花没找到");
		}
		
		// 使用名字查找
		System.out.println("*****************************");
		System.out.println("通过名字查找");
		boolean flag = false;
		Cat c = null;
		it = set.iterator();
		while(it.hasNext()) {
			c = (Cat) it.next();
			if (c.getName().equals("花花")) {
				flag = true;// 找到了
				break;
			}
		}
		if(flag) {
			System.out.println("花花找到了");
			System.out.println(c);
		} else {
			System.out.println("花花没找到");
		}
		/**
		 * 查找元素
		 * 1、直接通过对象查找，使用contains方法
		 * 2、通过属性查找，遍历集合中所有对象，并使用get方法结合equals方法来寻找符合条件的对象
		 * 注意每次重新使用迭代器都需重置迭代器，否则迭代器会一直指向末尾
		 */
		
		//删除花花二代的信息，并重新输出
		for(Cat cat : set) {
			if("花花2代".equals(cat.getName())) {
				set.remove(cat);
			}
		}
		System.out.println("**************************");
		System.out.println("删除花花二代后的数据为：");
		for(Cat cat : set) {
			System.out.println(cat);
		}
		
		//删除集合中的所有宠物猫信息
		System.out.println("删除所有集合后的信息：");
		boolean flag2 = set.removeAll(set);
		if(set.isEmpty()){
			System.out.println("都被删除了");
		} else {
			System.out.println("猫还在");
		}
		
		//如果不删除花花二代，而是删除花花呢？
		set.add(huahua);
		set.add(fanfan);
		set.add(huahua3);
		/*for(Cat cat : set) {
			if("花花".equals(cat.getName())) {
				set.remove(cat);
				//break;
			}
		}
		System.out.println("**************************");
		System.out.println("删除花花二代后的数据为：");
		for(Cat cat : set) {
			System.out.println(cat);
		}*/
		it = set.iterator();
		while(it.hasNext()) {
			Cat cat = it.next();
			if("花花".equals(cat.getName())) {
				it.remove();//利用迭代器删除
			}
		}
		System.out.println("**************************");
		System.out.println("删除花花后的数据为：");
		for(Cat cat : set) {
			System.out.println(cat);
		}
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127

总结：

  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中的内容
  • 查找某个单词的注释并显示
package com.ntdodoke.set;

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 DictionaryDemo {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();
		System.out.println("请输入三组单词对应的注释，并存放到HashMap中");
		Scanner sc = new Scanner(System.in);
		int i = 0;
		while (i < 3) {
			System.out.println("请输入key值（单词）：");
			String key = sc.next();
			System.out.println("请输入value值（注释）：");
			String value = sc.next();
			// 向map集合中添加元素
			map.put(key, value);
			i++;
		}

		// 打印输出value的值（直接使用迭代器）
		System.out.println("**********************************");
		System.out.println("使用迭代器输出所有的value");
		// 利用values()方法返回map中值的集合
		Iterator<String> it = map.values().iterator();
		while (it.hasNext()) {
			System.out.print(it.next() + " ");
		}

		System.out.println("\n**********************************");
		// 打印输出key和value的值
		// 通过entrySet()方法
		System.out.println("通过entrySet()方法得到key-value值");
		Set<Entry<String, String>> entrySet = map.entrySet();
		for (Entry<String, String> entry : entrySet) {
			System.out.print(entry.getKey() + "-");
			System.out.println(entry.getValue());
		}

		// 打印输出value的值（使用keySet()）
		System.out.println("**********************************");
		System.out.println("通过keySet()方法得到key值");
		Set<String> keySet =  map.keySet();
		for(String str : keySet) {
			System.out.print(str + "-");
			//利用get()获取集合中对应key的value值
			System.out.println(map.get(str));
		}
		
		System.out.println("**********************************");
		System.out.println("请输入要查找的单词：");
		//通过单词找到注释并输出
		//使用keySet()方法
		String searchKey = sc.next();
		//1. 取得keySet
		Set<String> keySet1 = map.keySet();
		//2. 遍历keySet
		for(String key:keySet1) {
			System.out.println(key);
			if(searchKey.equals(key)) {
			System.out.println("找到了！"+"键值对："+key+"-"+map.get(key));
				break;
			}
		}
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
Map集合案例

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

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

任务：

  • 属性：商品编号 id， 商品名称 name， 商品价格 price
  • 方法：构造方法、get/set方法、其他方法
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;

public class GoodsTest {
	public static void main(String[] args) {
		Scanner sc = 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 id = sc.next();
			//防止商品编号重复
			if(map.containsKey(id)) {
				System.out.println("该商品编号已经存在，请重新输入！");
				continue;
			}
			System.out.println("请输入商品名称");
			String name = sc.next();
			System.out.println("请输入商品价格");
			double price = 0;
			try {
				price = sc.nextDouble();
			}catch(InputMismatchException e) {
				System.out.println("商品价格格式不正确，请重新输入！");
				sc.next();
				i--;
				continue;
			}
			Goods goods = new Goods(id,name,price);
			map.put(id,goods);
			i++;
		}
		
		//遍历map，输出商品信息
		System.out.println("商品的全部信息为：");
		Iterator it = map.values().iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		//删除一条商品信息
		System.out.println("请输入售罄商品编号：");
		while(true) {
			String nid = sc.next();
			if(map.containsKey(nid)) {
				map.remove(nid);
				break;
			} else {
				System.out.println("不存在该商品编号，请重新输入！");
			}
		}
		System.out.println("清空售罄商品后的全部信息为：");
		it = map.values().iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/973946
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号