目录Map集合Map集合概述和特点Map集合的功能Map集合的遍历-键值对对象找键和值Map集合的遍历-键找值Map集合案例：键是String，值是StudentLinkedHashMap的概述和使用TreeMap集合集合嵌套HashMap嵌套HashMapHashMap嵌套ArrayListArrayList嵌套HashMapHashMap和Hashtable的区别Collections工具类常见方法Map集合Map集合概述和特点
目录
Map集合
Map集合概述和特点
1）Map集合是一个将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值。
2）Map与Collection的不同：
Map是双列的，Collection是单列的；
Map的键唯一，Collection的子体系Set是唯一的；
Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效。
Map集合的功能
添加功能：
//该方法的作用是向Map集合中添加元素 (键值对)，如果键是第一次存储，就直接存储元素，返回null；如果键不是第一次存在，就用新值替换以前的值，并把以前的值返回。 V put(K key, V value)
删除功能：
//移除所有的键值对元素 void clear() //根据 键 删除键值对元素，并把该元素返回 V remove(Object key)
判断功能：
//判断集合是否包含指定的键 boolean containsKey(Object key) //判断集合是否包含指定的值 boolean containsValue(Object value) //判断集合是否为空 boolean isEmpty()
获取功能：
//返回一个键值对的Set集合 Set<Map.Entry<K,V>> entrySet() //根据键获取值 V get(Object key) //获取集合中所有键的集合 Set<K> keySet() //获取集合中所有的集合 Collection<V> values()
长度功能
//返回集合中的键值对的对数 int size()
Map集合的遍历-键值对对象找键和值
创建HashMap集合，向集合中添加数据，使用forEach遍历集合获取键值对对象，打印键和值
import java.util.HashMap;
import java.util.function.BiConsumer;
public class Test {
public static void main(String[] args) {
HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(12,"aa");
hashMap.put(14,"bb");
hashMap.put(62,"cc");
hashMap.put(42,"dd");
hashMap.forEach(new BiConsumer<Integer, String>() {
@Override
public void accept(Integer integer, String s) {
System.out.println(integer+"="+s);
}
});
}
}
Map集合的遍历-键找值
创建HashMap集合，向集合中添加数据，keySet()方法获取集合中所有键的集合，遍历获取到的集合，使用get()方法打印键值对。
import java.util.HashMap;
import java.util.Set;
public class Test2 {
public static void main(String[] args) {
//Map集合的遍历-键找值
HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(12, "aa");
hashMap.put(14, "bb");
hashMap.put(62, "cc");
hashMap.put(42, "dd");
Set<Integer> keys = hashMap.keySet();
for (Integer key : keys) {
String s = hashMap.get(key);
System.out.println(key + "=" + s);
}
}
}
Map集合案例：键是String，值是Student
Student类，重写了equals()、toString()等方法，
import java.util.Objects;
public class Student {
private String name;
private int age;
public String getName() {
return name;
}
public int getAge() {
return age;
}
public Student(String name, int age) {
this.name = name;
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);
}
}测试类
import java.util.HashMap;
import java.util.Set;
import java.util.function.BiConsumer;
public class Test3 {
public static void main(String[] args) {
//创建HashMap集合，泛型写为<String, Student>
HashMap<String, Student> hashMap = new HashMap<>();
//存储key和value
hashMap.put("s01", new Student("Alice", 18));
hashMap.put("s02", new Student("Helen", 19));
hashMap.put("s03", new Student("Jack", 22));
hashMap.put("s05", new Student("Jack", 22));
//删除key为"s05"的元素,返回值为删除的键值对的value
Student s05_0 = hashMap.remove("s05");
System.out.println("删除的\"s05\"元素："+s05_0);
System.out.println("----------------");
//判断目前集合中是否存在key为"s05"的元素,存在返回true
boolean s05_1 = hashMap.containsKey("s05");
System.out.println("集合是否存在key为\"s05\"的元素："+s05_1);
System.out.println("----------------");
//判断目前集合中是否存在value为Student("Jack",22)的元素，存在返回true
boolean jack = hashMap.containsValue(new Student("Jack", 22));
System.out.println("集合中是否存在value为 Student(\"Jack\",22) 的元素："+jack);
System.out.println("----------------");
//获取集合中的所有键
Set<String> keySet = hashMap.keySet();
System.out.println("集合中的所有键："+keySet);
System.out.println("----------------");
//遍历集合
hashMap.forEach(new BiConsumer<String, Student>() {
@Override
public void accept(String s, Student student) {
System.out.println("s="+s+", "+student);
}
});
}
}
LinkedHashMap的概述和使用
LinkedHashMap集合是通过 Map 接口的哈希表和链表实现的，具有可预知的迭代顺序。
LinkedHashMap的特点：
1）底层的数据结构是链表和哈希表，元素有序且唯一
2）元素的有序性由链表数据结构保证，唯一性由哈希表的数据结构保证
TreeMap集合
特点
1）键不允许插入 null
2）键的数据结构是红黑树，可以保证键的排序和唯一性
3）有两种排序方式：自然排序和比较器排序
4）线程不安全，但效率高
统计字符串中每个字符出现的次数
测试字符串为"aababcabcdabcde" , 要求输出结果为 a(5)b(4)c(3)d(2)e(1)
import java.util.TreeMap;
import java.util.function.BiConsumer;
public class Test4 {
public static void main(String[] args) {
String str = "aababcabcdabcde";
TreeMap<Character, Integer> treeMap = new TreeMap<>();
//将字符串转换为字符数组，方便存储
char[] chars = str.toCharArray();
//先在集合中存入所出现的键
for (char c : chars) {
treeMap.put(c,0);
}
//遍历数组，将重复出现的键的值覆盖
for (char c : chars) {
treeMap.put(c,treeMap.get(c)+1);
}
//遍历集合，按要求格式打印
treeMap.forEach(new BiConsumer<Character, Integer>() {
@Override
public void accept(Character character, Integer integer) {
System.out.print(character+"("+integer+")");
}
});
}
}
集合嵌套
HashMap嵌套HashMap
要求使用HashMap集合进行嵌套，并遍历集合在控制台打印一下格式的信息
基础班 张三 20 李四 22 就业班 王五 21 赵六 23
import java.util.HashMap;
import java.util.function.BiConsumer;
public class Test5 {
public static void main(String[] args) {
HashMap<String, Integer> littleMap1 = new HashMap<>();
HashMap<String, Integer> littleMap2 = new HashMap<>();
littleMap1.put("张三", 20);
littleMap1.put("李四", 22);
littleMap2.put("王五", 21);
littleMap2.put("赵六", 23);
HashMap<String, HashMap<String, Integer>> bigMap = new HashMap<>();
bigMap.put("基础班", littleMap1);
bigMap.put("就业班", littleMap2);
//遍历大集合
bigMap.forEach(new BiConsumer<String, HashMap<String, Integer>>() {
@Override
public void accept(String s, HashMap<String, Integer> stringIntegerHashMap) {
System.out.println(s);
//遍历小集合
stringIntegerHashMap.forEach(new BiConsumer<String, Integer>() {
@Override
public void accept(String s, Integer integer) {
System.out.println("\t\t"+s+" "+integer);
}
});
}
});
}
}
HashMap嵌套ArrayList
要求使用HashMap集合嵌套ArrayList集合，存储以下数据，并按照格式打印在控制台
三国演义 吕布 周瑜 笑傲江湖 令狐冲 林平之 神雕侠侣 郭靖 杨过
import java.util.ArrayList;
import java.util.HashMap;
import java.util.function.BiConsumer;
public class Test6 {
public static void main(String[] args) {
//创建小集合ArrayList
ArrayList<String> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
ArrayList<String> list3 = new ArrayList<>();
//向小集合中录入数据
list1.add("吕布");
list1.add("周瑜");
list2.add("令狐冲");
list2.add("林平之");
list3.add("郭靖");
list3.add("杨过");
//创建大集合HashMap,并添加数据
HashMap<String, ArrayList<String>> map = new HashMap<>();
map.put("三国演义", list1);
map.put("笑傲江湖", list2);
map.put("神雕侠侣", list3);
//遍历大集合
map.forEach(new BiConsumer<String, ArrayList<String>>() {
@Override
public void accept(String s, ArrayList<String> strings) {
System.out.println(s);
//遍历小集合
for (String string : strings) {
System.out.println("\t\t"+string);
}
}
});
}
}ArrayList嵌套HashMap
需求：ArrayList集合的元素是HashMap，有三个，每一个HashMap集合的键和值都是字符串，创建集合并且录入数据，打印在控制台
周瑜---小乔 吕布---貂蝉 郭靖---黄蓉 杨过---小龙女 令狐冲---任盈盈 林平之---岳灵珊
import java.util.ArrayList;
import java.util.HashMap;
import java.util.function.BiConsumer;
public class Test7 {
public static void main(String[] args) {
//创建3个小集合HashMap
HashMap<String, String> hashMap1 = new HashMap<>();
HashMap<String, String> hashMap2 = new HashMap<>();
HashMap<String, String> hashMap3 = new HashMap<>();
//在小集合中录入数据
hashMap1.put("周瑜", "小乔");
hashMap1.put("吕布", "貂蝉");
hashMap1.put("郭靖", "黄蓉");
hashMap1.put("杨过", "小龙女");
hashMap1.put("令狐冲", "任盈盈");
hashMap1.put("林平之", "岳灵珊");
//创建大集合ArrayList
ArrayList<HashMap<String, String>> list = new ArrayList<>();
list.add(hashMap1);
list.add(hashMap2);
list.add(hashMap3);
//遍历大集合
for (HashMap<String, String> hashMap : list) {
//遍历小集合
hashMap.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String s, String s2) {
System.out.println(s + "===" + s2);
}
});
}
}
}
HashMap和Hashtable的区别
1）HashMap，线程不安全,效率高.允许null值和null键。
2）Hashtable:，线程安全 , 效率低.不允许null值和null键。
Collections工具类
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)
613
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
