Map集合

目录

一、map集合的增删改查

 二、遍历方式

三、常用实现类Hashmap

四、泛型

五、集合框架工具类

一、map集合的增删改查

package com.LX.map;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Demo1 {
public static void main(String[] args) {
    
    Map map=new HashMap<>();
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", 3);
        map.put("d", 4);
        
    //增加
    System.out.println("增加后的集合"+map);
    //移除
    Object  remove=map.remove("a");
    //打印移除的值
    System.out.println("移除的值"+remove);
    System.out.println("移除后的集合"+map);
//    
    //修改
    map.put("c", 123);
    System.out.println("修改的集合"+map);

    //查询
    System.out.println("根据键拿到的值为："+map.get("c"));
   
   
}    
}
 

 二、遍历方式

（1）增强for循环

//先拿到所有的键key集合
    System.out.println("=======增强for循环遍历========");
       Set keys=map.keySet();
    for (Object k : keys) {
        System.out.println("键："+k+",值："+map.get(k));
    }

 

（2）映射方式

//映射方式遍历
    System.out.println("=======映射方式遍历========");
    Set> entryset =map.entrySet();
    for (Entry entry : entryset) {
        System.out.println("键："+entry.getKey()+"值："+entry.getValue());
    }

---

三、常用实现类Hashmap

实现思路：
         * 1.做字符串切割，得到一个字符数组
         * 2.遍历拿到单个字符
         * 3.如果该字符没有出现过，即value值为null,那么该字符为key,值初始化为1
         * 4.如果已经出现过则原来值加1

用途：统计字符串各字母出现的次数 

          

       需求1：根据字母排序

 String s="kjnbcdieuyejjdjsjsnkjk";
        char[] arr =s.toCharArray();//字符串分割
        Map map=new HashMap<>();//字符集合
        for (char c : arr) {//遍历单个字符
            Integer value=map.get(c);//拿到值
            if(value==null) {
                map.put(c, 1);
            }else {
                map.put(c, value+1);
            }
        }
        //映射方式遍历
                Set> entryset =map.entrySet();
                for (Entry entry : entryset) {
                    System.out.println("键："+entry.getKey()+"值："+entry.getValue());

                }
                
    }
    

需求2：根据字母出现次数进行排序

package com.LX.map;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Map.Entry;
public class Demo2 {
    public static void main(String[] args) {
       
        String s="kjnbcdieuyejjdjsjsnkjk";
        char[] arr =s.toCharArray();//字符串分割
        Map map=new TreeMap<>();//字符集合
        for (char c : arr) {//遍历单个字符
            Integer value=map.get(c);//拿到值
            if(value==null) {
                map.put(c, 1);
            }else {
                map.put(c, value+1);
            }
        }
        ArrayList> listmap=new ArrayList<>(map.entrySet());
        //映射方式遍历
                Set> entryset =map.entrySet();
                for (Entry entry : entryset) {
//                    System.out.println("键："+entry.getKey()+"值："+entry.getValue());

                }
                
                Collections.sort(listmap,new Comparator>() {

                    @Override
                    public int compare(Entry o1, Entry o2) {
                        return o1.getValue()-o2.getValue();
                    }
                    
                } );
                    System.out.println(listmap);
    
    }
    }

效果图如下

---

 

四、泛型

情况：使用泛型之前不健壮的代码，只有运行时才会出现错误
 使用泛型之后把问题暴露出来
作用 :提高代码的健壮性;将运行期出现的异常转为编辑期的错误

package com.LX.map;

import java.util.HashSet;
import java.util.Set;

public class Demo3 {
    public static void main(String[] args) {
        Set set=new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        set.add(5);
        for (Object obj : set) {
            if(Integer.valueOf(obj.toString()) % 2 ==0) {//打印偶数
                System.out.println(obj);
            }
        }
        
    }
}
 

 

五、集合框架工具类

(1) collections------排序/集合数组 toArray（数组-->集合）

package com.LX.map;

import java.util.Arrays;
import java.util.List;

（数组-->集合）
public class Demo4 {
    public static void main(String[] args) {
        String [] arr= {"a","b","c","d"};//数组
        List list=Arrays.asList(arr);//本质上还是数组
        list.add("e");
        System.out.println(list.size());//数组长度不变
     
    }
}

 

分析：

1.数组转换为集合：本质上依然还是数组，长度不变
 2.集合与数组具备的方法是不一样的，如对数组而言，就没有判断内部包含的用法 

   

(2 )Arrays-----包括toString/aslist/sort

Listlist=new ArrayList<>();
        list.add("b");
        list.add("c");
        list.add("a");
        System.out.println(list);
//        排序sort
  Collections.sort(list, (x,y)-> y.compareTo(x));
//    System.out.println(list);

 

 public class Demo4 {

    public static void main(String[] args) {
        String [] arr= {"a","b","c","d"};//数组
        List list=Arrays.asList(arr);//本质上还是数组
        list.add("e");
        System.out.println(list.size());//数组长度不变   
    }
    
}

//字母排序
        Listlist=new ArrayList<>();
        list.add(new Person("b", 12));
        list.add(new Person("c", 18));
        list.add(new Person("a", 22));
        Collections.sort(list,(x,y) -> x.getName().compareTo(y.getName()) );
        System.out.println(list);
        //数字排序
        Integer[] arr= {4,3,9,5,2,8};
        Arrays.sort(arr,(x,y)-> y-x);
        System.out.println(Arrays.toString(arr));

        //创建一个类
        public Person implements Comparable() {
            // TODO Auto-generated constructor stub
        }
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + "]";
        }
        @Override
        public int compareTo(Person p) {
            return p.getName().compareTo(this.getName());
        }
        
        
}

效果如图所示：