摘要
Java基础加强重温_06：
可变参数（可变参数格式）
集合工具类Collections类（为集合批量添加元素/打乱元素顺序/默认排序/自定义排序：Comparator接口）
冒泡排序（sort方法实现/手写for循环嵌套）
Map集合（HashMap类、LinkedHashMap类、添加键值/删除键值/根据键获得值/获取键集合/获得键值对集合/判断键存在）
Map集合遍历（键找值遍历/键值对遍历/forEach遍历）
Map案例（自定义类做key/统计字符出现次数/特有排序方式：TreeMap集合）
LinkedHashMap集合（有序的Map集合）
图书管理系统（未抽取代码版）
回顾泛型与集合
1、List集合
特点：有序、可重复、有下标
实现类：
a、ArrayList的底层是数组
b、LinkedList的底层是链表
2、Set集合
特点：无序、不可重复、无下标
实现类：
a、HashSet的底层是哈希表
b、LinkedHashSet的底层是哈希表+链表
3、数据结构
a、栈：先进后出 FILO
队列：先进先出 FIFO
b、数组：查询快，增删慢
c、链表：查询慢，增删快
d、树：二叉树/红黑树，查询、排序
e、哈希表：横坐标是数组，纵坐标是链表
根据一个对象的hashCode，按照某种策略取尾数找到数组对应的位置，
遍历链表，通过equals进行比较找到对应的元素
哈希表的扩容，哈希表的链表长度较长怎么办？
4、泛型
泛型类/接口：动态传入数据类型，泛型类创建对象的时候确定泛型的数据类型
泛型方法：根据传入的参数的数据类型，确定泛型的数据类型
一、可变参数
使得方法可以接收不定数量个参数
格式
方法(数据类型... 参数)
可变参数的使用:
1、使用方法的时候，传入任意个参数
2、使用方法的时候，传入一个数组
可变参数的底层原理：可变参数的本质是数组
可变参数注意事项
1、一个方法只能有一个可变参数
2、定义方法，除了可变参数还有其他参数时，可变参数必须放最后一位
理解：因为可变参数可以传入任意个参数，如果不放最后一位，意味着后面还可以添加同类型的参数，就无法确定哪个参数是最后一个。
可变参数案例
public class Demo02Varargs {
//传多少个定义多少个参数
public static void sum2(int n1,int n2) {
System.out.println(n1+n2);
}
//想接受n个，不定个数，用可变参数
//计算传入的n个数值的总和
public static void sum(int... arr) {
int sum = 0;
for (int i : arr) {
sum+=i;
}
System.out.println(sum);
}
// 可变参数，反编译后的代码，本质是数组
// public static void sum(int[] arr)
// {
// int sum = 0;
// for (int i : arr) {
// sum += i;
// }
// System.out.println(sum);
// }
public static void main(String... args) {
//传入一个数组。麻烦，因为还需要定义一个数组才传入
int[] arr = {1,2,3,1,6}; //13
sum(arr);
//直接把数组元素传入，想传几个传几个
sum2(1,2);
sum(1,2,3,1,6);
}
}
二、Collections类
Collections是操作Collection接口相关实现类的工具类。（多个s）
也就是操作集合的工具类（工具类都是静态方法）
Collections的API
public static <T> boolean addAll(Collection<? super T> c, T... elements)
为任何类型的集合批量添加元素
public static void shuffle(List<?> list)
打乱集合顺序。
public static <T> void sort(List<T> list)
将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> )
将集合中元素按照指定规则排序。
addAll方法可以把数组变成集合
Integer[] numbers = {1,2,3,1,6};
ArrayList<Integer> numberList = new ArrayList<>();
//往numberList集合中批量添加numbers数组元素
Collections.addAll(numberList,numbers);
Comparator接口（比较器）
Comparator是一个接口，Collections使用Comparator比较器进行排序。
Collections类的sort方法按照默认的自然顺序进行了排列
如果想要指定顺序就要重写Comparator接口中的compare方法
//compare方法
public int compare(Plane o1, Plane o2) {
return o1-o2;
}
compare顺序逆序原理（大小，小大）：相邻2个元素执行减法，如果是负数（正数），两个元素调换位置
重写Comparator接口compare方法
匿名内部类实现Comparator接口，重写compare方法
案例1–自定义比较器排序
public class Demo02CollectionsSort {
public static void main(String[] args) {
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
//每2个元素执行减法，如果是负数，就需要调序
public int compare(Integer o1, Integer o2) {
return -(o1-o2);
}
};
List<Integer> intList = new ArrayList<>();
Collections.addAll(intList, 1,0,0,8,6);
Collections.sort(intList,comparator);
System.out.println(intList);
//如果是对象呢？
}
}
案例2–Collections的API
public class Demo01Collections {
public static void main(String[] args) {
//public static <T> boolean addAll(Collection<? super T> c, T... elements):
//为任何类型的集合批量添加元素
List<String> list = new ArrayList<>();
Collections.addAll(list, "1、东风17","2、东风41","3、巨浪2");
System.out.println(list);
//public static void shuffle(List<?> list)
//打乱集合顺序。
Collections.shuffle(list);
System.out.println("打乱后:"+list);
//public static <T> void sort(List<T> list)
//将集合中元素按照默认规则排序。
Collections.sort(list);
System.out.println("排序后:"+list); //默认情况下是顺序，如果想逆序就要自定义规则
//String的排序 根据编码排序， 每一个char都对应一个编码
List<Integer> intList = new ArrayList<>();
Collections.addAll(intList, 1,0,0,8,6);
Collections.sort(intList);
System.out.println(intList); //默认按照 从小到大排序
System.out.println("————————————————————————————————————————————————————");
List<Plane> planes = new ArrayList<>();
Collections.addAll(planes,
new Plane(10,"歼10"),
new Plane(15, "歼15"),
new Plane(16,"歼16"),
new Plane(20, "歼20"));
//重写Comparator比较器的compare方法，自定义比较规则
Comparator<Plane> planeComparator = new Comparator<Plane>() {
@Override
public int compare(Plane o1, Plane o2) {
return o1.id-o2.id;
}
};
Collections.shuffle(planes);
System.out.println("排序前："+planes);
Collections.sort(planes,planeComparator);
System.out.println("排序后："+planes);
}
}
三、排序算法
我们会使用数组来存储多个数据，有时候我们要将数组中的元素进行排序。比如原始数组为{5, 1, 3, 2}，排序后为{1, 2, 3, 5}。常见排序算法有：选择排序，冒泡排序，快速排序等。
冒泡排序(简单直观，效率一般)
快速排序(最快的，分而治之)
选择排序，堆排序，插入排序…
冒泡排序
原理：相邻元素比较，大的往后放。
作用：使用最基础的语法对数组进行排序
核心：每次找到最大/最小值放到数组最后面
冒泡排序的算法步骤
- 1、外循环控制遍历次数
- 2、内循环比较每两个元素大小
冒泡排序案例
public class Demo03BubbleSort {
public static void main(String[] args) {
//排数组（使用sort()）
//可以把数组变成List集合，再用集合sort方法排序
Integer[] numbers = {1,2,3,1,6};
ArrayList<Integer> numberList = new ArrayList<>();
Collections.addAll(numberList,numbers);
//排数组（手写for循环）
//手动写一个排序算法，用基础班的知识
Integer[] numbersArr = {1,2,3,1,6,4};
//1、外循环控制遍历次数
for(int i=0;i<numbersArr.length-1;i++) {
//2、内循环比较每两个元素大小
for(int j=0;j<numbersArr.length-1-i;j++) {
int prev = numbersArr[j];
int next = numbersArr[j+1];
//交换perv<=next j 和 j+1的位置
if(prev<=next) {
//核心
numbers[j] = next;
numbers[j+1] = prev;
}
}
}
System.out.println(Arrays.toString(numbersArr));
//思考题：如果想从小到大排列。冒泡排序反过来，大的往前面放
}
}
比较流程
四、Set、Map、List三种集合的差别
集合类型主要有3种：set(集）、list(列表）和map(映射)。
单列集合
- 有序List
- 无序Set
双列集合
- 无序HashMap
- 有序LinkeHashMap
- 排序TreeMap（专门用来排序的Map集合）
Set、Map、List三种集合的差别
https://blog.csdn.net/lmarster/article/details/90672794
五、Map集合
现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。
Map是一种存储双列的数据接口，一列叫key，一列叫value。存储的格式是 key=value的方式存储的
Map集合：用于存储键值对的集合。
像这样存储数据：apple=苹果，左边称为key/键，右边称为value/值
Map的常用子类
HashMap<K,V>
HashMap存储数据采用的哈希表结构，元素的存取顺序不能保证一致。
由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
LinkedHashMap<K,V>
HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。
通过链表结构可以保证元素的存取顺序一致；
通过哈希表结构可以保证的键的唯一、不重复。
需要重写键的hashCode()方法、equals()方法。
Map集合的常用方法
- public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
-
- public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
-
- public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
-
- public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
-
- public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
-
- public boolean containKey(Object key):判断该集合中是否有此键。
Map集合与List、Set集合的区别
Collection集合（List、Set）：单列集合
Map集合：双列集合
- Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
- Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
- Collection中的集合称为单列集合，Map中的集合称为双列集合。
- 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
Map集合的特点
1、key（键）是唯一，不能重复，如果重复，后面的会覆盖前面的值
2、key（键）可以是null
3、value（值）可以任意值（可以重复）
4、map的特性(如排序…)由key决定
HashMap和HashSet的关系
- HashSet的底层是HashMap，HashMap存储数据的结构是哈希表
- HashMap和HashSet存储数据的结构都是哈希表
- HashMap如果没有value部分，就是Set
案例1-创建Map集合
public class Demo04Map {
public static void main(String[] args) {
Map<String,Double> shoppingCar = new HashMap<>();
// 1、键不能重复，如果重复，后面的会覆盖前面的值
shoppingCar.put("印度神油", 998.0);
shoppingCar.put("印度神油", 889.0);
//2、key和value可以是null
shoppingCar.put(null, null);
//3、value有限制吗?
shoppingCar.put("仿真娃娃", null);
System.out.println(shoppingCar);
}
}
案例2–Map集合API使用
public class Demo05MapApi {
public static void main(String[] args) {
HashMap<String,String> map = new HashMap<>();
//public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
map.put("黄晓明", "AngelaBaby"); //夫妻废片
map.put("文章","马伊琍");
map.put("文章", null);
map.put("王宝强","马 蓉");
map.put("贾乃亮","李小璐");
map.put("陈羽凡","白百何");
//public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
String removeValue = map.remove("文章");
System.out.println(removeValue);
//public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
String baiHe = map.get("陈羽凡");
System.out.println("baiHe = " + baiHe);
//public boolean containKey(Object key):判断该集合中是否有此键。
boolean hasSunLi = map.containsKey("邓超");
System.out.println("hasSunLi = " + hasSunLi);
boolean hasMaRong = map.containsKey("王宝强");
System.out.println("hasMaRong = " + hasMaRong);
}
}
六、遍历Map集合的3种方式
遍历Map集合的3种方式
1、键找值的方式遍历：先拿到所有的键，再遍历键获取对应值。（最简单的）
2、键值对方式遍历。
3、forEach >=1.8
1、键找值方式遍历
键找值遍历步骤
1、获得Map集合所有的键：Set<E> keys = map.keySet()
2、遍历键的集合keys，并且通过key获取value
键找值遍历图解
代码实现
public class Demo06Map1KeySet {
public static void main(String[] args) {
HashMap<String,String> map = new HashMap<>();
//public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
map.put("黄晓明", "AngelaBaby"); //夫妻废片
map.put("文章","马伊琍");
map.put("王宝强","马 蓉");
map.put("贾乃亮","李小璐");
map.put("陈羽凡","白百何");
//map没有下标
//获取所有的key，返回值是Set
Set<String> keys = map.keySet();
System.out.println("keys = " + keys);
//set能遍历，有缺点，效率低
for (String key : keys) {
String value = map.get(key);
System.out.println(key+"="+value);
}
}
}
2、键值对方式遍历
Entry键值对对象:
Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。
Entry将键值对的对应关系封装成了对象，即键值对对象。这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
Entry是Map中的一个内部类，该类封装了key-value对，Map.Entry<K,V>。
在Map集合中提供了获取所有Entry对象的方法：
- public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
获取了Entry对象 , 表示获取了一对键和值，那么同样Entry中 , 分别提供了获取键和获取值的方法：
public K getKey()：获取Entry对象中的键。
public V getValue()：获取Entry对象中的值。
键值对方式遍历Map步骤
1、获得键值对集合：Set<Map.Entry<K,V>> entries = map.entrySet();
2、遍历键值对集合entries，通过getKey() 、getValue()分别获取键和值
遍历图解：
代码实现
public class Demo06Map2EntrySet {
public static void main(String[] args) {
HashMap<String,String> map = new HashMap<>();
//public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
map.put("黄晓明", "AngelaBaby"); //夫妻废片
map.put("文章","马伊琍");
map.put("王宝强","马 蓉");
map.put("贾乃亮","李小璐");
map.put("陈羽凡","白百何");
//获得entry对象的set集合
Set<Map.Entry<String,String>> entries = map.entrySet();
//Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。
//set又可以遍历了
for (Map.Entry<String, String> entry : entries) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"="+value);
}
}
}
3、forEach遍历Map
前两种虽然可以遍历map，但是都会产生中间的Set集合对象，比较麻烦。用forEach遍历Map集合可以省略Set集合对象
HashMap类中已经重写了forEach方法。
forEach的参数就是BiConsumer函数接口。
BiConsumer函数式接口
有且仅有一个抽象方法的接口叫函数式接口，BiConsumer函数接口里面只有一个accept方法，就是为了处理键值对key-value存在。
forEach方法
@Override
public void forEach(BiConsumer<? super K, ? super V> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.key, e.value);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
代码实现
forEach结合λ Lambda写法可以快速实现forEach打印
public class Demo06Map3ForEach {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
//public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
map.put("黄晓明", "AngelaBaby"); //夫妻废片
map.put("文章", "马伊琍");
map.put("王宝强", "马 蓉");
map.put("贾乃亮", "李小璐");
map.put("陈羽凡", "白百何");
//map调用forEach打印，参数是BiConsumer接口，使用匿名内部类实现接口，重写accept方法。
//写法还是太长了
map.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String key, String value) {
System.out.println(key+"="+value);
}
});
//预习改进 使用Lambda表达式写法
// map.forEach((String key,String value)->{
// System.out.println(key+"="+value);
// });
//继续缩减1
// map.forEach((key,value)->{
// System.out.println(key+"="+value);
// });
//继续缩减2，方法实现中只有一句话
map.forEach((key,value)->System.out.println(key+"="+value));
}
}
java8 Lambda表达式简介：
https://blog.csdn.net/qq_28410283/article/details/80961022
七、Map集合练习案例
1、使用自定义类作为key
需求
每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。（注意，学生姓名相同并且年龄相同视为同一名学生。）
注意事项
1、在HashMap中存放自定义对象时，如果自定义对象作为key存在，要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。
如果自定义对象作为value存在，则不用重写。
2、如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。
代码实现
编写学生类：
public class Student {
private String name;
private int age;
//构造方法
//get/set
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
编写测试类：
public class HashMapTest {
public static void main(String[] args) {
//1、创建Hashmap集合对象。
Map<Student,String> map = new HashMap<Student,String>();
//2、添加元素。
map.put(new Student("lisi",28), "上海");
map.put(new Student("wangwu",22), "北京");
map.put(new Student("wangwu",22), "南京");
//3、取出元素。键找值方式
Set<Student> keySet = map.keySet();
for(Student key: keySet){
String value = map.get(key);
System.out.println(key.toString()+"....."+value);
}
}
}
小结：
1、为什么hashMap存放的key对象需要重写hashCode和equals？
因为hashMap的存储数据结构是哈希表，哈希表是通过key的哈希值（hashcode）的尾数找数组的位置，通过key进行equals方法的比较key有没重复。为了保证key唯一必须重写hashCode方法和equals方法。
2、为什么HashMap的特性是由key决定的？
通过key的哈希值（hashcode）的尾数定位哈希表数组的位置，通过key进行equals方法的比较key有没重复。保证key唯一必须要重写hashCode方法与equals方法，value可以是任意值
HashMap中，比较key是否相等为什么要重写equal() 和hashCode()这两个方法？
https://blog.csdn.net/qq_24598059/article/details/97958489
2、Map集合练习–字符出现次数。
需求
计算一个字符串中每个字符出现次数。
分析
- 获取一个字符串对象
- 创建一个Map集合，键代表字符，值代表次数。
- 遍历字符串得到每个字符。
- 判断Map中是否有该键。
- 如果没有，第一次出现，存储次数为1；如果有，则说明已经出现过，获取到对应的值进行++，再次存储。
- 打印最终结果
public boolean containKey(Object key):判断该集合中是否有此键。
代码实现
public class MapTest {
public static void main(String[] args) {
//友情提示
System.out.println("请录入一个字符串:");
String line = new Scanner(System.in).nextLine();
// 定义 每个字符出现次数的方法
findChar(line);
}
private static void findChar(String line) {
//1:创建一个集合 存储 字符 以及其出现的次数
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
//2:遍历字符串
for (int i = 0; i < line.length(); i++) {
char c = line.charAt(i);
//判断 该字符 是否在键集中
if (!map.containsKey(c)) {//说明这个字符没有出现过
//那就是第一次
map.put(c, 1);
} else {
//先获取之前的次数
Integer count = map.get(c);
//count++;
//再次存入 更新
map.put(c, ++count);
}
}
System.out.println(map);
}
}
3、Map集合特有的排序方式
Map接口的实现类treeMap类，是专门用于排序（自定义排序）的集合
java.util.TreeMap.putAll()是TreeMap类的内置方法，用于复制操作。
代码示例
public class Demo09MapSort {
public static void main(String[] args) {
String shi = "懵逼树上懵逼果懵逼树下懵逼人懵逼树前排排坐一人一个懵逼果";
/*
1、定义一个Map存储统计的结果
2、遍历String
3、更新统计的结果
*/
//目标：字数统计次数最多的放在前面
Map<Character,Integer> wordCounts = new HashMap<>();
for(int i=0;i<shi.length();i++) {
char word = shi.charAt(i);
if(!wordCounts.containsKey(word)) {
//一开始不包含，所以需要首次初始化为1
wordCounts.put(word,1);
} else {
//counter:计数器
int counter = wordCounts.get(word)+1;
wordCounts.put(word,counter);
}
}
System.out.println(wordCounts);
Map<Character,Integer> sortMap = new TreeMap<>(new Comparator<Character>() {
@Override
public int compare(Character o1, Character o2) {
//获得value值
int c1 = wordCounts.get(o1);
int c2 = wordCounts.get(o2);
//return c1-c2; //等于0时，sout没输出字符
//所以最好不要出现0，考虑c1，c2相等的情况，用判断
if(c1>=c2) {
return -1;
}
return 1;
}
});
//可以添加传入map的所有数据
sortMap.putAll(wordCounts);
System.out.println(sortMap);
}
}
TreeMap的compare方法返回0，会覆盖当前key的值
https://blog.csdn.net/thirdfloor/article/details/90717308
八、LinkedHashMap
LinkedHashMap是HashMap的一个子类，它保留插入的顺序，如果需要输出的顺序和输入时的相同，那么就选用LinkedHashMap。
LinkedHashMap底层存储数据结构使用了哈希表存储数据，并且使用了链表存储插入顺序。
优点：可以使得数据可以按照添加的顺序访问或取出。可以理解为有序的HashMap
缺点：因为多维护了链表的关系，添加/删除性能会比HashMap较慢
代码示例：
public class Demo08LinkedHashMap {
public static void main(String[] args) {
//如果想按照我们添加的顺序保存
LinkedHashMap<String,String> map = new LinkedHashMap<>();
map.put("方面","补肾");
map.put("树人","补肾");
map.put("中酿","补肾");
map.put("山药","补肾");
map.put("秋葵","补肾");
map.put("枸杞","补肾");
System.out.println(map);
}
}
九、图书管理系统
图书管理系统项目界面演示
图书管理系统分析:
1.定义Book类
2.完成主界面和选择
3.完成查询所有图书
4.完成添加图书
5.完成删除图书
6.完成修改图书
7.使用Debug追踪调试
代码实现
定义一个Book类表示书籍
public class Book {
private String name;
private double price;
public Book() {
}
public Book(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
主界面的内容其实就是通过打印语句打印出来的，但是要注意因为每个操作过后都会重新回到主界面,所以使用while(true)死循环的方式.
public class LibrarySystem {
public static void main(String[] args) {
//1、定义Map<String,List<Book>>存储数据
// * 创建Book类,要有名字、价格
// * 初始化几本书
Map<String, List<Book>> map = new HashMap<>();
List<Book> mingzhus = new ArrayList<>();
Book book1= new Book("西游记",66.5);
Book book2 = new Book("三国演义",99.99);
Collections.addAll(mingzhus,book1,book2);
map.put("名著",mingzhus);
List<Book> its = new ArrayList<>();
Book book3= new Book("Java入门到放弃",1.0);
Book book4 = new Book("Mysql从删库到跑路",2.0);
Collections.addAll(its,book3,book4);
map.put("IT",its);
while(true) {
System.out.println("--------欢迎来到学生管理系统--------");
System.out.println("1.查看所有书籍");
System.out.println("2.添加书");
System.out.println("3.删除书");
System.out.println("4.修改书");
System.out.println("5.退出");
System.out.println("请输入你的选择：");
Scanner sc = new Scanner(System.in);
int number = sc.nextInt();
switch (number) {
case 1: //查看书籍
listBooks(map);
break;
case 2: //添加书
addBook(map);
break;
case 3: //删除书
delbook(map);
break;
case 4: //修改书
editBook(map);
break;
case 5: //退出
System.out.println("bye~");
System.exit(0);
break;
default:
System.out.println("请输入1~5的功能编号");
break;
}
}
}
//edit :编辑
private static void editBook(Map<String, List<Book>> map) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入 类别");
String type = sc.nextLine();
//通过类别找到这本书的集合
List<Book> books = map.get(type);
//分支1：没有类别
if(books==null) {
System.out.println("没有该"+type+"类别");
return;
}
System.out.println("请输入 书名");
String name = sc.nextLine();
//应该进行一下遍历的判断
System.out.println("请输入 新的书名");
String newName = sc.nextLine();
System.out.println("请输入 新的价格");
double newPrice = sc.nextDouble();
//分支2:for找到这个名字的书
for (int i = 0; i < books.size(); i++) {
Book book = books.get(i);
if(book.getName().equals(name)) {
book.setName(newName);
book.setPrice(newPrice);
System.out.println("修改"+name+"为"+newName);
return ;
}
}
//分支3：有这个类别，没有这本书
System.out.println("该"+type+"类别下没有"+name+"这本书");
}
private static void delbook(Map<String, List<Book>> map) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入 类别");
String type = sc.nextLine();
System.out.println("请输入 书名");
String name = sc.nextLine();
//通过类别找到这本书的集合
List<Book> books = map.get(type);
//分支1：没有类别
if(books==null) {
System.out.println("没有该"+type+"类别");
return;
}
//分支2:for找到这个名字的书
for (int i = 0; i < books.size(); i++) {
Book book = books.get(i);
if(book.getName().equals(name)) {
books.remove(i);
//books删除了不需要重新put,因为map存的是引用地址，引用地址中的内容被修改了，map中同样的地址的内容也会跟着变化
System.out.println("删除"+book.getName()+"成功");
//判断集合是不是空的，如果是空的返回true
if(books.isEmpty()) {
map.remove(type);
}
return;
}
}
//分支3：有这个类别，没有这本书
System.out.println("该"+type+"类别下没有"+name+"这本书");
}
//添加书籍
private static void addBook(Map<String, List<Book>> map) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入 类别");
String type = sc.nextLine();
System.out.println("请输入 书名");
String name = sc.nextLine();
System.out.println("请输入 价格");
double price = sc.nextDouble();
Book book = new Book(name,price);
//
// List<Book> books = map.get(type); //如果没有这个类别，获取到的book是null
// if(books==null) {
// books = new ArrayList<>();
// }
List<Book> books = map.get(type);
if(!map.containsKey(type)) {
books = new ArrayList<>();
}
books.add(book); //NullPointerException
map.put(type,books);//有没有多余？ 没有，有可能是 null,如果是null就需要 更新
System.out.println("添加"+name+"书成功!");
}
//查看所有书籍
private static void listBooks(Map<String, List<Book>> map) {
System.out.println("类别\t\t书名\t\t价格");
Set<Map.Entry<String, List<Book>>> entries = map.entrySet();
for (Map.Entry<String, List<Book>> entry : entries) {
//type类型
String type = entry.getKey();
List<Book> books = entry.getValue();
System.out.println(type);
for (Book book : books) {
System.out.println(" \t\t"+book.getName()+"\t\t"+book.getPrice());
}
}
System.out.println();
}
}
1237
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
