347-HashMap常用方法以及遍历排序方式

HashMap常用方法以及遍历排序方式

常用方法

map.containsKey()
map.put()
map1.equals(map2)

遍历方式

   Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
   while (iterator.hasNext()){
        System.out.println(iterator.next());
    }

排序方式

根据key排序（最好把要排序的设为key）

    //map对key排序（默认只能对key排序）
    @Test
    public void test1(){
        //普通方式
//        Map<String, String> map = new TreeMap<>(
//                new Comparator<String>() {
//                    public int compare(String obj1, String obj2) {
//                        //对key降序排序
//                        return obj2.compareTo(obj1);
//                    }
//                });
        //Lambda 表达式
        Map<String,String> map=new TreeMap<>((s1,s2)->{
            return s2.compareTo(s1);
        });
        map.put("d", "ddddd");
        map.put("b", "bbbbb");
        map.put("a", "aaaaa");
        map.put("c", "ccccc");
        Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

根据value排序

    //map对value排序
    //把TreeMap的EntrySet转换成list，然后使用Collections.sor排序
    @Test
    public void test2(){
        Map<String, String> map = new TreeMap<>();
        map.put("d", "ddddd");
        map.put("b", "bbbbb");
        map.put("a", "eeeee");
        map.put("c", "ccccc");

        //这里将map.entrySet()转换成list
        List<Map.Entry<String,String>> list = new ArrayList<Map.Entry<String,String>>(map.entrySet());
        //然后通过比较器来实现排序
        Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
            //升序排序
            public int compare(Map.Entry<String, String> o1,
                               Map.Entry<String, String> o2) {
                return o1.getValue().compareTo(o2.getValue());
            }
        });

        Iterator<Map.Entry<String, String>> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

Leetcode242-有效字母异位词

给定两个字符串 *s* 和 *t* ，编写一个函数来判断 *t* 是否是 *s* 的字母异位词。
注意：若 *s* 和 *t* 中每个字符出现的次数都相同，则称 *s* 和 *t* 互为字母异位
输入: s = "anagram", t = "nagaram"
输出: true

    public boolean isAnagram(String s, String t) {
            if(s.length()!=t.length()){
                return false;
            }

            Map map1=new HashMap<Character,Integer>();
            Map map2=new HashMap<Character,Integer>();

             for(int i=0;i<s.length();i++){
            if(!map1.containsKey(s.charAt(i))){
                map1.put(s.charAt(i),1);
            }else{
                map1.put(s.charAt(i),(Integer)map1.get(s.charAt(i))+1);
            }
        }

        for(int i=0;i<t.length();i++){
            if(!map2.containsKey(t.charAt(i))){
                map2.put(t.charAt(i),1);
            }else{
                map2.put(t.charAt(i),(Integer)map2.get(t.charAt(i))+1);
            }
        }

        return map1.equals(map2);
    }

Leetcode1-两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
输入：nums = [2,7,11,15], target = 9
输出：[0,1]

    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map=new HashMap<>();
        int[] res=new int[2];
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                res[0]=map.get(target-nums[i]);//get得到value所以这里把下标作为value
                res[1]=i;
                break;
            }else{
                map.put(nums[i],i);
            }
        }
        return res;
    }

Leetcode383-赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
输入：ransomNote = "a", magazine = "b"
输出：false

    public boolean canConstruct(String ransomNote, String magazine) {

            if(ransomNote.length()>magazine.length()){
                return false;
            }

            Map map=new HashMap<Character,Integer>();

            for(int i=0;i<magazine.length();i++){
                char temp=magazine.charAt(i);
                if(!map.containsKey(temp)){
                    map.put(temp,1);
                }else{
                    map.put(temp,(Integer)map.get(temp)+1);
                }
            }

            for(int j=0;j<ransomNote.length();j++){
                char temp=ransomNote.charAt(j);
                if(map.containsKey(temp)){
                    map.put(temp,(Integer)map.get(temp)-1);
                    if((Integer)map.get(temp)<0){
                        return false;
                    }
                }else{
                    return false;
                }
            }
            
            return true;
    }

Leetcode347-前k个高频元素

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案
输入：nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
            int[] result=new int[k];

        Map map=new HashMap<Integer,Integer>();


        for (int i=0;i< nums.length;i++){
            if (map.containsKey(nums[i])){
                map.put(nums[i],(Integer)map.get(nums[i])+1);
            }else {
                map.put(nums[i],1);
            }
        }

        // 第一种Map排序方式, 根据value排序
        List<Map.Entry<Integer, Integer>> entryList = new ArrayList<Map.Entry<Integer,Integer>>(map.entrySet());
        Collections.sort(entryList, new Comparator<Map.Entry<Integer,Integer>>() {
            @Override
            public int compare(Map.Entry<Integer,Integer> me1, Map.Entry<Integer,Integer> me2) {
                return me2.getValue().compareTo(me1.getValue()); // 降序排序
            }
        });



        for (int i=0;i<k;i++){
            result[i]=entryList.get(i).getKey();
        }

        return result;

    }
}