Map接口的概述
将键映射到值的对象。
Map不能包含重复的键;
每个键可以映射到最多一个值。
Map接口与Collection接口有什么区别？
1、Map接口与Collection接口是平级关机，不存在继承关系，都是属于util包下面的
2、Map集合中的元素都是成对出现的，Map集合中的键是唯一的，值是可以重复的 又称之为：夫妻对
3、Collection集合中的元素都是单独出现的，Collection接口下面有个子接口Set，它的元素也是唯一的
List中的元素也是单独出现，可以重复，像这样单独出现的元素，称之为：光棍
Map接口中的方法：
1、添加功能：
V put(K key, V value) 将指定的值与该映射中的指定键相关联（可选操作）。
2、删除功能：
void clear() 从该Map中删除所有的映射（可选操作）。
V remove(Object key) 如果存在（从可选的操作），从该Map中删除一个键的映射。
3、判断功能：
boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
boolean containsValue(Object value) 如果此地图将一个或多个键映射到指定的值，则返回 true 。
boolean isEmpty() 如果此地图不包含键值映射，则返回 true 。
4、获取功能：
V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
Set<K> keySet() 返回此Map中包含的键的Set视图。
Collection<V> values() 返回此Map中包含的值的Collection视图
Set<Map.Entry<K,V>> entrySet() 获取Map中所有元素，元素的类组成是由一个键和一个值组成
5、长度功能：
int size() 返回此Map中键值映射的数量。
package com.shujia.wyh.day20;
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
//创建Map集合对象
//由于Map是一个接口，所以接口不能直接实例化，要使用一个具体的子类进行实例化
//这里借助HashMap
Map<String,String> map = new HashMap<>();
//添加元素
//V put(K key, V value) 将指定的值与该映射中的指定键相关联（可选操作）。
//这里的返回值是将来再次插入同一个键的时候，被覆盖的那个值
map.put("黄晓明","杨颖");
map.put("邓超","孙俪");
map.put("小虎","冯提莫");
map.put("小虎","IU");
//删除功能
//void clear() 从该Map中删除所有的映射（可选操作）。
// map.clear();
// V remove(Object key) 如果存在（从可选的操作），从该Map中删除一个键的映射。
//返回对应删除的值
// System.out.println(map.remove("小虎"));
System.out.println("==========================================");
//boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
System.out.println(map.containsKey("小虎"));
//boolean containsValue(Object value) 如果此地图将一个或多个键映射到指定的值，则返回 true 。
System.out.println(map.containsValue("IU"));
System.out.println(map.isEmpty());
System.out.println(map);
}
}
Map集合遍历的方式一：根据键找值
1、通过调用keySet()方法获取Map集合中所有的key
2、结合get(key)这个方法，可以获取到每一个key对应的value
3、输出
package com.shujia.wyh.day20;
import java.util.HashMap;
import java.util.Set;
public class MapDemo3 {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
//向集合中添加元素
map.put("霞", "洛");
map.put("蛮王", "寒冰");
map.put("卢锡安", "塞纳");
map.put("盖伦", "卡特");
//通过调用keySet()方法获取Map集合中所有的key
Set<String> keySet = map.keySet();
//遍历keySet获取到每一个key
for (String s : keySet) {
String value = map.get(s);
System.out.println(s + ":" + value);
}
}
}
Map集合遍历的方式一：
一次先把所有的键值对获取到，然后在依次获取每一个键值对的key和value
package com.shujia.wyh.day20;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo4 {
public static void main(String[] args) {
//1、创建集合对象
HashMap<String, String> map = new HashMap<>();
//2、向集合中添加元素
map.put("王子1", "白雪公主");
map.put("王子2", "灰姑凉");
map.put("王子3", "美人鱼");
//遍历：一次先把所有的键值对获取到
//Set<Map.Entry<K,V>> entrySet() 获取Map中所有元素，元素的类组成是由一个键和一个值组成
Set<Map.Entry<String, String>> set = map.entrySet();
//遍历集合获取每一个键值对
for (Map.Entry<String, String> keyValue : set) {
String key = keyValue.getKey();
String value = keyValue.getValue();
System.out.println(key + ":" + value);
}
}
}
HashMap类概述 键是哈希表结构，可以保证键的唯一性
HashMap<Student,String>
如果key是自己自定义的一个对象，该类需要重写hashCode()方法和equals()方法
因为put方法的底层，添加元素的标准就是根据hashCode()方法和equals()的值来判断元素是否重复
package com.shujia.wyh.day20;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Objects;
class Student5 {
private String name;
private int age;
public Student5() {
}
public Student5(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student5 student5 = (Student5) o;
return age == student5.age && Objects.equals(name, student5.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Student4{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class MapDemo7 {
public static void main(String[] args) {
//1、创建集合对象
HashMap<Student5, String> map = new HashMap<>();
//2、创建学生对象
Student5 s1 = new Student5("王昭君", 17);
Student5 s2 = new Student5("貂蝉", 16);
Student5 s3 = new Student5("杨玉环", 18);
Student5 s4 = new Student5("西施", 19);
Student5 s5 = new Student5("王昭君", 17);
//将元素添加到集合中
map.put(s1, "1111");
map.put(s2, "2222");
map.put(s3, "3333");
map.put(s4, "4444");
map.put(s5, "5555");
//遍历
Set<Map.Entry<Student5, String>> entries = map.entrySet();
for (Map.Entry<Student5, String> keyValue : entries) {
Student5 key = keyValue.getKey();
String value = keyValue.getValue();
System.out.println(key + ":" + value);
}
}
}
LinkedHashMap类（父类HashMap）：
class LinkedHashMap extends HashMap implements Map{}
哈希表和链表实现的Map接口，具有可预测的迭代次序。
哈希保证的是元素的唯一，保证key是唯一
链表保证是有序的（存储和取出的顺序一致）
package com.shujia.wyh.day20;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
public class LinkedHashMapDemo {
public static void main(String[] args) {
LinkedHashMap<String, String> map = new LinkedHashMap<>();
//向集合中添加元素
map.put("1234", "hello");
map.put("4567", "world");
map.put("3456", "java");
map.put("7890", "hadoop");
map.put("1234", "hive");
//遍历
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> keyValue : entries) {
String key = keyValue.getKey();
String value = keyValue.getValue();
System.out.println(key + ":" + value);
}
}
}
TreeMap类：
底层数据结构是红黑树
排序针对于键来说的
自然排序
比较器排序
自定义一个类实现Comparator<T>接口，重写compare()方法
匿名内部类的形式进行构造方法传参，重写compare()方法
package com.shujia.wyh.day20;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo1 {
public static void main(String[] args) {
//1、创建集合对象
TreeMap<String, String> map = new TreeMap<>();
//创建元素并添加到集合中
map.put("hello", "你好");
map.put("world", "世界");
map.put("java", "面向对象的编程语言");
map.put("mysql", "结构化数据库");
//遍历：
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> keyValue : entries) {
String key = keyValue.getKey();
String value = keyValue.getValue();
System.out.println(key + ":" + value);
}
}
}
TreeMap<Student,String>
package com.shujia.wyh.day20;
import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Objects;
class Student6 implements Comparable<Student6> {
private String name;
private int age;
public Student6() {
}
public Student6(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student4{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class TreeMapDemo2 {
public static void main(String[] args) {
//1、创建TreeMap对象
//推荐使用比较器排序，并且用匿名内部类实现
TreeMap<Student6, String> map = new TreeMap<>(new Comparator<Student6>() {
@Override
public int compare(Student6 o1, Student6 o2) {
//判断年龄是否一样
int i = o1.getAge() - o2.getAge();
//年龄一样。姓名不一定一样
int i2 = i == 0 ? o1.getName().compareTo(o2.getName()) : i;
return i2;
}
});
//2、创建学生对象
Student6 s1 = new Student6("明旺", 18);
Student6 s2 = new Student6("王宇", 19);
Student6 s3 = new Student6("周家祥", 20);
Student6 s4 = new Student6("张保桂", 17);
Student6 s5 = new Student6("明旺", 18);
//3、向集合中添加元素
map.put(s1, "男枪");
map.put(s2, "女警");
map.put(s3, "卡特");
map.put(s4, "霞");
map.put(s5, "男枪");
//4、遍历
Set<Map.Entry<Student6, String>> entries = map.entrySet();
for (Map.Entry<Student6, String> keyValue : entries) {
Student6 key = keyValue.getKey();
String value = keyValue.getValue();
System.out.println(key + ":" + value);
}
}
}
例："aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
分析：
1、键盘录入字符串
2、定义一个TreeMap对象存储数据
键：Character
值：Integer
3、将字符串转成字符数组
4、遍历字符数组，得到每一个字符
5、拿着这个字符作为键去map集合中去找，看返回值
如果返回值是null,表示集合中没有该字符作为键，就把当前这个字符设置为键，value设置为1
如果返回值不是null,说明集合中已经存在这个字符作为键，value值+1，然后重新放入到集合中
6、定义一个StringBuffer作为拼接
7、遍历集合得到键和值，按照对应的输出格式进行拼接
8、把StringBuffer输出
package com.shujia.wyh.day20;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Scanner;
public class TreeMapDemo3 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要统计的字符串：");
String s = sc.next();
//定义一个TreeMap对象存储数据
TreeMap<Character, Integer> map = new TreeMap<>();
//将字符串转成字符数组
char[] chars = s.toCharArray();
//遍历字符数组，得到每一个字符 增强for循环遍历
for (Character ch : chars) {
//拿着这个字符作为键去map集合中去找，看返回值 get(key)
Integer num = map.get(ch);
//如果返回值是null,表示集合中没有该字符作为键，就把当前这个字符设置为键，value设置为1
if (num == null) {
map.put(ch, 1);
} else {
// 如果返回值不是null,说明集合中已经存在这个字符作为键，value值+1，然后重新放入到集合中
num++;
map.put(ch, num);
}
}
//定义一个StringBuffer作为拼接
StringBuffer sb = new StringBuffer();
//遍历集合得到键和值，按照对应的输出格式进行拼接
Set<Map.Entry<Character, Integer>> entries = map.entrySet();
for (Map.Entry<Character, Integer> keyValue : entries) {
Character ch = keyValue.getKey();
Integer number = keyValue.getValue();
sb.append(ch).append("(").append(number).append(")");
}
//将StringBuffer转成字符串
String result = sb.toString();
System.out.println("统计结果为：" + result);
}
}
HashMap和Hashtable的区别
1、HashMap与Hashtable它们存储的元素都是一个一个的键值对
2、HashMap中的key和value允许为null值，而Hashtable不允许
3、Hashtable是线程安全的，而HashMap是线程不安全的
Collections工具类的概述：
针对集合操作的工具类
Collections与Collection的区别：
1、Collection是单列集合的顶层接口，有两大子接口List/Set
2、Collections是一个针对于集合操作的工具类，可以对集合进行排序，还有查找（二分查找）
public static <T> void sort(List<T> list) 从小到大排序
public static <T> int binarySearch(List<?> list,T key) 二分查找
public static <T> T max(Collection<?> coll) 最大值
public static void reverse(List<?> list) 反转
public static void shuffle(List<?> list) 随机置换
static <T> List<T> synchronizedList(List<T> list) 返回由指定列表支持的同步（线程安全）列表。
package com.shujia.wyh.day20;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsDemo1 {
public static void main(String[] args) {
//创建List集合对象
ArrayList<Integer> list = new ArrayList<>();
//将ArrayList转换成线程安全的集合，返回的集合和原本的是一个存储空间
List<Integer> list1 = Collections.synchronizedList(list);
//添加元素
list1.add(10);
list1.add(30);
list1.add(20);
list1.add(70);
list1.add(40);
list1.add(50);
System.out.println(list);
System.out.println(list1);
//public static <T> void sort(List<T> list)
Collections.sort(list);
System.out.println("排序后的集合："+list);
//排序后的集合：[10, 20, 30, 40, 50, 70]
//public static <T> binarySearch(List<?> list,T key):二分查找前提是有序
//二分查找，如果元素存在，返回该元素对应索引
System.out.println(Collections.binarySearch(list,70));
//public static <T> T max(Collection<?> coll):查找最大值
System.out.println(Collections.max(list));
//public static void reverse(List<?> list) 反转
Collections.reverse(list);
System.out.println(list);
//public static void shuffle(List<?> list):随机置换
Collections.shuffle(list);
System.out.println(list);
}
}
集合嵌套
ArrayList嵌套HashMap
package com.shujia.wyh.day20;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class ArrayListAndHashMap {
public static void main(String[] args) {
//定义一个ArrayList对象
ArrayList<HashMap<String, String>> list = new ArrayList<>();
//创建2个HashMap对象
HashMap<String, String> map1 = new HashMap<>();
map1.put("霞", "洛");
map1.put("卢锡安", "塞纳");
map1.put("蛮王", "寒冰");
map1.put("盖伦", "卡特");
HashMap<String, String> map2 = new HashMap<>();
map2.put("邓超", "孙俪");
map2.put("张杰", "谢娜");
map2.put("小虎", "冯提莫");
list.add(map1);
list.add(map2);
//遍历
for (HashMap<String, String> maps : list) {
Set<Map.Entry<String, String>> entries = maps.entrySet();
for (Map.Entry<String, String> keyValue : entries) {
String key = keyValue.getKey();
String value = keyValue.getValue();
System.out.println(key + ":" + value);
}
}
}
}
930
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
