本文深入讲解Java中的Map集合，包括HashMap、LinkedHashMap、TreeMap等不同实现的特点与使用场景，同时提供丰富的示例代码帮助理解。
18.01_集合框架(Map集合概述和特点)
A: 需求: 根据学号获取学生姓名
import java.util.ArrayList;
import java.util.HashMap;
public class text1 {
public static void main(String[] args) {
HashMap<Student,String>hashMap=new HashMap<>();
hashMap.put(new Student("张三",16),"s001");
hashMap.put(new Student("李四",18),"s002");
hashMap.put(new Student("王五",13),"s003");
System.out.println(hashMap);
}
}
B:Map接口概述
查看API可以知道：
将键映射到值的对象
一个映射不能包含重复的键
每个键最多只能映射到一个值
C:Map接口和Collection接口的不同
Map是双列的,Collection是单列的
Map的键唯一,Collection的子体系Set是唯一的
Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效
18.02_集合框架(Map集合的功能概述)
A: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(): 返回一个键值对的Set集合
V get(Object key):根据键获取值
Set<K> keySet():获取集合中所有键的集合
Collection<V> values():获取集合中所有值的集合
e:长度功能
int size()：返回集合中的键值对的对数
18.03_集合框架(Map集合的基本功能测试)
A:案例演示
Map集合的基本功能
V put(K key,V value)//键相同 值覆盖
import java.util.HashMap;
public class text5 {
public static void main(String[] args) {
HashMap<String,Integer>hashMap=new HashMap<>();
hashMap.put("aaa",1);
hashMap.put("bbb",2);
hashMap.put("aaa",3);
hashMap.put("bbb",4);
System.out.println(hashMap);
}
}
V remove(Object key)
void clear()
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
int size()
import java.util.HashMap;
public class text5 {
public static void main(String[] args) {
HashMap<String,Integer>hashMap=new HashMap<>();
hashMap.put("aaa",1);
hashMap.put("bbb",2);
hashMap.put("ccc",3);
hashMap.put("aaa",3);
hashMap.put("bbb",4);
System.out.println(hashMap);
hashMap.remove("aaa");
System.out.println(hashMap);
boolean b=hashMap.containsKey("bbb");
System.out.println(b);
boolean a=hashMap.containsValue("3");
System.out.println(a);
boolean c=hashMap.isEmpty();
System.out.println(c);
hashMap.clear();
c=hashMap.isEmpty();
System.out.println(c);
}
}
18.04_集合框架(Map集合的获取功能测试)
A:案例演示
V get(Object key)
Set<K> keySet()
Collection<V> values()
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;
public class text6 {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("文章", "马伊琍");
map.put("贾乃亮", "李小璐");
map.put("陈思成", "佟丽娅");
map.put("大郎", "金莲");
//键找值
String value=map.get("文章");
//获取所有键的集合
Set<String> keySet=map.keySet();
for(String key:keySet)
{
System.out.println(key+"==="+map.get(key));
}
System.out.println("------------");
//获取所有值得集合
Collection<String>collection=map.values();
System.out.println(collection);
}
}
18.05_集合框架(Map集合的遍历之键找值)
A:键找值思路：
获取所有键的集合
遍历键的集合，获取到每一个键
根据键找值
B:案例演示
Map集合的遍历之键找值
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class text6 {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("文章", "马伊琍");
map.put("贾乃亮", "李小璐");
map.put("陈思成", "佟丽娅");
map.put("大郎", "金莲");
//键找值
String value=map.get("文章");
//获取所有键的集合
Set<String> keySet=map.keySet();
for(String key:keySet)
{
System.out.println(key+"==="+map.get(key));
}
System.out.println("------------");
//获取所有值得集合
Collection<String>collection=map.values();
System.out.println(collection);
Set<Map.Entry<String,String>>entries=map.entrySet();
for(Map.Entry<String,String> k:entries)
{
String a=k.getKey();
String b=k.getValue();
System.out.println(a+"==="+b);
}
}
}
总结 ：共两种方法
遍历方式1：
通过键值来遍历
Set<String> keySet=map.keySet()//keySet()获取到 map集合中的所有键值
for(String key:ketSet)
{
System.out.println(key+"===="+map.get(key));//get()通过键找到 值
}
18.08_集合框架(HashMap集合键是Stirng值是String的案例)
HashMap 允许插入null键 null值
import java.util.HashMap;
public class text7 {
public static void main(String[] args) {
HashMap<String,Integer>hashMap=new HashMap<>();
hashMap.put(“abc”,100);
hashMap.put(null,200);
hashMap.put(“bbb”,null);
hashMap.put(null,null);
System.out.println(hashMap);
}
}
输出
{null=null, abc=100, bbb=null}
Hashtable和HashMap 的区别
// HashMap 允许存储null键和null值 线程不安全效率高
//Hashtable 不允许null键和null值 线程安全效率低
Hashtable<String, String> hashtable = new Hashtable<>();
//hashtable.put(null,"abc"); 报错，不允许null键和null值
18.09_集合框架(HashMap集合键是String值是Student的案例)
A:案例演示: HashMap集合键是String值是Student的案例
###18.10_集合框架(HashMap集合键是Student值是String的案例)(掌握)
键唯一 注意重写hashCode方法 和 equals 方法
A:案例演示: HashMap集合键是Student值是String的案例
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@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 text7 {
public static void main(String[] args) {
HashMap<Student,String>hashMap=new HashMap<>();
hashMap.put(new Student("张三",18),"学生");
hashMap.put(new Student("李四",26),"工人");
hashMap.put(new Student("王五",56),"科学家");
System.out.println(hashMap);
}
}
18.11_集合框架(LinkedHashMap的概述和使用)(了解)
A:LinkedHashMap的概述: Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序
B:LinkedHashMap的特点： 底层的数据结构是链表和哈希表 元素有序 并且唯一
元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证
Map集合的数据结构只和键有关
C:案例演示: LinkedHashMap的特点
import java.util.LinkedHashMap;
public class text8 {
public static void main(String[] args) {
LinkedHashMap<Integer,String> linkedHashMap=new LinkedHashMap<>();
linkedHashMap.put(60, "abc");
linkedHashMap.put(313, "abc");
linkedHashMap.put(10,"abc");
linkedHashMap.put(20, "abc");
linkedHashMap.put(30, "abc");
linkedHashMap.put(40, "abc");
linkedHashMap.put(50, "abc");
linkedHashMap.put(60, "abc");
linkedHashMap.put(70, "abc");
linkedHashMap.put(70, "abcdddd");
System.out.println(linkedHashMap);
}
}
输出
{60=abc, 313=abc, 10=abc, 20=abc, 30=abc, 40=abc, 50=abc, 70=abcdddd}
18.12_集合框架(TreeMap集合键是String值是String的案例)(掌握)
TreeMap 键不允许插入null
A: TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性
排序分为自然排序和比较器排序
线程是不安全的效率比较高
18.13_集合框架(TreeMap集合键是Student值是String的案例)(掌握)
A:案例演示: TreeMap集合键是Student值是String的案例
按照年龄大小进行排序
注意键要实现Comparable 接口
import java.util.Objects;
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {
}
public Student(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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@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 compareTo(Student o) {
int i=this.age-o.age;
int j=i==0?this.getName().compareTo(o.getName()):i;
return j;
}
}
主类
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class text9 {
public static void main(String[] args) {
TreeMap<Student,Integer>treeMap=new TreeMap<>();
treeMap.put(new Student("aaa",16),1);
treeMap.put(new Student("bbb",20),2);
treeMap.put(new Student("ccc",21),3);
treeMap.put(new Student("ddd",16),4);
treeMap.put(new Student("eee",15),5);
treeMap.put(new Student("eee",15),5);
Set<Map.Entry<Student,Integer>> entries=treeMap.entrySet();
for(Map.Entry<Student,Integer> en:entries)
{
Student key=en.getKey();
int a=en.getValue();
System.out.println(key.getName()+"==="+key.getAge()+"===="+a);
}
}
}
18.14_集合框架(统计字符串中每个字符出现的次数)(理解)
A:案例演示: 需求：统计字符串中每个字符出现的次数
"aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
public class MyTest {
public static void main(String[] args) {
//A:
//案例演示:
//需求：统计字符串中每个字符出现的次数
//"aababcabcdabcde", 获取字符串中每一个字母出现的次数要求结果:a(5) b(4) c(3) d(2) e(1)
Scanner scanner = new Scanner(System.in);
System.out.println("请随便输入一行字符");
String line = scanner.nextLine();
// "aababcabcdabcde"
// a(5) b(4) c(3)d(2) e(1)
//思路：
/*
* a-----5
* b------4
* c------3
* d------2
* e------1
* 通过观察，发现这个数据是键值对的数据，那我就会想到用Map 集合来存储这个数据
*
* 难点，在于我们要把用户输入的数据，存到集合中，还要统计一下个数
*
*
* */
HashMap<Character, Integer> hashMap = new HashMap<>();
for (int i = 0; i < line.length(); i++) {
//截取字符，作为键，存到集合中
//"aaababcabcdabcde"
char ch = line.charAt(i);
if(!hashMap.containsKey(ch)){
hashMap.put(ch,1);
}else{
Integer integer = hashMap.get(ch);
integer++;
hashMap.put(ch,integer); //键相同，值覆盖
}
}
// System.out.println(hashMap);
//当这些数据存进去后，遍历集合，拼串拼成我想要的形状
// a(5) b(4) c(3) d(2) e(1)
StringBuilder sb = new StringBuilder();
Set<Character> keySet = hashMap.keySet();
for (Character key : keySet) {
sb.append(key).append("(").append(hashMap.get(key)).append(")");
}
String s = sb.toString();
System.out.println(s);
}
}
18.19_集合框架(Collections工具类的概述和常见方法讲解)(掌握)
A:Collections类概述: 针对集合操作 的工具类
B: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): 随机置换
C:案例演示: Collections工具类的常见方法讲解
扫一扫
1139
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
