集合（四）Map
Collection集合和Map集合的区别:java
a: Map集合属于双列集合 , Collection属于单列集合 安全
b: Map集合键是惟一性的, 而Collection集合中的Set集合能够保证元素的惟一性数据结构
c: Map集合的数据结构只和键有关系 ,和值没有关系 , 而Collection集合的数据结构和元素有关系app
Map集合是一个接口 , 接口不能直接实例化 , 若是咱们要对其进行实例化,那么就须要使用子类 , HashMap 和 TreeMapide
Map集合的功能概述:工具
a: 添加元素学习
V put(K key, V value) 添加元素测试
b: 删除元素ui
void clear() 删除全部的元素spa
V remove(Object key) 根据键删除元素
c: 获取元素
V get(Object key) 根据键获取值
Set<K> keySet() 获取全部的键对应的Set集合
int size() 获取集合的长度
Collection<V> values() 获取全部的值对应Collection
d: 判断该功能
boolean containsKey(Object key) 判断是否包含某一个键
boolean containsValue(Object value) 判断是否包含某一个值
boolean isEmpty() 判断集合是否为空
e: 遍历Map集合
（1） 键找值
分析:
a: 获取全部的键对应的Set集合
b: 遍历这个Set集合, 获取每个元素 , 而每个元素就是键 , 而后根据当前遍历的键获取对应的值
（2）根据键值对象遍历集合
Set<Map.Entry<K,V>> entrySet(): 获取的是全部的键值对对象对应的set集合
分析:
a: 调用entrySet方法获取全部的键值对对象对应的Set集合
b: 遍历这个Set集合, 获取每个元素,而每个元素应该是键值对对象 , 而后咱们调用方法 ,从这个键值对对象中获取对应的键和值
HashMap的两种遍历方式：
* 请编写程序，存储自定义对象到HashMap集合中，并采用两种方式遍历
*/
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class HashMapDemo {
public static void main(String[] args) {
Student s1 = new Student("李时珍",50);
Student s2 = new Student("蒲松龄",39);
Student s3 = new Student("曹雪芹",41);
//1.建立HashMap对象，键为String类型，值为Student类型
HashMap<String, Student> hs = new HashMap<String,Student>();
//将自定义对象加入集合
hs.put("本草纲目", s1);
hs.put("聊斋志异", s2);
hs.put("红楼梦", s3);
//遍历，根据键获取对象
Set<String> keySet = hs.keySet();
for(String k:keySet){
Student st = hs.get(k);
System.out.println(k+"---"+st.getName()+"---"+st.getAge());
}
System.out.println("----------------------------------------");
//2.建立HashMap对象，key为Student类，value为String类型
HashMap<Student,String> hs2 = new HashMap<Student,String>();
//将自定义对象加入集合
hs2.put(s3, "红楼梦");
hs2.put(s2, "聊斋志异");
hs2.put(s1, "本草纲目");
//遍历,使用entrySet方法，将全部键值对的对象存入Set集合中，而后根据键值对象获取键与值
Set<Entry<Student, String>> entrySet = hs2.entrySet();
for(Entry<Student, String> en : entrySet){
Student st = en.getKey();
System.out.println(st.getName()+"---"+st.getAge()+"---"+en.getValue());
}
}
}
/*
* 红楼梦---曹雪芹---41
聊斋志异---蒲松龄---39
本草纲目---李时珍---50
----------------------------------------
李时珍---50---本草纲目
曹雪芹---41---红楼梦
蒲松龄---39---聊斋志异
*/
TreeMap:
TreeMap集合的特色: 底层的数据结构是二叉树, 能够对元素进行排序
而排序有两种方式
第一种是天然排序 public TreeMap()
对元素有要求 , 要求元素必须实现 Comparable 接口
第二种是比较器排序 public TreeMap(Comparator comparator)
咱们到底使用的是天然排序仍是比较器排序主要依赖于构造方法
Map集合的数据结构只和键有关系,和值没有关系
TreeMap的两种遍历方式
/*
* 请编写程序，存储自定义对象到TreeMap集合中，并采用两种方式遍历.
*/
import java.util.Map.Entry;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo {
public static void main(String[] args) {
//建立自定义对象
Student s1 = new Student("曹雪芹",41);
Student s2 = new Student("蒲松龄",39);
Student s3 = new Student("李时珍",50);
//使用TreeMap类中的比较器进行排序
TreeMap<Student, String> tm = new TreeMap<Student,String>(new Comparator<Student>() {
//重写Comparator的compare方法
@Override
public int compare(Student st1, Student st2) {
// TODO Auto-generated method stub
//比较年龄
int num = st1.getAge()-st2.getAge();
//比较姓名
int num2 = (num==0)?st1.getName().compareTo(st2.getName()):num;
return num2;
}
}
);
//将键值对添加入TreeSet集合中
tm.put(s3, "本草纲目");
tm.put(s2, "聊斋志异");
tm.put(s1, "红楼梦");
//1.使用键值对对象遍历TreeMap集合
//将TreeSet键值对对象存储到set集合中
Set<Entry<Student, String>> entrySet = tm.entrySet();
//用键值对对象获取key,value值
for(Entry<Student, String> en :entrySet){
Student key = en.getKey();
String value = en.getValue();
System.out.println(key.getName()+"---"+key.getAge()+"----"+value);
}
//2.根据获取到的key去获取value
System.out.println("-----------------------------------------------------------");
Set<Student> st = tm.keySet();
//遍历
for(Student sNum:st){
System.out.println(sNum.getName()+"---"+sNum.getAge()+"---"+tm.get(sNum));
}
}
}
/*
* 结果:
蒲松龄---39----聊斋志异
曹雪芹---41----红楼梦
李时珍---50----本草纲目
-----------------------------------------------------------
蒲松龄---39---聊斋志异
曹雪芹---41---红楼梦
李时珍---50---本草纲目
*/
最后再举几个使用Map集合的例子
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
/*
* 需求:统计字符串中每一个字符出现的次数 "aababcabcdabcde",获取字符串中每个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
*
* 要点:1.根据HashMap集合的特色去存储字符的出现次数
* 2.对于HashMap的遍历方式进行学习与理解
* 3.选用StringBuffer进行拼接，减小内存资源的消耗
* 4.更优的方式是使用StringBuilder进行拼接，由于StringBuffer是线程安全的，拼接速度较慢。StringBuilder是线程不安全的，
* 适用于单线程任务，速度更快
*/
public class HashMapTest {
public static void main(String[] args) {
//定义一个字符串
String st = "aababcabcdabcde";
//建立一个HashMap集合
HashMap<Character,Integer> hs = new HashMap<Character,Integer>();
//遍历字符串，将字符串添加到HashMap集合中去
for(int i = 0;i<st.length();i++){
char charAt = st.charAt(i);
//將要查找的字符做為鍵，去HashMap中去查找
Integer num = hs.get(charAt);
//若是不存在，將其值num赋值为1
if(num==null){
hs.put(charAt, 1);
}
//若是已经存在该键，将该键的值+1，
else{
num++;
hs.put(charAt, num);
}
}
//测试HashMap中的结果
//System.out.println(hs);
//建立StringBuffer对象，按照要求进行拼接
StringBuffer stb = new StringBuffer();
//遍历HashMap集合，按照指定格式进行输出
//将HashMap集合对对象存储到Set集合中
Set<Entry<Character, Integer>> entrySet = hs.entrySet();
//分别获取Set集合中的键值对对象的key，value值，而后进行拼接
for( Entry<Character, Integer> en:entrySet){
stb.append(en.getKey()).append("(").append(en.getValue()).append(")");
}
//输出
System.out.println(stb.toString());
}
}
/*结果:
* a(5)b(4)c(3)d(2)e(1)
*/
集合嵌套的使用
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
/*集合嵌套实例：
* HashMap的嵌套
*明:
* 李时珍 本草纲目
*清：
* 曹雪芹 红楼梦
* 蒲松龄 聊斋志异
*/
public class HashMapNest {
public static void main(String[] args) {
//建立嵌套HashMap集合对象
HashMap<String,HashMap<String, String>> hm = new HashMap<String,HashMap<String,String>>();
//建立明朝做者，书籍集合对象
HashMap<String, String> hMing = new HashMap<String,String>();
//添加明朝集合中的key,value值
hMing.put("李时珍", "本草纲目");
//建立清朝做者，书籍对象
HashMap<String, String> hQing = new HashMap<String,String>();
hQing.put("蒲松龄", "聊斋志异");
hQing.put("曹雪芹", "红楼梦");
//将小范围集合添加进大范围集合中
hm.put("明", hMing);
hm.put("清", hQing);
//遍历集合
//获取外集合键值对对象
Set<Entry<String, HashMap<String, String>>> entrySet = hm.entrySet();
for(Entry<String, HashMap<String, String>> en:entrySet){
//获取键值
String key1 = en.getKey();
System.out.println(key1+":");
//获取外集合value值(即内集合)
HashMap<String,String> hm2 = en.getValue();
//获取内集合键值对对象
Set<Entry<String, String>> entrySet2 = hm2.entrySet();
for(Entry<String, String> en2:entrySet2){
//获取内集合键值
String key2 = en2.getKey();
System.out.println(key2+"---"+en2.getValue());
}
}
}
}
/*
清:
蒲松龄---聊斋志异
曹雪芹---红楼梦
明:
李时珍---本草纲目
*/
HashMap和HashSet的区别
HashMap 线程不安全 , 效率高 , 容许存在null值和null键
Hashtable 线程安全, 效率低 , 不容许在null值和null键
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):随机置换
- 1. 集合（四）: Map
- 2. Java学习|集合（四）——Map
- 3. Java：集合框架（四）Map详解
- 4. 遍历Map集合四中方法
- 5. Map集合的四种遍历方式
- 6. Java集合----Map集合
- 7. map集合(双列集合)
- 8. Set集合、Map集合
- 9. Map集合
- 10. Java集合Map
- 更多相关文章...
- • Scala Set(集合) - Scala教程
- • C# 集合（Collection） - C#教程
- • RxJava操作符（四）Combining
- • ☆技术问答集锦（13）Java Instrument原理
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Window下Ribbit MQ安装
- 2. Linux下Redis安装及集群搭建
- 3. shiny搭建网站填坑战略
- 4. Mysql8.0.22安装与配置详细教程
- 5. Hadoop安装及配置
- 6. Python爬虫初学笔记
- 7. 部署LVS-Keepalived高可用集群
- 8. keepalived+mysql高可用集群
- 9. jenkins 公钥配置
- 10. HA实用详解
- 1. 集合（四）: Map
- 2. Java学习|集合（四）——Map
- 3. Java：集合框架（四）Map详解
- 4. 遍历Map集合四中方法
- 5. Map集合的四种遍历方式
- 6. Java集合----Map集合
- 7. map集合(双列集合)
- 8. Set集合、Map集合
- 9. Map集合
- 10. Java集合Map