Leetcode1/242/383-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;
    }