18.01_Map集合概述和特点
-
public interface Map<K,V>键值对- 将键映射到值的对象！一个映射不能包含重复的键！每个键最多只能映射到一个值。（通过查看HashMap的源码，发现Set集合的底层是依赖Map集合的）
-
Map接口和Collection接口的不同:-
Map是双列的,Collection是单列的 -
Map的键唯一,Collection的子体系Set是唯一的 -
Map集合的数据结构（算法）只针对键有效，跟值无关;Collection集合的数据结构是针对元素有效
-
18.02_Map集合的功能概述
- a:添加功能
-
V put(K key,V value):添加元素。- 如果键是第一次存储，就直接存储元素，返回null
- 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
-
- b:删除功能
-
void clear():移除所有的键值对元素 -
V remove(Object key)：根据键删除键值对元素，并把值返回
-
- c:判断功能
-
boolean containsKey(Object key)：判断集合是否包含指定的键 -
boolean containsValue(Object value):判断集合是否包含指定的值 -
boolean isEmpty()：判断集合是否为空
-
- d:获取功能
-
Set<Map.Entry<K,V>> entrySet():获取所有的键值对象的集合 -
V get(Object key):根据键获取值 -
Set<K> keySet():获取集合中所有键的集合 -
Collection<V> values():获取集合中所有值的集合
-
- e:长度功能
-
int size()：返回集合中的键值对的个数
-
18.03_Map集合的遍历之键找值
- 1.获取所有键的集合
- 2.遍历键的集合，获取到每一个键
- 3.根据键找值
Map<String, Integer> map = new HashMap<>();
map.put("第一个", 100); // 自动装箱
map.put("第二个", 300);
map.put("第三个", 300);
Set<String> set = map.keySet(); //获取所有的key
//增强for循环遍历
for (String key : set) {
System.out.println(key + "-->" + map.get(key));
}
//迭代器遍历
Iterator<String> it = set.iterator();
while (it.hasNext()) {
String key = it.next();
System.out.println(key + "-->" + map.get(key));
}
18.04_Map集合的遍历之键值对对象找键和值
- 1.获取所有键值对对象的集合
- 2.遍历键值对对象的集合，获取到每一个键值对对象
- 3.根据键值对对象找键和值
Map<String, Integer> map = new HashMap<>();
map.put("第一个", 100);
map.put("第二个", 300);
map.put("第三个", 300);
// Map.Entry Entry是Map接口的内部接口，将键和值封装成Entry对象，并存储在Set集合中。
Set<Map.Entry<String, Integer>> entry = map.entrySet();
// 迭代器
Iterator<Map.Entry<String, Integer>> it = entry.iterator();
while (it.hasNext()) {
Map.Entry<String, Integer> en = it.next();
String key = en.getKey();
Integer value = en.getValue();
System.out.println(key + "-->" + value);
}
// foreach
for (Map.Entry<String, Integer> en : entry) { //父类引用指向子类对象
System.out.println(en.getKey() + "-->" + en.getValue());
}
- 内部接口例子
interface Inter {
interface Inter2 { // 内部接口
public void show();
}
}
class Demo implements Inter.Inter2 { // 实现接口的内部接口
public void show() {}
}
18.05_HashMap集合键是Student值是String的案例
// 键是Student 值是字符串，代表地址
// 结论： 自定义类，需要重写 hashCode方法 和 equals 方法
HashMap<Student, String> map = new HashMap<>();
map.put(new Student("张三", 12), "北京");
map.put(new Student("张三", 12), "北京");
map.put(new Student("八戒", 358), "西天");
System.out.println(map); //此时，只有2个元素，张三 和 八戒
// 快速生成 hashCode和equals
// Shift + Alt + s 然后再 h
18.06_LinkedHashMap的概述和使用
-
LinkedHashMap底层是链表实现的可以保证怎么存就怎么取
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("qq", 100);
map.put("yy", 230);
map.put("ww", 100);
System.out.println(map); // 存的顺序 和 取的顺序是一致的
18.07_TreeMap集合键是Student值是String的案例
方案一，不使用比较器
TreeMap<Student, String> tm = new TreeMap<>();
tm.put(new Student("张三", 21), "xxoo");
tm.put(new Student("张三", 25), "xxoo");
tm.put(new Student("赵六", 24), "xoxo");
System.out.println(tm); // 此时，如果自定义对象没有实现Comparable接口，就会报错
// TreeMap 会自动排序，比较键，键对象就必须实现java.lang.Comparable接口
// 自定义对象的 实现 compareTo 方法
@Override
public int compareTo(Student o) {
int num = this.age - o.age; //以年龄为主要条件，姓名为次要条件
return num == 0 ? this.name.compareTo(o.name) : num;
}
方案二，使用比较器
Comparator<Student> comp = new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int num = o1.getAge() - o2.getAge();
return num == 0 ? o1.getName().compareTo(o2.getName()) : num;
}
};
TreeMap<Student, String> treeMap = new TreeMap<>(comp);
treeMap.put(new Student("张三", 21), "xxoo");
treeMap.put(new Student("张三", 25), "xxoo");
System.out.println(treeMap);
18.08_统计字符串中每个字符出现的次数
- 需求：统计字符串中每个字符出现的次数
String str = "aaaabbbcccccbcccca";
char[] array = str.toCharArray();
HashMap<Character, Integer> map = new HashMap<>();
for (char c : array) {
/*if (map.containsKey(c)) {
map.put(c, map.get(c) + 1);
} else {
map.put(c, 1);
}*/
// 可以优化为三目运算符
map.put(c, map.containsKey(c) ? (map.get(c) + 1) : 1);
}
System.out.println(map);
18.09_集合嵌套之HashMap嵌套HashMap
- 集合嵌套之HashMap嵌套HashMap
// 双列集合--元素一
HashMap<Student, String> map1 = new HashMap<>();
map1.put(new Student("S1", 23), "北京");
map1.put(new Student("S2", 23), "北京");
// 双列集合--元素二
HashMap<Student, String> map2 = new HashMap<>();
map2.put(new Student("S5", 78), "郑州");
map2.put(new Student("S8", 45), "天津");
HashMap<Map<Student, String>, String> map = new HashMap<>();
map.put(map1, "第一个元素");
map.put(map2, "第二个元素");
// 遍历 嵌套双列集合
for (Map<Student, String> subMap : map.keySet()) {
String s1 = map.get(subMap);
System.out.println("----"+s1+"---");
for (Student stu : subMap.keySet()) {
System.out.println(" " + stu + "--->" + subMap.get(stu));
}
}
18.10_HashMap和Hashtable的区别
-
Hashtable是JDK1.0版本出现的,是线程安全的,效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率高 -
Hashtable不可以存储null键和null值,HashMap可以存储null键和null值 - 底层都是哈希算法，都是双列集合
HashMap<String, String> map = new HashMap<>();
map.put(null, null);
System.out.println(map); // 没有问题。可以存储null键值
Hashtable<String, String> tab = new Hashtable<>();
tab.put(null, null); //报错，NullPointerException
18.11_Collections工具类的概述和常见方法讲解
- 针对集合操作 的工具类， 类似 操作数组的工具类
Arrays
，其实对于这种工具类的学习，查看文档即可， 一般都是只有静态方法（私有了构造方法）。
常用几个方法
static <T> void sort(List<T> list) 排序List
static <T> int binarySearch(List<?> list,T key) 二分查找List
static <T> T max(Collection<?> coll) 获取List的最值
static void reverse(List<?> list) 反转List元素
static void shuffle(List<?> list) 随机排序List，类似：洗牌
18.12_模拟斗地主洗牌和发牌
- 模拟斗地主洗牌和发牌，牌没有排序
//买一副扑克
String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
String[] color = {"方片","梅花","红桃","黑桃"};
ArrayList<String> poker = new ArrayList<>();
// 拼接花色和数字
for (String s1 : color) {
for (String s2 : num) {
poker.add(s1.concat(s2)); // concat连接两个字符串
}
}
// 添加大小王
poker.add("大王");
poker.add("小王");
// 洗牌
Collections.shuffle(poker);
// 发牌
ArrayList<String> p1 = new ArrayList<>();
ArrayList<String> p2 = new ArrayList<>();
ArrayList<String> me = new ArrayList<>();
ArrayList<String> dipai = new ArrayList<>(); //底牌，斗地主，要留3张
for (int i = 0; i < poker.size(); i++) {
if (i >= poker.size() - 3) { //将最后3张底牌存储在底牌集合里
dipai.add(poker.get(i));
} else if ( i % 3 == 0) { //这里的 i%3，应该好好理解一下
p1.add(poker.get(i));
} else if ( i % 3 == 1) {
p2.add(poker.get(i));
} else {
me.add(poker.get(i));
}
}
// 看牌
System.out.println(me);
System.out.println(dipai);
18.13_模拟斗地主洗牌和发牌并对牌进行排序的原理图解
斗地主.png
18.14_模拟斗地主洗牌和发牌并对牌进行排序的代码实现
//买一副扑克
String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] color = {"方片","梅花","红桃","黑桃"};
HashMap<Integer, String> map = new HashMap<>(); //存储索引和扑克牌
ArrayList<Integer> list = new ArrayList<>(); //存储索引，为了方便洗牌
// 拼接扑克牌
int index = 0;
for (String s1 : num) {
for (String s2 : color) {
map.put(index, s2.concat(s1));
list.add(index);
index++ ;
}
}
map.put(index, "小王"); list.add(index); //添加大王和小王 以及对应的索引
map.put(++index, "大王"); list.add(index);
// 洗牌，就是洗索引
Collections.shuffle(list);
// 发牌 (就是发索引，TreeSet能自动排序)
TreeSet<Integer> p1 = new TreeSet<>();
TreeSet<Integer> p2 = new TreeSet<>();
TreeSet<Integer> me = new TreeSet<>();
TreeSet<Integer> dipai = new TreeSet<>(); //底牌
for (int i = 0; i < list.size(); i++) {
if (i >= list.size() - 3) {
dipai.add(list.get(i)); //ArrayList有索引，Set没有索引
} else if ( i % 3 == 0) {
p1.add(list.get(i));
} else if ( i % 3 == 1) {
p2.add(list.get(i));
} else {
me.add(list.get(i));
}
}
// 看牌自己的牌 （这里可以封装一个专门看牌的方法）
for (Integer i : me) {
System.out.print(map.get(i) + " "); //按照索引，从Map里面取出来对应的牌面值
}
18.15_泛型高级---泛型固定边界
-
? super E固定下边界 -
? extends E固定上边界 - 本质都是 父类指向子类对象
集合接口： Collection<E>
方法：
boolean addAll(Collection<? extends E> c)
这里用到了 泛型固定上边界，意思是 addAll() 方法传入 Collection 以及子类 都可以。
双列集合： TreeMap<K,V>
构造方法：
TreeMap(Comparator<? super K> comparator)
例子(注意比较器泛型的类型和TreeSet泛型的类型)：
TreeSet<Son> set = new TreeSet<>(new Comparator<Father>() {
@Override
public int compare(Father o1, Father o2) {
int num = o1.getAge() - o2.getAge();
return num == 0 ? o1.getName().compareTo(o2.getName()) : num;
}
});
set.add(new Son("SS1", 21));
set.add(new Son("SS2", 31));
set.add(new Son("SS3", 41));
System.out.println(set);
18.16_四天集合总结
/**
* Collection
* List(存取有序,有索引,可以重复)
* ArrayList
* 底层是数组实现的,线程不安全,查找和修改快,增和删比较慢
* LinkedList
* 底层是链表实现的,线程不安全,增和删比较快,查找和修改比较慢
* Vector
* 底层是数组实现的,线程安全的,无论增删改查都慢
* 如果查找和修改多,用ArrayList
* 如果增和删多,用LinkedList
* 如果都多,用ArrayList
* Set(存取无序,无索引,不可以重复)
* HashSet
* 底层是哈希算法实现
* LinkedHashSet
* 底层是链表实现,但是也是可以保证元素唯一,和HashSet原理一样
* TreeSet
* 底层是二叉树算法实现
* 一般在开发的时候不需要对存储的元素排序,所以在开发的时候大多用HashSet,HashSet的效率比较高
* TreeSet在面试的时候比较多,问你有几种排序方式,和几种排序方式的区别
* Map
* HashMap
* 底层是哈希算法,针对键
* LinkedHashMap
* 底层是链表,针对键
* TreeMap
* 底层是二叉树算法,针对键
* 开发中用HashMap比较多
*/
END。
我是小侯爷。
在魔都艰苦奋斗，白天是上班族，晚上是知识服务工作者。
如果读完觉得有收获的话，记得关注和点赞哦。
非要打赏的话，我也是不会拒绝的。
