java 将map重新赋值为空 map重新设置value

文章目录

Map

Set

只出现一次的数字

复制带随机指针的链表

宝石与石头

坏键盘打字

前k个高频单词：博哥的set&map那一节的1:20左右

移除链表重复节点

Map

Map的官方文档

---

---

注意：Map.Entry<K,V>并没有提供设置Key的方法

---

注意：

1. Map是一个接口，不能直接实例化对象**，如果**要实例化对象只能实例化其实现类TreeMap或者HashMap
2. Map中存放键值对的Key是唯一的，value*是可以重复的
3. 在Map中插入键值对时，key不能为空，否则就会抛NullPointerException异常，但是value可以为空
4. Map中的Key可以全部分离出来，存储到Se中来进行访问(因为Key不能重复)
5. Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。
6. Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行
   重新插入。
   关于Entry这个方法

//Map.Entry<String,Integer> Entry这个方法就是把key和value打包然后放到集合entrySet里去
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        for (Map.Entry<String,Integer> entry :entrySet) {
            System.out.println(entry.getKey()+"->"+entry.getValue());
        }

//        Set<String> set = map.keySet();//Set这个集合当中 存储的元素 都是不重复的
//        System.out.println(set);

TreeMap放入数据是有序的，因为他实现了SortMap接口，而HashMap 底层是根据哈希表来进行存储的，HashMap的进阶就是红黑树

---

Set

Set文档

Set最大的特点是他可以去重，不添加重复的元素，而Map是更新 新的val值

Set与Map主要的不同有两点：Set是继承自Collection的接口类，Set中只存储了Key

//Set的迭代器使用
Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

只出现一次的数字

class Solution {
    public int singleNumber(int[] nums) {
        Set<Integer> set = new HashSet(); 
        int ret = 0;
        for(int x : nums){
            if(!set.contains(x)){
                set.add(x);
            }else{
                set.remove(x);
            }
        }
        Iterator<Integer> iterator = set.iterator();
        return iterator.next();
    }
}

复制带随机指针的链表

class Solution {
    public Node copyRandomList(Node head) {
        Map<Node,Node> map = new HashMap<>();
        Node cur = head;
        while(cur != null){
            Node node = new Node(cur.val);
            map.put(cur,node);
            cur = cur.next;
        }
        cur = head;
        while(cur != null){
            map.get(cur).next = map.get(cur.next);
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }
        return map.get(head);

    }
}

宝石与石头

class Solution {
    public int numJewelsInStones(String jewels, String stones) {
        Set<String> set = new HashSet<>();
        int count = 0;
        for(int j = 0;j<jewels.length();j++){
            String sb = jewels.charAt(j)+"";
            set.add(sb);
        }
        for(int i = 0;i<stones.length();i++){
            String ret = stones.charAt(i)+"";
            if(set.contains(ret)){
                count++;
            }
        }
        return count;
    }
}

坏键盘打字

import java.util.*;
public class Main{
 public static void func(String strExce,String strActual) {
        HashSet<Character> set = new HashSet<>();
        for (char ch : strActual.toUpperCase().toCharArray()) {
            set.add(ch);
        }

        HashSet<Character> broken = new HashSet<>();

        for (char ch : strExce.toUpperCase().toCharArray()) {
            if(!set.contains(ch) && !broken.contains(ch)) {
                System.out.print(ch);
                broken.add(ch);
            }
        }
    }



    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        while(scan.hasNextLine()) {
            String str1 = scan.nextLine();
            String str2 = scan.nextLine();
            func(str1,str2);
        }
    }
}

前k个高频单词：博哥的set&map那一节的1:20左右

class Solution {
    /**
     * 求的是出现次数最多的单词
     * @param words
     * @param k
     * @return
     */
    public static List<String> topKFrequent(String[] words, int k) {
        HashMap<String,Integer> map = new HashMap<>();
        //1、统计每个单词出现的次数 map
        for (String s : words) {
            if(map.get(s) == null) {
                map.put(s,1);
            }else {
                int val = map.get(s);
                map.put(s,val+1);
            }
        }
        //2、建立一个大小为K的小根堆
        PriorityQueue<Map.Entry<String,Integer>> minHeap = new PriorityQueue<>(k, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                if(o1.getValue().compareTo(o2.getValue()) == 0) {
                    return o2.getKey().compareTo(o1.getKey());
                }
                return o1.getValue()-o2.getValue();
            }
        });

        //3、遍历Map
        for (Map.Entry<String,Integer> entry : map.entrySet()) {
            if(minHeap.size() < k) {
                minHeap.offer(entry);
            }else {
                //说明堆中 已经放满了K个元素，需要看堆顶元素的数据 和当前的数据的大小关系
                Map.Entry<String,Integer> top = minHeap.peek();
                //判断频率是否相同，如果相同，比较单词的大小，单词小 的入堆
                if(top.getValue().compareTo(entry.getValue()) == 0) {
                    if(top.getKey().compareTo(entry.getKey()) > 0) {
                        minHeap.poll();
                        minHeap.offer(entry);
                    }
                }else {
                    if(top.getValue().compareTo(entry.getValue()) < 0) {
                        minHeap.poll();
                        minHeap.offer(entry);
                    }
                }
            }
        }
        //System.out.println(minHeap);
        List<String> ret = new ArrayList<>();
        for (int i = 0;i < k;i++) {
            Map.Entry<String,Integer> top = minHeap.poll();
            ret.add(top.getKey());
        }
        Collections.reverse(ret);
        return ret;
    }
}

移除链表重复节点

public  ListNode removeDuplicateNodes(ListNode head) {
        if(head == null){
            return null;
        }
        Set<Integer>  map = new HashSet<>();
        ListNode cur = head;
        map.add(head.val);
        while(cur.next != null){
            int val = cur.next.val;
            ListNode prev = cur.next;
            if(map.add(val)){
                cur = cur.next;
            }else{
                cur.next = cur.next.next;
            }
    }
    return head;
}

.next != null){ int val = cur.next.val; ListNode prev = cur.next; if(map.add(val)){ cur = cur.next; }else{ cur.next = cur.next.next; } } return head; }