Map和Set（附代码）

最新推荐文章于 2024-01-06 15:08:33 发布
最新推荐文章于 2024-01-06 15:08:33 发布
阅读量138 收藏 1
点赞数
分类专栏： Map和Set 文章标签： Set和Map
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47331155/article/details/116358511
版权

在这里插入图片描述
1：Map/Set里面的元素组织顺序和插入元素顺序没有任何关系。
2：for each代码底层也是靠迭代器来实现的，Iterable接口就提供了一个方法，这个方法就好返回一个迭代器对象。

了解Set接口

代码实现：

public class TestSet {
    public static void main(String[] args) {
        //1.实例化Set
        Set<String> set = new HashSet<>();
        //2.用add往set中插入元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //3.判断set中某个值是否存在
        System.out.println(set.contains("world"));
        //4.删除set中的某个值
        set.remove("world");
        System.out.println(set.contains("world"));
        //5.打印set
        System.out.println(set);
        //6.遍历打印set(如果要想循环遍历set中的元素，就需要使用迭代器了)
        /*迭代器的泛型参数，要和集合类中保存的元素参数保持一致，Iterator是一个接口，
        * 集合类内部自己实现自己版本的迭代器类，不同的集合类，内部的迭代器类型不同，
        * 迭代方式也不同（迭代器的实现细节也不同），但是我们用的时候统一用Iterator，感觉不到它的差异*/
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {//hasNext()判断是否有下一个元素
            String next = iterator.next();
            System.out.println(next);
        }
    }
}

面试题

1：

在这里插入图片描述
解答：

class Solution {
    public int singleNumber(int[] nums) {
//1.创建一个Map统计每个数字出现的次数，key表示当前数字，value表示这个数字出现的次数
        Map<Integer, Integer> map = new HashMap<>();
        //2.数组，完成统计Map中每个数字出现的次数
        for (int x:nums) {
            Integer value = map.get(x);
            if (value == null) {
                //当前这个数字之前在map中不存在，使对应的value置1
                map.put(x,1);
            } else {
                //当前这个数字前面已经存在过了，把value再加1即可
                map.put(x,value + 1);
            }
        }
        //3.遍历map，找到出现次数为1的数字
        for (Map.Entry<Integer,Integer> entry: map.entrySet()) {
            if (entry.getValue().equals(1)) {
                /*getValue得到的是Integer包装类，通过equals判定相当于对1进行自动装箱，比较两个Integer
                * 如果写成 == 1,相当于对Integer自动装箱，比较两个 ==*/
                return entry.getKey();
            }
        }
        //理论上讲，只要输入数组给的是正确内容，这里的return 0是不会触发的
        return 0;
    }
}

解2：按位异或的方式：a ^ b ^ b = a a ^ 0 = a
思想：初始值为0，把所有数字都往一起进行异或，由于大部分数字是出现两次，两次异或同一个数字就抵消~~，所有数字都异或完成之后，最后的结果就是只存在一次的数字。
解2代码实现如下：

 public  int singleNumber(int[] nums) {
        int ret = 0;
        for (int x:nums) {
            ret ^= x;
        }
        return ret;
    }

如果要是有两个整数只出现一次咋办呢？a 和 b
1：把所有的数字^到一起，得到的结果相当于a ^ b
2:a ^ b肯定不为0，就可以从异或结果中找到某个值为1的bit位。
代码实现如下：

public int[] singleNumber2(int[] nums) {
        //1:先把所有数字异或到一起
        int ret = 0;
        for (int x:nums) {
            ret ^= x;
        }
        //2.此时的异或结果相当于 a ^ b,值一定不为0。就可以从中找到某个为1的bit位。
        int bit = 1;
        int i = 0;
        for (; i < 32; i++) {
            if ((ret& (bit << i)) != 0) {
                break;
            }
        }
        //循环结束之后，bit中的值，就是刚找到某一位为1的值，然后再进行分组,分组操作能保证两点;
        //1:让a和b分散到不同组
        //2：让值相同的元素一定在同一组
        int a = 0;
        int b = 0;
        for (int x: nums) {
            if ((x & (bit << i)) != 0) {
                //第一组，指定位为1
                a ^= x;
            } else {
                //第二组，指定位为0
                 b ^= x;
            }
        }
        int[] array = {a,b};
        return array;
    }

力扣算法第138题：复制带随机指针的链表
思路：1：一种简单粗暴的思路：先把链表按照普通链表的方式复制一份，遍历每个节点，看该节点random指针指向的位置相对于头结点的偏移量是几（从头结点出发走几步能到达random指向位置），然后根据这个偏移量决定新链表中的每个节点的指向。(这是一种代码实现起来比较麻烦的思路)
2：更简单的方法：创建一个Map<Node,Node> key表示旧链表上的节点，value表示旧链表对应节点的拷贝（也就是新链表的节点）
在这里插入图片描述
代码实现：

public class MapInterview {
    //整个node的static内部类
    static class Node {
        int val;
        Node next;
        Node random;

        public Node(int val) {
            this.val = val;
            this.next = null;
            this.random = null;
        }
    }
    public Node copyRandomList(Node head) {
        //1.遍历旧链表，把旧链表每个节点依次插入到map中，key是旧链表节点，value是拷贝出来的新节点
        Map<Node,Node> map = new HashMap<>();
        for (Node cur = head;cur != null; cur = cur.next) {
            map.put(cur,new Node(cur.val));//此时新链表中的val值拷贝出来了，但是next和random仍然是null
        }
        //2.再次遍历链表，修改新链表节点中的next和random
        for (Node cur = head;cur != null; cur = cur.next) {
            //先从map中找到该cur对应的新链表节点
            Node newCur = map.get(cur);
            newCur.next = map.get(cur.next);
            newCur.random = map.get(cur.random);
        }
        //需要返回新链表的头节点
        return map.get(head);
    }
}

在这里插入图片描述
for each 这种东西，相当于“语法糖”，语法糖：指的是某个语法特性，没有也完全ok，如果有了的话，可以让代码更简单（程序员心里甜甜的），lambda也是语法糖，包装类自动装箱，自动拆箱，也算语法糖。
力扣算法第771题：宝石与石头
代码实现：

   public int numJewelsInStones(String J,String S) {
        //1.先遍历J把所有的宝石类型加入到一个Set中
        Set<Character> set = new HashSet<>();
        for (char c:J.toCharArray()) {
            set.add(c);
        }
        //2.遍历s拿到每个元素之后，再去set中查找，如果能找到，就说明是宝石
        int ret = 0;
        for (char c : S.toCharArray()) {
            if (set.contains(c)) {
                ret++;
            }
        }
        return ret;
    }

牛客旧键盘：
坏掉的键：按下键没有输出
题目理解：给出一个"预期输出的字符串",再给出一个“实际输出的字符串”，找到哪些字符预期要输出但是实际没输出的，这样的字符就是坏掉的键。键盘上某个键坏了，对应大写字母和小写字母都无法输出，需要把A和a当成同一种情况。
代码实现如下：

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class BrokenKeyboard {
    public static void main(String[] args) {
        /*该题的思路：
        * 1：循环读入两个字符串，第一个字符串是预期输出的内容；第二个字符串是实际输出的内容
        * 2：把读入的两个字符串全都转成大写（根据题目的输出示例）
        * 3：题目中的主要任务是判定预期输出的哪些字符在实际输出的字符串中有没有存在。先搞一个Set把实际输出的
        * 每个字符都存进去，然后再遍历预期输出字符串，看看哪个字符在这个Set中不存在
        * 【注意事项】：最后还得对坏掉的键进行去重（同样可以使用Set来去重，因为Set中的key是不允许重复的）
        * */
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            // 1：循环读入两个字符串，第一个字符串是预期输出的内容；第二个字符串是实际输出的内容
            String expected = scanner.next();
            String actual = scanner.next();
            //2.把读入的两个字符串全都转成大写（根据题目的输出示例）。
            expected = expected.toUpperCase();
            actual = actual.toUpperCase();
            //3.创建一个Set保存实际输出的字符
            Set<Character> actualSet = new HashSet<>();
            for (int i = 0;i < actual.length();i++) {
                //注意Set中的内容是不会重复的，如果add的时候发现这个元素已经存在，那么add这个操作就不
                //再进行了，会继续进行下面的add，不会抛出异常，也不会影响到原有Set中的内容，
                actualSet.add(actual.charAt(i));
            }
            //4.遍历预期输出的字符串，看看哪个字符没有被实际输出
            Set<Character> brokenKeySet = new HashSet<>();//这个brokenKeySet用来存放坏键，能够去重
            for (int i = 0; i < expected.length();i++) {
                char c = expected.charAt(i);
                if (actualSet.contains(c)) {
                    //当前字符对应的按键是一个好的键，不打印，继续往下走
                    continue;
                }
                //走到这儿，剩下的就是坏了的键，要注意输出格式的问题，空格，换行的有无，这些细节都很重要
                if (brokenKeySet.contains(c)) {
                    //此处的brokenKeySet用于辅助去重，防止同一个坏键被打印多次
                    continue;
                }
                System.out.print(c);
                brokenKeySet.add(c);
            }
        }
    }
}

力扣算法第692题：
代码实现如下：

static class MyComparator implements Comparator<String> {
        private Map<String,Integer> map;

        public MyComparator(Map<String, Integer> map) {
            this.map = map;
        }

        @Override
        public int compare(String o1, String o2) {
            int count1 = map.get(o1);
            int count2 = map.get(o2);
            if (count1 == count2) {
                return o1.compareTo(o2);//这里就按字典序进行排序，因为String自身也实现了Comparable,自带字典序
                //的比较功能，compareTo就是在使用String默认的比较规则
            }
            return count2 - count1;//这里可以这样理解：sort本身是按升序排列
            //以下两种方式相当于重新定义排列顺序
            /*1：count1 - count2  仍然是升序排列
            * 2：count2 - count1   降序排列
            * */

        }
    }
    public List<String> topKFrequent(String[] words,int k) {
        //1.先统计每个单词出现的次数，用map将每个单词及其出现次数存起来
        Map<String,Integer> map = new HashMap<>();
        for (String s: words) {
            Integer count = map.getOrDefault(s,0);
            map.put(s,count + 1);//这里map如果再次put就会把原来的给覆盖更新
        }
        //2.把刚才这里统计到的字符串内容放到ArrayList中，KeySet相当于得到了一个Set，Set中存放的就是所有的key
        ArrayList<String> arrayList = new ArrayList<>(map.keySet());
        //3.按照刚才字符串出现次数，针对arrayList进行排序
        //sort默认是按照元素的自身大小进行升序排序（String 的字典序），但是根据题意，此处我们需要按照字符串出现次数
        //来降序排序，也就需要通过自制比较器来自定制比较规则。
        Collections.sort(arrayList,new MyComparator(map));//在比较要用到每个单词出现的次数，但是每个单词出现的次数在
        //map里，所以要把map给传过去
        //4.获取到前k个元素
        return arrayList.subList(0,k);
    }

通过匿名内部类的方式求解：

 static class MyComparator implements Comparator<String> {
        private Map<String,Integer> map;

        public MyComparator(Map<String, Integer> map) {
            this.map = map;
        }

        @Override
        public int compare(String o1, String o2) {
            int count1 = map.get(o1);
            int count2 = map.get(o2);
            if (count1 == count2) {
                return o1.compareTo(o2);//这里就按字典序进行排序，因为String自身也实现了Comparable,自带字典序
                //的比较功能，compareTo就是在使用String默认的比较规则
            }
            return count2 - count1;//这里可以这样理解：sort本身是按升序排列
            //以下两种方式相当于重新定义排列顺序
            /*1：count1 - count2  仍然是升序排列
            * 2：count2 - count1   降序排列
            * */

        }
    }
    public List<String> topKFrequent(String[] words,int k) {
        //1.先统计每个单词出现的次数，用map将每个单词及其出现次数存起来
        Map<String,Integer> map = new HashMap<>();
        for (String s: words) {
            Integer count = map.getOrDefault(s,0);
            map.put(s,count + 1);//这里map如果再次put就会把原来的给覆盖更新
        }
        //2.把刚才这里统计到的字符串内容放到ArrayList中，KeySet相当于得到了一个Set，Set中存放的就是所有的key
        ArrayList<String> arrayList = new ArrayList<>(map.keySet());
        //3.按照刚才字符串出现次数，针对arrayList进行排序
        //sort默认是按照元素的自身大小进行升序排序（String 的字典序），但是根据题意，此处我们需要按照字符串出现次数
        //来降序排序，也就需要通过自制比较器来自定制比较规则。
       // Collections.sort(arrayList,new MyComparator(map));//在比较要用到每个单词出现的次数，但是每个单词出现的次数在
        //map里，所以要把map给传过去
        //4.获取到前k个元素
        Collections.sort(arrayList, new Comparator<String>() {
            @Override//下面的代码创建了一个“匿名内部类”：你不知道这个类的名字是啥，但是你知道这个类实现了Comparator接口，
            //“匿名内部类”：这个类只需要用一次，用完就丢
            public int compare(String o1, String o2) {
                int count1 = map.get(o1);//匿名内部类优势与其他类的地方在于：他可以直接用所在邻域内的变量，而不需要通过构造器传递
                int count2 = map.get(o2);
                if (count1 == count2) {
                    return o1.compareTo(o2);//按字典序进行排列
                }
                return count2 - count1;
            }
        });
        return arrayList.subList(0,k);
    }

该题lambda表达式的求解：

static class MyComparator implements Comparator<String> {
        private Map<String,Integer> map;

        public MyComparator(Map<String, Integer> map) {
            this.map = map;
        }

        @Override
        public int compare(String o1, String o2) {
            int count1 = map.get(o1);
            int count2 = map.get(o2);
            if (count1 == count2) {
                return o1.compareTo(o2);//这里就按字典序进行排序，因为String自身也实现了Comparable,自带字典序
                //的比较功能，compareTo就是在使用String默认的比较规则
            }
            return count2 - count1;//这里可以这样理解：sort本身是按升序排列
            //以下两种方式相当于重新定义排列顺序
            /*1：count1 - count2  仍然是升序排列
            * 2：count2 - count1   降序排列
            * */

        }
    }
    public List<String> topKFrequent(String[] words,int k) {
        //1.先统计每个单词出现的次数，用map将每个单词及其出现次数存起来
        Map<String,Integer> map = new HashMap<>();
        for (String s: words) {
            Integer count = map.getOrDefault(s,0);
            map.put(s,count + 1);//这里map如果再次put就会把原来的给覆盖更新
        }
        //2.把刚才这里统计到的字符串内容放到ArrayList中，KeySet相当于得到了一个Set，Set中存放的就是所有的key
        ArrayList<String> arrayList = new ArrayList<>(map.keySet());
        //3.按照刚才字符串出现次数，针对arrayList进行排序
        //sort默认是按照元素的自身大小进行升序排序（String 的字典序），但是根据题意，此处我们需要按照字符串出现次数
        //来降序排序，也就需要通过自制比较器来自定制比较规则。
       // Collections.sort(arrayList,new MyComparator(map));//在比较要用到每个单词出现的次数，但是每个单词出现的次数在
        //map里，所以要把map给传过去
        //4.获取到前k个元素
        Collections.sort(arrayList, (o1, o2) -> {//lambda表达式本质上就是一个匿名方法，o1,o2的类型就是String类型，剩下
            //大括号中方法的具体实现就和匿名内部类的完全一样
            int count1 = map.get(o1);
            int count2 = map.get(o2);
            if (count1 == count2) {
                return o1.compareTo(o2);//按字典序进行排列
            }
            return count2 - count1;
        });
        return arrayList.subList(0,k);
    }

Arrays.sort:是针对数组排序，也可以通过第二个参数指定比较规则（比较器对象）
Collections.sort:针对集合类排序。

王根生
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常用Java代码65个附示例代码
01-07
Java集合框架包括接口（如List, Set, Map）和实现这些接口的类（如ArrayList, HashSet, HashMap）。Collections类提供了一些静态方法，用于操作各种集合。 3. **Java中的自动装箱和拆箱（Autoboxing and Unboxing...
匿名函数与map方法
qq_36936443的博客
04-16 582
有时候我们想临时实现一个操作，并且以后也不想在程序的其他地方中调用这个函数，那么就可以使用匿名函数，不指定函数名，只需要对应的函数映射关系 [(lambda x: 2*x) (i) for i in range(5)] #输出：[0, 2, 4, 6, 8] 对于上述的这种列表推导式的匿名函数映射，还可以map函数来完成，map(function,iterator) list(map(lambda x, y: str(x)+'_'+y, range(5...
类似于匿名内部类Map类的创建
qq_32816723的博客
06-02 643
在java的一些程序中，某些函数形参需要用到Map集合，通常我们是直接在外部创建一个Map的是实现类，然后put一些数据进去。这种方式麻烦，代码看起来档次不高。可以采用以下形式: List<Blog> blogs = mapper.queryBlogIf(new HashMap() {{ put("title", "Java"); put("author", "狂神说"); }}); 注：本段代码选自Mybatis学习课程中.
快速创建 Map
jiey0407的博客
08-29 2388
想要快速创建Map，不用频繁new，最快的方法就是用Guava，使用ImmutableMap.of(“a”, 1, “b”, 2, “c”, 3);超过 10 组会不支持，那么就要这样：Map.ofEntries(匿名Map mymap = new HashMap() {
【python高级用法】匿名函数（lambda）、map()、filter()、reduce()系列高阶函数
最新发布
qq_44091004的博客
01-06 990
高阶函数是指能够接受其他函数作为参数或者返回函数作为结果的函数。在函数式编程中，高阶函数是一种强大的工具，它使得代码更加灵活、抽象和可复用。
java day028 Map与匿名内部类
bandersnatch的博客
05-18 622
java day028 Map与匿名类 1.Map 1.1 Map概述 Map是一个双边队列 数据存储形式为键（Key）值（Value）对形式 Map双边队列对于数据存储类型有限制，存储数据类型在创建Map双边队列时进行约束，保证类型一致化； 但是也没有约束，Map可以满足任意类型的存储 Map使用了俩个泛型 Map<K, V> 1.2 Map整体结构与常用API interface Map<K, V> --| class HashMap<K, V> 底层存储数据结构为
数据结构算法与应用-C++语言描述 附源代码.zip
08-27
C++提供了STL（标准模板库），其中包含容器（如vector、list、set、map等）和算法，使得程序员可以便捷地使用和操作数据结构，同时也支持自定义数据结构的创建。 源代码的提供则为学习者提供了实践和深入理解的机会...
java 课件 完整 入门版 易懂 附例题代码
07-20
Java集合框架是处理对象数组的关键工具，包括List、Set、Queue和Map等接口，以及ArrayList、LinkedList、HashSet、HashMap等实现类。通过学习，你可以学会如何有效地存储和操作数据。 五、输入/输出(I/O)与文件操作...
c++题 附详细代码
07-31
4. **STL（Standard Template Library）**：C++的标准模板库，包括容器（如vector, list, set, map）、迭代器、算法和函数对象。 5. **异常处理**：错误处理机制，用于在程序运行时捕获并处理异常情况。 6. **文件...
STL源码剖析简体中文完整版(清晰扫描带目录，附源代码).zip
07-13
STL是C++编程中的核心部分，它包含了一系列高效的数据结构（如vector、list、set、map等）和算法（如排序、查找等）。这些组件都是以模板的形式实现的，因此可以应用于各种数据类型，极大地提高了代码的复用性和效率...
python入门（5）—— 匿名函数，列表推导式、set、list、tuple三者的转换、高阶函数
zzhou——blog
04-05 383
文章目录1.匿名函数（lambda）常用场景：2.递归函数3. 列表推导式4.set集合5.list-set-tuple三者之间的转换6.高阶函数map函数reduce函数filter函数 1.匿名函数（lambda） """ def my_add(a, b): return a + b my_add(10, 20) """ # lambda 形参1,形参2, ... : 单行表达式 ...
EagleMap介绍
2301_79965602的博客
09-26 544
在这里强烈建议将高德地图的ak改成自己的，不要使用默认的，因为使用人多了可能会被封号，将不能正常使用。更改了ak后，要记得重启EagleMap服务。EagleMap是黑马程序员研究院自研的地图中台服务，它可以对接多个地图服务商，目前已经完成百度地图和高德地图的对接。
java8 treemap 排序_使用Java8 Stream API对Map按键或值进行排序
weixin_35089515的博客
02-13 1564
一、什么是Java 8 Stream使用Java 8 Streams，我们可以按键和按值对映射进行排序。下面是它的工作原理：将Map或List等集合类对象转换为Stream对象使用Streams的sorted()方法对其进行排序最终将其返回为LinkedHashMap(可以保留排序顺序)sorted()方法以Comparator作为参数，从而可以按任何类型的值对Map进行排序。如果对Compara...
神领物流day05-路线规划之微服务
study-java
01-03 1569
使用Neo4j来实现路线规划微服务的编写，实现该服务中路线管理的核心服务-提供路线规划查询服务以及crud等基本功能
C++——map和set的简介及使用
qq_56663697的博客
02-21 2110
文章目录关联式容器键值对setset的介绍set的使用set的模板参数列表set的构造set中常用的成员函数set中迭代器相关函数使用示例multisetmapmap的介绍map的使用map的模板参数说明map构造map的插入map的[ ]运算符重载 关联式容器 关联式容器包括序列式容器和关联式容器 序列式容器： 底层为线性序列的数据结构，里面存储的是元素本身，包含vector、list、deque、forward_list(C++11)等。 关联式容器： 里面存储的是<key, value>结
细说匿名内部类方式创建线程、初始化HashMap
javaloveiphone的专栏
08-30 5250
先来看看使用匿名内部类创建线程和初始化HashMap的示例代码：使用匿名内部类创建线程：new Thread() { public void run() { System.out.println("匿名内部类创建线程并启动"); }}.start();使用匿名内部类初始化HashMap：Map map = new HashMap(){ { pu
HashMap的匿名内部类
bingguang1993的博客
08-31 4665
    Map&lt;String,Object&gt; map =new HashMap&lt;String,Object&gt;(){{         put("num",123);     }};
引用数据类型（类）+ 匿名对象 + set/get赋值取值
newway22的博客
04-07 354
1.引用数据类型包括： 数组， 类（自定义类也属于） 对于引用数据类型来说： 这个类型对应的数据 就是他这个类创建出来的对象。例如：一个Teacher类型的数据 就是需要一个由Teacher这个类创建出来的对象 2.匿名对象 创建两个类：Student，Teacher；调用Student类中study方法的两种方式 匿名对象： 就是一个没有名字的对象，匿名对象因为没有名字，无法再次使用（没有任何一个变量/对象名保存这个对象的堆内存地址） ...
使用{{}}创建HashMap
feiya000的博客
09-20 283
其中{{}} 匿名内部类+代码块
Java中的匿名内部类：由setOnClickListener说起
ljcmeng的博客
06-28 2680
在初学Android的时候，总是看到这样一段代码： Button button = (Button) findViewById(R.id.button); button.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值