乐趣区

关于java:Map集合-笔记

jiezi

Map 汇合

地图不能蕴含反复的键，每个键能够映射到最多一个值，是一个 接口，HashMap 保障键的唯一性

// 创立汇合对象
Map<String String> map = new HashMap<String String>(); 
//map 里增加元素 V put(K key , V value)将指定的值与该映射中的指定关键词相关联
map.put("itheima001","张曼玉")；map.put("itheima002","王祖贤")；map.put("itheima003","林青霞")；sout(map);


HahMap 重写了 toString 办法，把键和值用等号拼接起来，而后输入，键是惟一的，不能反复，当键反复的时候，咱们起初的值就会把以前的值笼罩掉

Map 汇合的基本功能

// 创立汇合对象
Map<String String> map = new HashMap<String String>(); 
//map 里增加元素 V put(K key , V value)
map.put("张无忌","赵敏")；map.put("郭靖","黄蓉")；map.put("杨过","小龙女")；// 依据键删除键值对元素 V remove(Object key); 而后返回键值对对应的元素
sout(map.remove(key:"郭靖"));// 输入键值郭靖对应的元素黄蓉
sout(map.remove(key:"郭襄"));// 输入键值对郭襄对应的元素，发现没有键值郭襄，所以返回空元素 null

// 革除所有键值对元素 void clear
map.clear()；// 判断汇合是否蕴含指定的键 boolean containsKey(Object key);
sout(map.containsKey(key:"郭靖"));// 判断汇合是否蕴含郭靖这个键，发现蕴含则返回 true；sout(map.containsKey(key:"郭襄"));// 判断汇合是否蕴含郭襄这个键，发现不蕴含就返回 false；// 判断汇合是否为空 boolean isEmpty
sout(map.isEmpty());

// 测试汇合长度 int size();
sout(map.size());

// 输入汇合对象
sout(map);


删除

清空

判断是否蕴含指定的键

判断汇合是否为空

测试汇合长度

Map 汇合的获取性能

// 依据键获取值 V get(Object key);
sout(map.get("张无忌"));
sout(map.get("张三丰"));// 如果说获取的键或者获取的键的元素在汇合中不存在就返回 null，如果存在就返回键对应额值

// 获取所有键的汇合 Set<K> keySet();
Set<String> keySet = map.keySet();
// 加强 for 循环遍历
for(String key : keySet){sout(key);
}

/// 获取所有值的汇合 Collection<V> values();
Collection<String> values = map.values();
// 加强 for 循环遍历
for(String value : values){sout(value);
}

依据键获取值

获取所有 键的汇合

获取所有 值的汇合

Map 汇合的遍历

形式一

遍历键，通过键去找对应的值再输入

// 获取所有键的汇合 Set<K> keySet();
Set<String> keySet = map.keySet();
// 加强 for 循环遍历每一个键
for(String key : keySet){
    // 依据键去找值，用 get 办法实现
   String value = map.get(key);
   sout(key +","+ value);
}

输入后果

形式二

获取所有键值对对象的汇合，找到对象提取外面的键和值

// 获取所有键值对对象的汇合 Set<Map.Entry<String ,String>> entrySet();
Set<Map.Entry<String ,String>> entrySet = map.entrySet();// 后面是键，前面是值
// 遍历键值对对象的汇合，失去每一个键值对对象
for(<map.Entry<String ,String> me : entrySet){
    // 依据键值对对象获取键和值
    String key = me.getKey();
    String value = me.getValue();
    sout(key +","+ value);
}

输入后果

案例 HashMap 存储学生对象并遍历


学生类

创立 HashMap 汇合

// 创立 HashMap 汇合对象 键是 String 类型，值是 student 类型
HashMap<String,Student> hm = new HashMap<String,Student>();
// 创立学生对象
Student s1 = mew Student(name:"林青霞",age:30);
Student s2 = mew Student(name:"张曼玉",age:35);
Student s3 = mew Student(name:"王祖贤",age:33);

// 将学生增加到汇合
hm.put("itheima001",s1);
hm.put("itheima002",s2);
hm.put("itheima003",s3);

// 遍历
// 形式 1 键找值
Set<String> keySet = hm.keySet();
// 加强 for 循环遍历每一个键
for(String key : keySet){
    // 依据键去找值，用 get 办法实现
   Student value = hm.get(key);
   sout(key +","+ value.getName()+","+ value.getAge());
}


// 形式 2 遍历键值对对象找键和值
Set<Map.Entry<String ,Student>> entrySet = hm.entrySet();// 后面是键，前面是值
for(<map.Entry<String ,Student> me : entrySet){
    // 依据键值对对象获取键和值
    String key = me.getKey();
    Student value = me.getValue();
    sout(key +","+ value.getName()+","+ value.getAge());
}

输入后果

案例 HashMap 存储学生对象并遍历（和下面不一样）

保障键的唯一性，自定义保障唯一性，这次学生作为键存在，并且保障唯一性 , 因为键是惟一的，所以学生就惟一，

学生类

创立 HashMap 汇合

// 创立 HashMap 汇合对象 键是 student 类型，值是 String 类型，HashMap<Student,String> hm = new HashMap<Student,String>();
// 创立学生对象
Student s1 = mew Student(name:"林青霞",age:30);
Student s2 = mew Student(name:"张曼玉",age:35);
Student s3 = mew Student(name:"王祖贤",age:33);

// 将学生增加到汇合 值是地位
hm.put(s1,"西安");
hm.put(s2,"武汉");
hm.put(s3,"郑州");

// 遍历
// 形式 1 键找值
Set<Student> keySet = hm.keySet();
// 加强 for 循环遍历每一个键
for(Student key : keySet){
    // 依据键去找值，用 get 办法实现
   String value = hm.get(key);
   sout(key.getName() +","+ key.getAge()+","+value);
}

输入

如果我新建的两个对象成员内容是一样的，那么咱们认为是同一个对象，反复的元素，所以 s4 在增加的时候如果键是一样的，s4 应该会笼罩掉 s3 的地位
// 创立 HashMap 汇合对象 键是 student 类型，值是 String 类型，HashMap<Student,String> hm = new HashMap<Student,String>();
// 创立学生对象
Student s1 = mew Student(name:"林青霞",age:30);
Student s2 = mew Student(name:"张曼玉",age:35);
Student s3 = mew Student(name:"王祖贤",age:33);

Student s4 = mew Student(name:"王祖贤",age:33);

// 将学生增加到汇合 值是地位
hm.put(s1,"西安");
hm.put(s2,"武汉");
hm.put(s3,"郑州");

hm.put(s4,"北京");

// 遍历
// 形式 1 键找值
Set<Student> keySet = hm.keySet();
// 加强 for 循环遍历每一个键
for(Student key : keySet){
    // 依据键去找值，用 get 办法实现
   String value = hm.get(key);
   sout(key.getName() +","+ key.getAge()+","+value);
}

键雷同值应该笼罩掉 ，如果笼罩掉须要 重写 hashCode()和 equals()办法

重写 alt+insert 重写

案例 ArrayList 汇合存储 HashMap 元素并遍历


// 创立 ArrayList 汇合
ArrayList<HashMap<String,String>> array = new ArrayList<HashMap<String,String>>();

// 创立 HashMap 汇合并增加键值对元素
HashMap<String String> hm1 = new HashMap<String String>(); 
hm1.put("孙策","大乔");
hm1.put("周瑜","小乔");
// 把 HashMap 作为元素增加到 ArrayList 汇合
array.add(hm1);

HashMap<String String> hm2 = new HashMap<String String>(); 
hm2.put("郭靖","黄蓉");
hm2.put("杨过","小龙女");
// 把 HashMap 作为元素增加到 ArrayList 汇合
array.add(hm2);

HashMap<String String> hm3 = new HashMap<String String>(); 
hm3.put("令狐冲","任盈盈");
hm3.put("林平之","岳灵珊");
// 把 HashMap 作为元素增加到 ArrayList 汇合
array.add(hm3);


// 遍历 ArrayList 汇合
for(HashMap<String String> hm : array){Set<String> keySet = hm.KeySet();
    for(String key : keySet){String value = hm.get(key);
        sout(key +","+ value);
    }
}

输入后果

案例 HashMap 汇合存储 ArrayList 元素并遍历


// 创立 HashMap 汇合, 键是 String 类型，值是 ArrayList 类型
HashMap<String ,ArrayList<String>> hm = new HashMap<String ArrayList<String>>(); 

// 创立 ArrayList 汇合，并增加元素
ArrayList<String> sgyy = new ArrayList<String>();
// 增加元素
sgyy.add("诸葛亮");
sgyy.add("赵云");
// 把 ArrayList 汇合作为元素增加到 HashMap 汇合
hm.put("三国演义",sgyy);


// 创立 ArrayList 汇合，并增加元素
ArrayList<String> xyj = new ArrayList<String>();
// 增加元素
xyj.add("唐僧");
xyj.add("孙悟空");
// 把 ArrayList 汇合作为元素增加到 HashMap 汇合
hm.put("西游记",xyj);


// 创立 ArrayList 汇合，并增加元素
ArrayList<String> shz = new ArrayList<String>();
// 增加元素
shz.add("武松");
shz.add("鲁智深");
// 把 ArrayList 汇合作为元素增加到 HashMap 汇合
hm.put("水浒传",shz);

// 遍历 遍历 HashMap 汇合
Set<String> keySet = hm.KeySet();
for(String key : keySet){sout(key);
    ArrayList<String> value = hm.get(key);
    // 遍历 ArrayList 汇合
    for(String s : value){sout("\t"+s);
    } 
}

输入后果

案例 统计字符串中每个字符呈现的次数


// 键盘录入一个字符串
Scanner sc = new Scanner(System.in);
sout("请输出一个字符串:");
String line = sc.nextLine();

// 创立 HashMap 汇合，键是 Character，值是 Interger
HashMap<Character, Interger> hm = new HashMap<Character, Interger>(); 

// 遍历字符串失去每一个字符
for(int i = 0;i<line.length();i++){char key = line.charAt(i);
    // 拿失去的每一个字符作为键到 HashMap 汇合中去找对应额值，看其返回值
    Interger value = hm.get(key);
    if(value == null){
        // 如果返回值是 null，阐明该字符再 HashMap 汇合中不存在，就把该字符作为键，1 为值存储
        hm.put(key,1);
    }else{
        // 如果返回值不是 null，阐明该字符再 HashMap 汇合中是存在的，就把该值加 1，而后从新存储该字符和对应的值
        value++;
        hm.put(key,value);
    }
}
// 遍历 HashMap 汇合，失去键和值，依照要求进行拼接 拼接用 StringBuilder
StringBuilder sb = new StringBuilder();

Set<Character> keySet = hm.keySet();
for(Character key : keySet){Interger value = hm.get(key);
    sb.append(key).append("(").append(value).append(")");    
}// 此时外面四 StringBuilder 类型，须要转化成 String 类型
String result = sb.toString();

// 输入后果
sout(result);


TreeMap 能够对键进行排序

退出移动版