哈希表和Map接口

已于 2023-03-04 13:13:35 修改
阅读量1.4k 收藏 3
点赞数 1
文章标签： 数据结构 散列表 b树
于 2022-02-26 21:16:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58342797/article/details/123120635
版权

目录

 

哈希表

避免哈希冲突

设计哈希函数

调节负载因子

解决哈希冲突

开放地址法

线性探测法

二次探测法

链地址法

Map接口

HashMap集合

HashMap的底层实现

常用方法

put方法---添加元素

get方法--根据key值得到value值

 遍历

 LinkedHashMap集合：保证元素的输入顺序

 TreeMap集合

treemap和hashmap的区别

1、输出的有序性

 2.对null的要求

 3、性能分析

我们查找一个数据时，遍历元素的查找时间复杂度O（n），二分查找的时间复杂度O（log2N)……那有没有可能查找的时间复杂度在O（1）呢？这就是哈希表

哈希表

根据某一种映射关系，将元素存储在某一个特定位置，查找元素时，根据这个映射关系得到存储位置---》这就是哈希表

这个映射关系就是哈希函数

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

但是有一个问题，如果我还有一个元素是33呢，根据上图的映射关系，33%11==0，应该放在0下标，但是0下标已经有一个元素11了，33又放到哪里？这种产生的冲突就是哈希冲突

那么如何避免，如何解决哈希冲突呢？

避免哈希冲突

设计哈希函数

设计更好的哈希函数，可以尽量避免哈希冲突

好的哈希函数满足的条件：

  • 哈希函数的定义域必须包括了所有的数据。如果哈希表长度是m，那么所有的数据使用哈希函数得到的下标都必须在0~m-1之间
  • 元素按照哈希函数得到的存储位置尽可能的均匀
  • 哈希函数尽量简单

常用的哈希函数设计方法：

1、直接定址法：hash（key）=A*key+b

线性函数：y=kx+b---》均匀的分布在线性函数附近

2、除留余数法：hash（key）=key%a---得到的下标位置[0~a-1]

调节负载因子

负载因子=存入哈希表的元素个数/哈希表的长度

如果负载因子过大，冲突的可能性越大，那么就可以来增大哈希表的长度来减少发生冲突的可能

f537a0da077a894c3ddc8e3f77a17225.png

解决哈希冲突

冲突无法完全避免，我们要想办法解决冲突

开放地址法

只要数组有空元素，找到空元素位置存放冲突元素

线性探测法

 H=(hash(key)+d)%m

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

二次探测法

H=(hash(key)±a^2)%m

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

链地址法

数组+链表

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

  jdk1.8开始, 当链表长度超过8且数组长度超过64，这时候链表会转为红黑树（查找非常高效的树）

通常情况下，哈希表插入和查找的时间复杂度O（1)

Map接口

一个人的身份证号唯一对应了这个人，这种具有对应关系的数据的存储就需要Map接口

Map接口是一种双列集合，每个元素都包含一个键对象Key和值对象Value，键和值之间存在着某一种对应关系，称为映射

Map接口中的映射关系是一对一的，一个键对象对应着唯一的值对象，Key和Value都可以是任意的数据类型，并且键对象Key不允许重复，这样通过key可以找到唯一指定的value（key---value模型）

HashMap集合

HashMap集合是Map接口的实现类，用于存储键值之间的映射关系，键不能重复，且集合元素是无序的

HashMap的底层实现

hashmap的底层是一个哈希表，这个哈希表使用链表解决冲突（JDK1.8后，当链表长度大于8且数组长度>64，链表变成红黑树）

常用方法

put方法---添加元素

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

 如何添加元素： 

1、根据提供的key（键值）得到对应的hash值

2、根据对应的hash值，找到哈希表数组的相对应存储位置

3、判断这个数组位置是不是有结点，没有结点直接插入结点；数组位置有结点，判断链表中是否有结点的key和插入结点的key相同，相同意味着value值要更新；如果不存在一个结点的key和插入结点的key相同，那么意味着要在链表插入结点（jdk1.8之后使用尾插法）

4、插入一个元素，就要计算负载因子，负载因子越大，产生冲突的可能性就越大，可以通过增大数组长度来减小负载因子。（数组不是单纯的扩容，数组长度改变，哈希函数改变，所有元素都需要重新哈希入新的数组）

简单的模拟实现：

public class Myhashmap {
    class Node {
        int key;
        int value;
        Node next;

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "key=" + key +
                    ", value=" + value +
                 "}";
        }
    }

    private int count = 0;//记录存入的数据个数
    private final float loadFactor = 0.75f;//hashmap默认的装载因子是0.75f
    Node[] table = new Node[10];//table存放的是new Node这个实例化对象的引用，现在存放是null

    /**
     * 根据key插入元素value
     */
    public void put(int key, int value) {
        //第一步，设计hash函数，得到hash值
        int hash = key % table.length;

        //第二步：插入结点的key已经存在
        Node cur = table[hash];
        while (cur != null) {
            if (cur.key == key) {
                cur.value = value;
                return;
            }
            cur = cur.next;
        }
        //第三步：插入结点的key不存在(jdk1.8后使用尾插法）
        cur = table[hash];
        Node newode = new Node(key, value);
        if (cur == null) {
            table[hash] = newode;
            count++;
            loadFactor(key, value);
            return;
        }
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = newode;
        count++;
        //第四步，计算装载因子（存入的元素个数除以数组长度）
        loadFactor(key, value);
    }

    private void loadFactor(int key, int value) {
        if (count * 1.0f / table.length > loadFactor) {//数组扩容，hashmap数组2倍扩容
            reseize();
        }
    }

    private void reseize() {
        Node[] newtable = new Node[table.length * 2];
        //遍历之前的数组，例如hash（4)存储的key=14就要重新hash到新数组的hash（14）位置
        for (int i = 0; i < table.length; i++) {
            Node cur = table[i];
            Node newnode;
            while (cur != null) {//链表的每一个元素全部重新哈希（jdk1.8后使用尾插法，其实头插简单）
                int hash = cur.key % newtable.length;
                newnode = newtable[hash];
                Node curNext = cur.next;
                cur.next = null;
                if (newnode == null) {
                    newtable[hash] = cur;
                    cur = curNext;
                    continue;
                }
                while (newnode.next != null) {
                    newnode = newnode.next;
                }
                newnode.next = cur;
                cur = curNext;
            }
        }
        table = newtable;
    }
    public void print() {
        for (int i = 0; i < table.length; i++) {
            Node node = table[i];
            while (node != null) {
                System.out.println(node);
                node = node.next;
            }
        }
    }
}

hashmap的源码设置：

数组长度默认16，二倍扩容，负载因子是0.75，当链表长度超过8并且数组长度超过64的时候，链表转化为红黑树

数组长度是2的倍数

如果传入长度17，那么编译器会找到>=17最近的2的倍数，也就是32,这时数组长度是32

get方法--根据key值得到value值

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

模拟实现：

 public Node get(int key) {
        for (int i = 0; i < table.length; i++) {
            Node node = table[i];
            while (node != null) {
             if(node.key==key)
                 return node;
                node = node.next;
            }
        }
        return null;
    }

 hashmap的泛型类实现：

class Person{
    int ID;
    public Person(int ID) {
        this.ID = ID;
    }

    @Override
    public String toString() {
        return "Person{" +
                "ID=" + ID +
                '}';
    }
}

public class hash {
    public static void main(String[] args) {
        Person person=new Person(123);
        Person person1=new Person(123);
        System.out.println(person.hashCode());
        System.out.println(person1.hashCode());
    }
}

hashCode方法可以将引用类型转化为整数，但是我们想让身份证后三位相同的人，产生相同的hash值，发现做不到，产生的整数值是不相同的

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

 但是，我们重写equals and hashCode方法之后：

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_14,color_FFFFFF,t_70,g_se,x_16

 就会产生相同的整数watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

 为什么要同时重写equals（）和 hashCode（）方法呢？

equals（）用于比较是否相等，hashCode（）用于生成整数

hashCode()相同，equal（）不一定相同

equals（）相同，hashCode（）一定相同

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

public class Myhashmap<K,V> {
     class Node <K,V>{
        K key;
        V value;
        Node <K,V>next;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "key=" + key +
                    ", value=" + value +
                 "}";
        }
    }

    private int count = 0;//记录存入的数据个数
    private final float loadFactor = 0.75f;//hashmap默认的装载因子是0.75f
    Node <K,V>[] table = new Node [10];//table存放的是new Node这个实例化对象的引用，现在存放是null

    /**
     * 根据key插入元素value
     */
    public void put(K key, V value) {
        //第一步，设计hash函数，得到hash值
        int hash = key.hashCode() % table.length;

        //第二步：插入结点的key已经存在
        Node <K,V>cur = table[hash];
        while (cur != null) {
            if (cur.key .equals(key) ) {
                cur.value = value;
                return;
            }
            cur = cur.next;
        }
        //第三步：插入结点的key不存在(jdk1.8后使用尾插法）
        cur = table[hash];
        Node<K,V> newode = new Node<K,V>(key, value);
        if (cur == null) {
            table[hash] = newode;
            count++;
            loadFactor(key, value);
            return;
        }
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = newode;
        count++;
        //第四步，计算装载因子（存入的元素个数除以数组长度）
        loadFactor(key, value);
    }

    private void loadFactor(K key, V value) {
        if (count * 1.0f / table.length > loadFactor) {//数组扩容，hashmap数组2倍扩容
            reseize();
        }
    }

    private void reseize() {
        Node<K,V>[] newtable = new Node[table.length * 2];
        //遍历之前的数组，例如hash（4)存储的key=14就要重新hash到新数组的hash（14）位置
        for (int i = 0; i < table.length; i++) {
            Node<K,V> cur = table[i];
            Node<K,V> newnode;
            while (cur != null) {//链表的每一个元素全部重新哈希（jdk1.8后使用尾插法，其实头插简单）
                int hash = cur.key.hashCode() % newtable.length;
                newnode = newtable[hash];
                Node<K,V> curNext = cur.next;
                cur.next = null;
                if (newnode == null) {
                    newtable[hash] = cur;
                    cur = curNext;
                    continue;
                }
                while (newnode.next != null) {
                    newnode = newnode.next;
                }
                newnode.next = cur;
                cur = curNext;
            }
        }
        table = newtable;
    }
    public void print() {
        for (int i = 0; i < table.length; i++) {
            Node<K,V> node = table[i];
            while (node != null) {
                System.out.println(node);
                node = node.next;
            }
        }
    }
    public Node<K,V> get(int key) {
        for (int i = 0; i < table.length; i++) {
            Node<K,V> node = table[i];
            while (node != null) {
             if(node.key.equals(key))
                 return node;
                node = node.next;
            }
        }
        return null;
    }
}

 遍历

1、迭代器

    public static void main(String[] args) {
        Map <String,Integer> map=new HashMap<>();
        map.put("123",1);
        map.put("145",9);
        Set<String>set=map.keySet();//获取key值的集合
        Iterator  it=set.iterator();
        while(it.hasNext()){
            Object key=it.next();//获取key
            Object value=map.get(key);//获取key对应的value
            System.out.println(key+" "+value);
        }
    }

2、

  public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("123", 1);
        map.put("145", 9);
        Set set = map.entrySet();//将所有的键值对打包到一起，成为Set集合返回
        Iterator it=set.iterator();
        while(it.hasNext()){
            Map.Entry ret=(Map.Entry)(it.next());//将Iterator对象的其中一个转化为  Map.Entry<K，V>
            Object key=ret.getKey();
            Object value=ret.getValue();
            System.out.println(key+" "+value);
        }
    }

3、for-each

Lambda表达式的函数式接口BIConsumer

  public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("123", 1);
        map.put("145", 9);
       map.forEach((key,value)-> System.out.println(key+" "+value));
    }

 LinkedHashMap集合：保证元素的输入顺序

使用hashmap集合无法保证集合元素的存入和取出顺序

LinkedHashMap是hashmap的子类，内设双向链表来维护元素内部之间的关系，保证元素的输出顺序和存入顺序一致

  public static void main(String[] args) {
        Map<Integer, Integer> map = new HashMap<>();
        map.put(1, 9);
        map.put(3,0);
        map.put(2, 1);
        System.out.println(map);

        Map<Integer, Integer> map1 = new LinkedHashMap<>();
        map1.put(1, 9);
        map1.put(3,0);
        map1.put(2, 1);
        System.out.println(map1);
    }

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

 TreeMap集合

底层实现是一个红黑树

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

  TreeTree会自动对key值进行排序存储（String 类实现了Comparator接口）hashtree适用于key有序的情况下

treemap和hashmap的区别

1、输出的有序性

hashmap的key值无顺序，treemap的key有顺序

    public static void main(String[] args) {
        Map<Integer,String>map=new HashMap<>();
     map.put(78,"8");
        map.put(0,"8");
        map.put(89,"8");
        System.out.println(map);
        Map<Integer,String>maptree=new TreeMap<>();
        maptree.put(78,"8");
        maptree.put(0,"8");
        maptree.put(89,"8");
        System.out.println(maptree);
    }

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

 

 2.对null的要求

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

 hashmap可以让key和value都是null

1、key==null&&value==null ---存入键值对（null，null）

2、key==null&&value！=null ---不存入键值对，但是不会抛出异常

3、key！=null&&value==null ---存入键值对（key，null）

treemap的key不能是null，value可以是null，否则抛出异常

  public static void main(String[] args) {
        Map<String,Integer> maptree=new TreeMap<>();
        maptree.put("hi",null);
        System.out.println(maptree);
        System.out.println(maptree.size());
    }

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdHdvIOWAqQ==,size_20,color_FFFFFF,t_70,g_se,x_16

 3、性能分析

hashmap的底层是链表+数组，查找和插入的时间复杂度都是O（1）

treemap的底层是红黑树，查找和插入的时间复杂度都是O（log2 N）

 

 

two 倩
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HashMap解读
不知名路人甲的博客
01-01 1550
HashMap ，是一种散列表，用于存储 key-value 键值对的数据结构，一般翻译为“哈希表”，提供平均时间复杂度为 O(1) 的、基于 key 级别的 get/put 等操作。哈希表结构为数组，链表和红黑树。如图哈希表渴望实现O1的查找时间复杂度，因此采用数组作为基础结构，通过哈希函数，计算key的哈希值，哈希表指示存储数组的下标，但是会出现不同key对应同一个哈希值，则称作哈希碰撞，采取拉链法解决，将同一下标的所有节点链接为链表。但是当链表长度过长，hash表便也失去了平均o1的特性。因此在一定条
HashMap 详解
jacket350401的博客
08-09 3719
HashMap 详解
哈希表详解及模拟实现（unordered_map）
最新发布
yao_yao0524的博客
05-27 1138
C++STL，unordered_map哈希表模拟实现。
（新手必看）HashMap是什么？
xyk：的博客
04-05 1万+
那么HashMap什么时候进行扩容呢？当hashmap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，也就是说，默认情况下，数组大小为16，那么当hashmap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为2*16=32
【数据结构】哈希表（Map和Set）
haoshaokang_的博客
06-07 1299
3️⃣当堆中不够K个元素时，就直接入堆，入够K个元素之后，此时按照比较规则，堆顶元素一定是出现频率最小的，如果堆中还有其他元素和堆顶元素频率相同，那堆顶元素应该是字典序靠后的。4️⃣再接着遍历集合元素，如果当前元素比堆顶元素频率高，则出堆顶元素，入当前元素；如果当前元素和堆顶元素频率一样高，再比较字典序，如果堆顶元素靠后，则出堆顶元素，入当前元素。5️⃣最终依次出堆顶元素到List中，然后逆序List即可。
HashMap详解
热门推荐
java123456111的博客
03-09 5万+
一、HashMap集合简介 HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null，此外，HashMap 中的映射不是有序的。 jdk1.8 之前 HashMap 由 数组 + 链表 组成，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突（两个对象调用的 hashCode 方法计算的哈希值经哈希函数算出来的地址被别的元素占用）而存
哈希map以及set的封装
04-05
在这个场景中，我们讨论的是C++中的哈希表实现，即`哈希map`和`哈希set`的封装，它们是STL（标准模板库）的一部分，由`unordered_map`和`unordered_set`两个容器来表示。 首先，我们来看`哈希map`。`std::unordered...
java中哈希表及其应用详解
09-03
在Java中，哈希表的实现主要体现在`Hashtable`类中，它是`Dictionary`类的子类，并且实现了`Map`接口。`Hashtable`内部使用了一个`Entry`类来保存单元数据，每个`Entry`实例都包含一个键和一个值，它们共同构成了...
Java Map接口及其实现类原理解析
08-19
LinkedHashMap是基于链表和哈希表的Map接口实现类，它提供了一个有序的映射关系，可以根据插入顺序或访问顺序来排序。LinkedHashMap不允许null键，但允许null值。底层数据结构是链表和哈希表，保证键唯一，且可以...
JAVA中哈希表HashMap的深入学习
08-18
Entry类实现了Map.Entry接口，其中包含了key、value、next引用和一个hash属性，用于存储键的哈希码值。 初始化时，HashMap的table是一个空的Entry数组，随着元素的添加，数组会自动扩容以保持负载因子（默认为0.75...
哈希表 华北电力大学
06-20
这些容器内部已经实现了哈希表的机制，提供了一套接口供用户使用。 哈希表在实际应用中广泛，如数据库索引、缓存系统、字符串查找、唯一标识生成等。例如，数据库使用哈希索引可以快速定位记录；缓存系统（如Redis...
hashmap哈希map是什么？什么时候需要使用hashmap？C实现hashmap示例
猪哥的专栏
12-25 1578
对于C程序员，尤其是嵌入式C程序员，hashmap使用的相对较少，所以会略显陌生，hashmap其实涉及到2个概念，分别是哈希(hash)、map。哈希hash：是把任意长度输入通过蓝列算法变换成固定长度的输出，这种转换是一种压缩映射，一般不可逆。这是专业的解释，我们常说的crc16、crc32、lrc、md5、sha256等，本质上都是哈希hash，只不过散列算法不同而已。
HashMap 简述
学海无涯,我用JAVA
05-08 605
HashMap 是开发中常用的一种数据结构,通常用做返回值,计算比对等,会经常用到;可是很多key的hashcode值如果相同,下标相同怎么办?于是出现了链表结构,就是当很多key的hashcode值相同的时候,即哈希冲突,那么此时会在这个下标下面挂出一个链表,用来存储产生了哈希冲突的key,那么它的下标如何计算?哈希值都是同一个,应该是对当前所在链表的长度取模,作为它的唯一下标;这里仅仅是对于hashmap的一个简单介绍,主要说明了哈希冲突的由来,以及底层存储结构的选择的理由;
【数据结构】哈希表以及HashMap(基本原理、手动实现)
qq_53180719的博客
03-26 1073
目录 一、上集回顾 二、基本原理 三、闭散列方法 四、开散列方法（哈希桶） 五、HashMap的手动实现 六、进一步分析 一、上集回顾 我们已经了解了Set和Map的基本性质，并且我们使用二叉搜索树实现了简单的TreeSet的功能，其实TreeMap的实现方法和TreeSet是类似的，我们不再介绍。接下来我们会引入一个新的数据结构哈希表（HashTable），并以此来实现HashMap类，同样，HashSet类似，就不介绍了。 二、基本原理 什么是...
map和哈希map区别及使用场景
Runnymmede的博客
02-14 370
哈希map的实现需要两个条件：可以判断两个class变量是否相等的函数。（直接重载operator==即可）可以计算class地址的函数。（实现一个std::hash模板类，重载operator()）public:int first;// 重载判断class是否相等的函数// 实现Myclass的hash函数??暂时不知道有何用，建议实际尝试后再决定是否保留该句// 自己设计地址计算方法即可（随便写，尽量使不同的变量有不同的返回值）return res;
Hash哈希（hashCode、HashSet 、HashMap）
Alvin_hcf的Blog
03-30 1008
文章目录HashHashMap类hashCode()方法hashCode() 与 equals() 的关联情况1（不重写hashCode()和equals() 方法）情况2（仅仅重写hashCode()方法）情况3（重写hashCode()和equals() 方法） Hash 哈希表基础： hash函数：Index = hash(key) 除留取余 ：index = key MOD p 折叠法 平方取中 … 哈希冲突 开放定址 链地址法 再散列法 HashMap类 HashMap使用的
hash与HashMap详解
godoom的博客
01-13 627
hash与HashMaphash的介绍优秀的哈希算法特点java中的hash其他场景中的Hash算法哈希算法的用途碰撞性及解决方法手写模仿HashMap主要功能研究HashMap源码 1.7HashMap是线程不安全的为什么要用2的次方数作为数组大小？为什么重写equals的时候要重写hashCode方法? hash的介绍 Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输...
哈希表与unordered_map
08-12
哈希表和unordered_map是相关概念，但在具体实现和使用上存在...总的来说，unordered_map是C++中使用哈希表实现的一种容器，提供了方便的接口和功能。哈希表是一种数据结构的概念，需要自己实现或使用第三方库来构建。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值