Map集合之HashMap（二）

最新推荐文章于 2022-09-24 15:09:33 发布
最新推荐文章于 2022-09-24 15:09:33 发布
阅读量590 收藏
点赞数
分类专栏： Java 文章标签： java
本文为博主原创文章，未经授权，不得转载搬运。
本文链接：https://blog.csdn.net/qfc_128220/article/details/115902191
版权

思维导图

代码练习

package hashmaptest;

import linkedlist.Person;

import java.util.HashMap;
import java.util.Map;

public class HashMapTest {
    public static void main(String[] args) {
//        noParamConstractor();
//        oneParamConstractor();
//        twoParamConstractor();
//        mapParamConstractor();
//        putTest();
//        removeTest();
//        getTest();
//        containsKeyTest();
//        containsValueTest();
//        clearTest();
//        sizeTest();
//        isEmptyTest();
//        cloneTest();
//        keySetTest();
//        valuesTest();
        entrySetTest();
    }

    private static void entrySetTest() {
        HashMap<String, String> hm = new HashMap<>(8);
        hm.put("重地","1");
        hm.put("通话","2");

        /**
         * 遍历HashMap集合的KV时，推荐使用entrySet()，而不是keySet()
         */
        hm.entrySet().forEach(entry-> System.out.println(entry.getKey()+":"+entry.getValue()));

        System.out.println("====================================");

        for (String s : hm.keySet()) {//keySet遍历KV,先要获取keySey迭代器对象，进行迭代，然后根据迭代出来的key再去hm遍历查询value,遍历了两次
            System.out.println(s+":"+hm.get(s));
//            hm.put("qfc","123");//java.util.ConcurrentModificationException
//            hm.remove("重地");//java.util.ConcurrentModificationException
        }
    }

    private static void valuesTest() {
        HashMap<String, String> hm = new HashMap<>(8);
        hm.put("重地","1");
        hm.put("通话","2");

        hm.values().forEach(str-> System.out.println(str));

        for (String value : hm.values()) {
//            hm.put("qfc","123");//java.util.ConcurrentModificationException
//            hm.remove("重地");//java.util.ConcurrentModificationException
        }
    }

    private static void keySetTest() {
        HashMap<String, String> hm = new HashMap<>(8);
        hm.put("重地","1");
        hm.put("通话","2");

        hm.keySet().forEach(str-> System.out.println(str));

        for (String s : hm.keySet()) {
//            hm.put("qfc","1");//java.util.ConcurrentModificationException
//            hm.remove("通话");//java.util.ConcurrentModificationException
        }
    }

    private static void cloneTest() {
        HashMap<Person, String> hm = new HashMap<>(8);
        Person p1 = new Person("qfc",18);
        Person p2 = new Person("zyx",19);

        hm.put(p1,"1");
        hm.put(p2,"2");

        /**
         * clone方法
         * 首先HashMap clone = super.clone();获得克隆对象
         * 然后clone对象重置HashMap的属性，table,threshold,size,modcount,entrySet,keySey,values
         * 然后重新将super的key-value重新put进clone中
         * 由于clone和super中的对应key和value都是指向同一个对象，所以还是属于浅克隆
         */
        HashMap<Person, String> clone = (HashMap) hm.clone();
        clone.put(p1,"3");

        System.out.println(hm.get(p1));//1
        System.out.println(clone.get(p1));//3

        Person next = clone.keySet().iterator().next();
        next.setAge(100);

        Person next1 = hm.keySet().iterator().next();
        System.out.println(next1.getAge());//100

        for (Map.Entry<Person, String> personStringEntry : hm.entrySet()) {
            System.out.println(personStringEntry.getKey());
        }
//        Person{name='qfc', age=100}
//        Person{name='zyx', age=19}
    }

    private static void isEmptyTest() {
        HashMap<String, String> hm = new HashMap<>(8);
        hm.put("重地","1");
        hm.put("通话","2");

        /**
         * isEmpty方法内部即 return size == 0;
         * 当判断一个HashMap集合为空时，建议使用isEmpty()而不是size()==0
         * 因为isEmpty的时间复杂度是O(1)
         */
        System.out.println(hm.isEmpty());
    }

    private static void sizeTest() {
        HashMap<String, String> hm = new HashMap<>(8);
        hm.put("重地","1");
        hm.put("通话","2");

        /**
         * size()方法就是返回HashMap实例的size属性值
         */
        int size = hm.size();
        System.out.println(size);
    }

    private static void clearTest() {
        HashMap<String, String> hm = new HashMap<>(8);
        hm.put("重地","1");
        hm.put("通话","2");

        /**
         * clear方法是循环遍历哈希表，将哈希表的桶位置全部设置为null
         */
        hm.clear();
    }

    private static void containsValueTest() {
        HashMap<String, String> hm = new HashMap<>(8);
        hm.put("重地","1");
        hm.put("通话","2");

        /**
         * containsValue方法是以双重for循环，外层遍历哈希表，内层遍历每个桶下面的链表或红黑树
         * 内层以next方式遍历链表或红黑树的节点，红黑树节点TreeNode类是Node类的间接子类，可以支持next方式遍历
         * 但是如果是红黑树next效率很低
         */
        System.out.println(hm.containsValue("2"));
        System.out.println(hm.containsValue("null"));
    }

    private static void containsKeyTest() {
        HashMap<String, String> hm = new HashMap<>(8);
        hm.put("重地","1");
        hm.put("通话","2");

        /**
         * containsKey内部调用了getNode方法，即get方法的内部调用逻辑
         * 即getNode返回值不为null,则说明有对应key
         */
        System.out.println(hm.containsKey("通话"));
        System.out.println(hm.containsKey(null));
    }

    private static void getTest() {
        HashMap<String, String> hm = new HashMap<>(8);
        /**
         * get方法执行前判断底层哈希表是否初始化，且不为空，若没有初始化或者为空，则直接返回null
         */
        String r1 = hm.get(null);
        System.out.println(r1);//null

        hm.put("重地","1");
        hm.put("通话","2");

        /**
         * 若底层哈希表已经初始化，且不为空，则继续检查
         * 要查询的key的索引处是否有节点？若没有，则直接返回null
         * 否则根据（hash(key)==hash(getkey) && (key==getkey || (key!=null && key.equals(getkey)))）
         * 比较key和getkey是否相同，若相同，则返回getkey对应键值对的value
         * 否则判断桶位置下面是否有节点，若无节点，则返回null
         * 若有节点，则遍历红黑树或者链表节点，根据（hash(key)==hash(getkey) && (key==getkey || (key!=null && key.equals(getkey)))）
         * 判断是否有相同key的节点，若没有则返回null
         * 否则返回对应节点的value值
         */
        String r2 = hm.get("通话");
        System.out.println(r2);//2
    }

    private static void removeTest() {
        HashMap<String, String> hm = new HashMap<>(8);
        /**
         * remove方法
         * 先判断底层哈希表table是否初始化，是否为空？若为空，则remove不只想删除操作，只返回null
         * put方法返回值类型是V
         */
        String r1 = hm.remove(null);
        System.out.println(r1);//null

        hm.put("重地","1");
        hm.put("通话","2");

        /**
         * 若底层哈希表已经初始化，且不为空，则判断要删除的key对应的桶位置是否有节点
         * 若没有，则不执行删除操作，只返回null
         */
        String r2 = hm.remove(null);
        System.out.println(r2);//null

        /**
         * 判断要删除的key对应的桶位置有节点，
         * 则根据（hash(key)==hash(delKey) && (key==delkey || (key!=null && key.equals(delkey))))
         * 判断key和delkey是否相同。若相同，则直接删除桶位置节点，（下一个节点next上移）
         * 若不同，则判断桶位置是否还有下一个节点，若没有，则返回null
         * 否则遍历链表节点或者红黑树节点，检查（hash(key)==hash(delKey) && (key==delkey || (key!=null && key.equals(delkey))))
         * 是否有相同的节点，若没有，则返回null,否则删除对应相同节点，并返回删除节点的value
         */
        String r3 = hm.remove("通话");
        System.out.println(r3);//2
    }

    static void putTest(){
        HashMap<String, String> hm = new HashMap<>(8);
        //HashMap的key和value都支持存储null，
        // 1.key，value的类型是K,V必须是引用类型,引用类型支持null，
        // 2.HashMap的底层支持求null的关键码值，即hash(Object key),当key==null,hash(key)=0,即null key总是存储再哈希表的索引0处
        hm.put(null,null);
        // put方法不仅支持新增，还支持修改。当新增时，说明key对应的索引还没有节点，可以直接赋值，此时返回null,put方法返回值类型是V的类型
        String res1 = hm.put("重地", "qfc");
        System.out.println(res1);//null
        // 当key对应的索引已经有节点时，则此时检查 (hash(key)==hash(oldkey) && (key==oldkey || (key!=null && key.equals(oldKey))))
        // 当前key和oldkey通过哈希函数计算出来的索引相同，那么当key和oldkey相同时，
        // 则说明此时是put修改功能,put方法会用value覆盖oldValue，put方法返回被覆盖的value
        // 否则就是哈希冲突，put则还是新增功能，返回null
        String res2 = hm.put("通话", "zyx");
        System.out.println(res2);//null

        String res3 = hm.put("重地", "qfc1");
        System.out.println(res3);//qfc
    }

    static void noParamConstractor(){
        //使用无参构造器创建对象时，底层的哈希表table并没有初始化
        // 但是此时已经设置了哈希表的关键属性：threshold=0,loadFactor=0.75
        // 注意此时threshold=0表示，初始化table时，table的初始化容量使用默认初始化容量16
        HashMap<Integer, String> hm = new HashMap<>();
        hm.put(1,"qfc");//第一次put时，内部调用resize方法初始化table为长度16的数组。且更新threshold值为16*0.75=12
        hm.put(2,"zyx");
        hm.put(3,"qdh");
    }

    static void oneParamConstractor(){
        // 指定初始容量的构造器，使用该构造器创建对象，底层哈希表table同样没有初始化
        // 但此时已经设置了哈希表的关键属性：threshold=tabsizeFor(3),loadFactor=0.75
        // 其中tableSizeFor的方法作用是将3转为大于或等于它的2的幂，即4。
        HashMap<Integer, String> hm = new HashMap<>(3);
        hm.put(1,"qfc");//第一次put，内部调用resize方法初始化table为长度4的数组。且更新threshold值为4*0.75=3。
        hm.put(2,"zyx");
        hm.put(3,"qdh");
        hm.put(4,"qdz");// 当添加该键值对时，底层哈希表会再次扩容一次，因为此时size>threshold
        /**
         * 扩容方案是：容量扩容两倍,容量变为8,threshold也扩容两倍，变为6（只是采用的是capacity*loadFatcor,此时locaFator不变，capacityy扩大2倍）
         * 当老数组容量大于等于16时，threshold扩容会采用左移一位方式来提升效率，因为位运算比乘2运算快
         */
    }

    static void twoParamConstractor(){
        /**
         * 指定初始化容量和负载因子的构造器，使用该构造器创建对象不会初始化哈希表table
         * 但是此时已经设置了哈希表的两个关键属性：threshold:tableSizeFor(3),loadFactor:0.8
         */
        HashMap<Integer, String> hm = new HashMap<Integer, String>(3, 0.8f);
        hm.put(1,"qfc");//第一次put，内部调用resize方法初始化table为长度4的数组。且更新threshold值为4*0.8=3。
        hm.put(2,"zyx");
        hm.put(3,"qdh");
        hm.put(4,"qdz");// 当添加该键值对时，底层哈希表会再次扩容一次，因为此时size>threshold
        /**
         * 扩容方案是：容量扩容两倍,容量变为8,threshold也扩容两倍，变为6（只是采用的是capacity*loadFatcor,此时locaFator不变，capacityy扩大2倍）
         * 当老数组容量大于等于16时，threshold扩容会采用左移一位方式来提升效率，因为位运算比乘2运算快
         */
    }
    
    static void mapParamConstractor(){
        HashMap<Integer, String> hm = new HashMap<Integer, String>(3, 0.8f);
        hm.put(1,"qfc");
        hm.put(2,"zyx");
        hm.put(3,"qdh");
        hm.put(4,"qdz");

        /**
         * 指定初始键值对的构造器。使用该构造器创建对象时，已经初始化好了table
         * 该构造器使用默认负载因子0.75
         */
        HashMap<Integer, String> hm1 = new HashMap<>(hm);
        /**
         * 该构造器内部会调用putMapEntries方法
         * 关于putMapEntries实现
         * 首先判断被添加的Map集合hm是否初始化或为空？若hm为空，则hm1的threshold不做处理，还是初始值0
         * 若hm不为空，则hm1必须支持存储hm.size()个键值对。但是不能直接将hm.size()设置为hm的哈希表容量
         * 因为这样会导致一次扩容。比如hm.size()=4，则存储到3个时，就会触发扩容
         *
         * 则为了防止扩容操作
         * hm1.size()*loadFactor > hm.size()
         * 即 hm1.size() > hm.size()/loadFactor
         * 那么就将hm1.size() = hm.size()/loadFatcor + 1
         * 而由于此时hm1是初始化，所以tableSizeFor(hm1.size()) = threshold
         * 则threshold = 8;
         */

    }
}

思考题

当你需要存13个键值对到HashMap中，那么使用哪种构造器创建对象比较好？

如果使用无参构造器，则底层哈希表容量为默认初始化容量16，此时扩容阈值是12，则存储第13个元素后，会触发扩容。

如果使用指定容量构造器，那么直接指定初始化容量为13，底层会将tableSizeFor(13)容量，即16容量，作为哈希表容量，同样存储第13个元素后，会触发扩容。

如果使用指定容量构造器，但是预判扩容时机，则指定容量为 tableSizeFor(13 / 0.75 + 1)=32，这样就不会触发扩容。

 

为什么HashMap的key为自定义对象时，那么该对象的类需要同时重写hashCode和equals方法？

HashMap内部会根据key的关键码值计算出其再哈希表中的索引位置。

key的关键码值计算需要调用(h = key.hashCode) ^ (h>>>16),其中会用到hashCode()方法，所以key需要重写hashCode()方法

当key关键码值计算出来的索引已经有节点占用了，那么就需要判断是否发生哈希冲突？如果key和占用key不相同，则说明发生哈希冲突。

其中判断key和占用oldKey相同的逻辑是：

hash(key) == hash(oldKey) && (key==oldKey || (key!=null && key.equals(oldKey)))

其中用到了key的equals方法。

另外需要保证当hashCode返回值相同时，对应的equals结果也要相同，否则就会很麻烦。

 

为什么keySet(),values(),entrySet()方法返回的集合在遍历过程中不能新增或删除元素？

因为keySet()返回的时KeySet类对象，该类没有存储数据，而是在遍历时，内部调用迭代器遍历HashMap的哈希表。我们知道迭代器迭代过程中，只能使用使用迭代器进行新增删除，不能使用集合进行新增删除，或者会抛出并发修改异常。

values(),entrySet()也是这个原因

 

为什么不建议使用keySet()方法去遍历HashMap实例的key-value，而是使用enterySet()方法？

因为keySet()返回的是key列的Set集合。此时keySet()是内部依赖迭代器遍历HashMap的哈希表的所有节点的key。

后面还要hm.get(key)。此时还是需要去基于key去遍历HashMap的哈希表的所有节点的value。

所以使用keySet()遍历KV时，内部遍历了两次HashMap的哈希表

但是enterySet()返回的时key-value键值对Map.Entry类型对象，只需要遍历一次HashMap的哈希表的所有节点，就可以得到所有KV。

程序员阿甘
关注
专栏目录
HashMap(二)
cnhaaa的博客
05-17 198
文章目录内部红黑树结点类属性内部方法左旋右旋插入后平衡操作树的分裂将链表转换为树将树转换为链表红黑树插入链表树形化参考 这篇文章主要关注HashMap中有关红黑树的相关操作。 内部红黑树结点类 属性 static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { TreeNode<K,V> parent; // 指向父结点的指针 red-black tree
Map集合之HashMap
桐花思雨
09-09 1355
一：HashMap概述 HashMap 是通过 put(key,value) 存储，get(key)来获取。当传入 key 时，HashMap 会根据 key 的 hashCode() 方法计算出 hash 值，根据 hash 值将 value 保存在 bucket(桶)里。当计算出的 hash 值相同时，称之为 hash 冲突。HashMap 的做法是用 链表和红黑树 存储相同 hash 值的 value 二：Hash冲突，以及解决方法 hash 冲突：两个元素通过 hashCode() 计算出的值是一样
HashMap深度解析(二)
热门推荐
寻道
11-26 6万+
       本文来自：高爽|Coder，原文地址：http://blog.csdn.net/ghsau/article/details/16890151，转载请注明。        上一篇比较深入的分析了HashMap在put元素时的整体过程，Java Collections Framework中实际操作的都是数组或者链表，而我们通常不需要显示的维护集合的大小，而是集合类框架中内部维护，方便的同...
HashMap2
weixin_42146996的博客
07-16 267
由于今年疫情的原因，再加上学业的繁重和找工作的艰难准备，csdn个人博客的文章从去年放寒假到现在一直没有更新过了，在这半年的时间里，自己对于所学的知识有了一个更加清晰的认知，发现以前的文章有很多错误，难免有误人子弟的嫌疑，所以在接下来的时间我会将前面文章的错误一一改正，并继续写出高质量的技术文章，欢迎广大网友的批评与指正。
关于HashMap几个刁钻的面试题
砖家穴者叫兽的博客
09-15 1万+
1：HashMap 的数据结构？ A：哈希表结构（链表散列：数组+链表）实现，结合数组和链表的优点。当链表长度超过 8 时，链表转换为红黑树。 transient Node<K,V>[] table; 2：HashMap 的工作原理？ HashMap 底层是 hash 数组和单向链表实现，数组中的每个元素都是链表，由 Node 内部类（实现 Map.Entry<...
Java集合之HashMap(二)
一江溪水
07-22 136
HashMap扩容机制 明确几个参数： capacity 即容量，默认16。 loadFactor 加载因子，默认是0.75 threshold 阈值。阈值=容量*加载因子。默认12。当元素数量超过阈值时便会触发扩容。 什么时候触发扩容？ 一般情况下，当元素数量超过阈值时便会触发扩容。每次扩容的容量都是之前容量的2倍。 HashMap的容量是有上限的，必须小于1<<30，即1073741824。 如果容量超出了这个数，则不再增长，且阈值会被设置为Integer.MAX_VALUE 什么是
Map集合和HashMap键值理解及相关练习
weixin_45614621的博客
04-12 465
从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队 。八、定义一个泛型为String类型的List集合，统计该集合中每个字符（注意，不是字符串）出现的次数。例如：集合中有”abc”、”bcd”两个元素，程序最终输出结果为：“a = 1,b = 2,c = 2,d = 1”。第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]
JavaSE之Map集合以及HashMap和LinkedHashMap
Meteorazj的博客
03-03 606
一、Map<K,V>集合 Map集合被称为双列集合，每个元素包含键（Key）和值（Value），将键映射到值，一个映射不能包含重复的键，每个键最多只能映射到一个值，即Key和Value是一一对应的 Map集合下的常用子类包括HashMap和LinkedHashMap，HashMap的底层是哈希表，即数组+链表/红黑树，并且是一个无序的集合，存储元素和取出元素的顺序可能不一致，LinkedHashMap的底层是哈希表+链表，是一个具有可预知迭代顺序的集合 Map接口中的常用方法 1.p
Java集合之HashMap用法详解
08-30
Java集合之HashMap用法详解主要介绍了Java集合之HashMap用法，结合实例形式分析了java map集合中HashMap定义、遍历等相关操作技巧。 HashMap概述 HashMap是Java集合框架中最常用的Map集合，它的键值对在存储时要...
Java中集合Map HashMap
m0_46550052的博客
09-24 307
Java中集合Map HashMap
哈希表之HashMap(二)
weixin_34238642的博客
06-11 77
在写这篇文章之前，看了很多关于HashMap解析的文章。对于大多数人来说，可了跟着别人的文章走一遍。大家都能了解HashMap的内部结构，使用方法以及注意事项。我还是觉得知道用是一回事。知道原理是另一回事。只有了解了其数据结构设计初衷。才能更好的使用它。此系列文章主要分为两个部分，具体目录如下： 哈希表初识(一) 哈希表之HashMap(二) 提示：该篇文章作为彻底理解哈希表的第二个部分...
HashMap的详细介绍(2)
迷途菜鸟
01-05 1082
HashMap的详细介绍 —–本文只针对1.7版本的HashMap所讲解. 通过上一章的讲解HashMap的详细介绍(1)我们知道了HashMap的构造过程,随即引出了两个问题，一：HashMap的容量为什么一定要是2的次幂？二：如果put元素数量大于阈值 一定会扩容吗？现在我们就来对这俩个问题进行讲解.看代码: public V put(K key, V value) {
Map＜String,Object＞ res = new HashMap＜＞(2)这个2是什么意思
我真的睡不够
12-08 4842
HashMap(intinitialCapacity)构造一个带指定初始容量和默认加载因子(0.75)的空HashMap。 参数： initialCapacity-初始容量。 抛出： IllegalArgumentException-如果初始容量为负。 加载因子越高空间利用率提高了但是查询时间和添加时间增加 hashmap是这样存的 先利用hashcode找到需要存的地方 但是存的地方肯定是有限的就是hashMap分配到的空间比如是10 ...
java hashmap(2)
sinat_35719640的博客
12-04 144
另外开一篇 下面开始记hashmap的public，讲道理对方法实现的顺序感到不解，为什么喜欢用前面实现的方法去调用后面实现的方法呢，这样看到前面的方法时，总会调用还没实现的方法，对于可读性差了点哇   第一个方法是构造函数HashMap(int initialCapacity, float loadFactor) 做了一些输入合法性判断，然后给成员变量加载因子复制，给成员变量thresho...
Java集合类学习--HashMap（二）
CodersCoder的博客
10-11 101
常用&核心方法 1 、put 方法 public V put(K key, V value) { // 调用hash(key)计算出key的hash值 return putVal(hash(key), key, value, false, true); } static final int hash(Object key) { int h; // 如果key为null，则hash值为0，否则调用key的hashCode()方法 // 并让高16位与整个has
浅析HashMap【2】查增
qq_38732834的博客
05-14 178
查 真正的实现就是这个。 首先判断桶表是不是未实例化，然后再判断桶表的长度是否大于0，最后再判断检索到的桶表索引是否为空。 如果以上条件都满足后。 再看是否为头结点(同一对象或者相同对象)，如果是返回头结点的值。 再判断是否为红黑树结构，如果是，以红黑树的查询方式，则首先比较其哈希值的大小关系来找，如果哈希值是一样的(如果出现这种情况估计真能中彩票了，要不然就是彩票基本上被包圆了(滑稽))，那么看是否实现了Comparable接口，如果实现了按照这个大小关系查找，如果没有实现那就深搜吧。 所以加入HashM
源码解析系列：HashMap(2) - 核心方法
Jwasx的博客
12-17 1233
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录1. 前言2. HashMap核心方法1. get2. containsKey3. put4. resize 1. 前言 HashMap(1)中介绍了一些相关的方法的原理和一些重要的参数以及四种构造方法。本文会结和上一篇文章介绍HashMap中几个常用的方法。有些地方调用了红黑树的查找，关于红黑树的方法的解析，在系列的最后会讲解。第一篇文章：https://blog.csdn.net/laohuangaa/article/deta
细粒度拆分HashMap＜2＞
抛弃幻想，准备斗争
12-16 270
对于上篇文章遗漏了一点： 在进行<<、>>和>>>运算的时候需要考虑正负的情况 <<：不分正负数，低位补0； “>>”：如果该数为正，则高位补0，若为负数，则高位补1； “>>>”：若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0 在面试HashMap的时候，你是不是背面试答案还是真的有去研究分析源...
读HashMap（二）
不做程序员的博客
04-27 378
最近好久都没有写博客了，每天都盯着电脑在忙，但也没忙出个什么东西，可能有点眼高手低了吧，最近又搜索了下HashMap底层知识，在这把自己的理解记录一下： 先把源码中声明的一些常量和全局变量挪过来方便看 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable...
java集合类之map的hashmap
最新发布
06-28
Java中的Map接口提供了一种将键映射到值的对象。其中一种实现是HashMap，它使用哈希表来实现。HashMap允许 null 键和 null 值，并且没有顺序保证。HashMap 的操作复杂度为 O(1) 平均复杂度，因此在许多情况下非常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员阿甘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值