摘要

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队列：先进先出 FIFOb、数组：查询快，增删慢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}; //13sum(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>() {@Overridepublic 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可以是nullshoppingCar.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，返回值是SetSet<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>() {@Overridepublic 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@Overridepublic 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);}@Overridepublic 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、遍历String3、更新统计的结果*///目标：字数统计次数最多的放在前面Map<Character,Integer> wordCounts = new HashMap<>();for(int i=0;i<shi.length();i++) {char word = shi.charAt(i);if(!wordCounts.containsKey(word)) {//一开始不包含，所以需要首次初始化为1wordCounts.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>() {@Overridepublic 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()+"成功");//判断集合是不是空的，如果是空的返回trueif(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); //NullPointerExceptionmap.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();}}

Java基础加强重温_06：可变参数、集合工具类Collections类、冒泡排序、Map集合、Map集合遍历、Map案例、LinkedHashMap集合、图书管理系统相关推荐

Java基础加强重温_05：Iterator迭代器、增强for循环、集合综合案例-斗地主、数据结构（栈、队列、数组、链表、红黑树）、List接口、Set接口
摘要: Java基础加强重温_05: Iterator迭代器(指针跟踪元素). 增强for循环(格式.底层). 集合综合案例-斗地主(代码规范抽取代码,集合元素打乱). 数据结构[栈(先进后出,子弹夹 ...
Java基础加强重温_08：线程不安全、线程同步、线程状态、线程状态切换、线程池（Executors类、newFixedThreadPool）、死锁、Lambda表达式、Stream
摘要 Java基础加强重温_08: 线程安全(线程安全概念.线程不安全案例). 线程同步(同步代码块.同步方法.Lock锁,锁对象). 线程状态(new新建.Runnable可运行.Blocked锁阻 ...
Java基础加强重温_13：XML（可拓展标记语言）、XML语法、XML约束、XML解析（Dom4j，JAXP）、Dom4j基本使用、Xpath表达式（XML路径语言）、XML解析综合案例
摘要 Java基础加强重温_13: XML(可拓展标记语言.作用:小型数据库.框架配置文件.不同平台数据交换). XML语法(文档.标签/元素.属性.注释.转义字符.CDTA区) XML约束(DTD约 ...
day02--java基础编程：变量，数据类型，类型转换，运算规则，运算符，分支结构，循环(随机数)，方法，重载，可变参数，递归，数组，冒泡排序
1 Day02–变量+数据类型+类型转换 1.1 前言 1.1.1 标识符可以简单的理解为一个名字.在Java中,我们需要标识代码的很多元素,包括包名.类名.方法.字段.变量等.我们选择的名称就称为 ...
day02--java基础编程：变量，数据类型，类型转换，运算规则，Scanner，运算符，分支结构，循环(随机数)，方法，重载，可变参数，递归，数组，冒泡排序
1 Day02–变量+数据类型+类型转换 1.1 前言 1.1.1 标识符可以简单的理解为一个名字.在Java中,我们需要标识代码的很多元素,包括包名.类名.方法.字段.变量等.我们选择的名称就称为 ...
【Java 基础】字符串StringBuilder、StringBuffer，工具StringJoiner
字符串StringBuilder.StringBuffer,工具StringJoiner 一.概述二.StringBuilder 三.StringBuffer 三.StringBuilder .St ...
java基础5：工厂模式、单例模式、File文件类、递归、IO流、Properties配置文件、网络编程、利用IO流模拟注册登录功能、关于反射、JDK动态代理
1.工厂模式 23种java设计模式之一 1)提供抽象类(基类) 2)提供一些子类,完成方法重写 3)提供一个接口:完成具体子类的实例化对象的创建,不能直接new子类,构造函数私有化. 优点:具体的子 ...
java集合学习笔记 ---Collections类对集合的处理
2019独角兽企业重金招聘Python工程师标准>>> 包名:java.util.Collections Collections是个类,不是接口有以下方法,部分列举 1.对List ...
java_基础_遍历map删除元素_Java 遍历Map（包括集合）时,修改删除元素
转载自:https://blog.csdn.net/weixin_33498283/article/details/114071025 1.遍历Map集合的四种方法 public staticvoid ...
java中map嵌套map_java中遍历MAP,嵌套map的几种方法
java中遍历MAP的几种方法 Map map=new HashMap(); map.put("username", "qq"); map.put(" ...

Java基础加强重温_06：可变参数、集合工具类Collections类、冒泡排序、Map集合、Map集合遍历、Map案例、LinkedHashMap集合、图书管理系统

摘要

回顾泛型与集合

一、可变参数

格式

可变参数的使用:

可变参数注意事项

可变参数案例

二、Collections类

Collections的API

Comparator接口（比较器）

重写Comparator接口compare方法

案例1–自定义比较器排序

案例2–Collections的API

三、排序算法

冒泡排序

冒泡排序案例

四、Set、Map、List三种集合的差别

五、Map集合

Map的常用子类

HashMap<K,V>

LinkedHashMap<K,V>

Map集合的常用方法

Map集合与List、Set集合的区别

Map集合的特点

HashMap和HashSet的关系

案例1-创建Map集合

案例2–Map集合API使用

六、遍历Map集合的3种方式

1、键找值方式遍历

键找值遍历步骤

键找值遍历图解

代码实现

2、键值对方式遍历

Entry键值对对象:

键值对方式遍历Map步骤

遍历图解：

代码实现

3、forEach遍历Map

BiConsumer函数式接口

forEach方法

代码实现

七、Map集合练习案例

1、使用自定义类作为key

需求

注意事项

代码实现

小结：

2、Map集合练习–字符出现次数。

需求

分析

代码实现

3、Map集合特有的排序方式

代码示例

八、LinkedHashMap

代码示例：

九、图书管理系统

图书管理系统项目界面演示

图书管理系统分析:

代码实现

Java基础加强重温_06：可变参数、集合工具类Collections类、冒泡排序、Map集合、Map集合遍历、Map案例、LinkedHashMap集合、图书管理系统相关推荐

最新文章

热门文章