哈希表和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
    评论
js——Set和Map，以及哈希表
leilei7407的博客
05-16 1万+
1.哈希表 参考链接 哈希表概述： 散列表（Hash table，也叫哈希表），是根据关键值(Key)而直接进行访问的数据结构。也就是说，它通过把关键值key映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数(哈希函数)，存放记录的数组叫做散列表。（哈希表一般用数组来存储） 向哈希表中存数据： 根据数据的key值和哈希函数，得到一个数组下标，这个下标的含义是数据在哈希表中的存放的位置。若发生了冲突，则再根据冲突的处理方法来解决冲突。找到最终存放的位置后，将数据存放进去。 在哈希表中查
【数据结构】哈希表（Map和Set）
haoshaokang_的博客
06-07 1307
3️⃣当堆中不够K个元素时，就直接入堆，入够K个元素之后，此时按照比较规则，堆顶元素一定是出现频率最小的，如果堆中还有其他元素和堆顶元素频率相同，那堆顶元素应该是字典序靠后的。4️⃣再接着遍历集合元素，如果当前元素比堆顶元素频率高，则出堆顶元素，入当前元素；如果当前元素和堆顶元素频率一样高，再比较字典序，如果堆顶元素靠后，则出堆顶元素，入当前元素。5️⃣最终依次出堆顶元素到List中，然后逆序List即可。
MAP哈希表
qq_55996124的博客
08-23 1069
Map接口 1. 说一下 HashMap 的实现原理？ HashMap概述： HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变 HashMap的数据结构：HashMap是一个“散列表”的数据结构，即数组和链表的结合体 HashMap 基于 Hash 算法实现的： ①当我们往Hashmap中put元素时，利用key的hashCode重新hash计算出当前对象的元素在数组中的下标 ②存
哈希表详解及模拟实现（unordered_map）
最新发布
yao_yao0524的博客
05-27 1153
C++STL，unordered_map哈希表模拟实现。
什么是哈希表？什么是set和Map集合？他们之间有什么关系
qq_48584557的博客
02-10 1471
哈希表，哈希桶，map集合，set集合，hashCode方法
哈希算法和哈希表
qq_41757528的博客
09-16 1824
这篇文章将会简单介绍几种常见的哈希算法，然后是C++或Java的标准库中哈希函数与哈希表的基本使用，最后将会提供一个使用C语言手搓FNV-1a算法的示例，以及使用它实现的哈希表。这篇文章虽然内容不多，但前前后后，也是删删改改了好多天了，虽然内容还是不尽人意，但希望此文能为你提供一点帮助，不说理解哈希，至少能够使用吧。不知道某位大佬会不会来看这篇文章，关于哈希表的部分我不是很拿得准，如果理解有误，请帮我指出。
哈希表的定义和应用
m0_74724723的博客
05-24 708
（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。
哈希表的概念
stormsunshine的博客
11-10 1035
文章目录哈希表的基本概念哈希表的定义哈希函数哈希冲突链地址法开放寻址法Java 中的哈希表和哈希集合Map\texttt{Map}Map、HashMap\texttt{HashMap}HashMap 和 TreeMap\texttt{TreeMap}TreeMapSet\texttt{Set}Set、HashSet\texttt{HashSet}HashSet 和 TreeSet\texttt{TreeSet}TreeSet哈希表的应用场景和使用技巧 哈希表的基本概念 哈希表的定义 哈希表也称散列表，是一种
【C++ 包装器类 map】C++ 标准库（std）中的map结构 哈希表（unordered_map）和黑红树（map）教程
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-15 522
哈希表，作为一种特别有效的数据结构，它把 Key 通过一个函数的操作，转换成一个位于特定范围内的整数，这个过程叫做哈希化（Hashing）。哈希化的结果被用作在数组（通常称为哈希表）中索引数据的便捷方式。通过这种方式，我们可以通过O(1)的复杂度找到我们需要的元素，这是一种非常高效的查找方式。
Map和Set（哈希表）
2301_80035594的博客
02-14 2189
介绍了map和set的常用的方法和一些注意点并进行代码运行演示，并引出了哈希表的概念，冲突，避免和解决的两个方法闭散列和开散列（哈希桶）。
哈希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...
哈希表de 设计.rar_c++ 哈希表_哈希_哈希 VC_哈希表
09-23
哈希表，也被称为散列表...在C++中，通过理解和利用`unordered_map`，开发者可以轻松地实现和使用哈希表，提高程序的运行效率。不断优化哈希函数、控制装载因子以及选择合适的冲突解决策略，都是提升哈希表性能的关键。
List接口和Map接口
03-14
### List接口和Map接口详解 #### 一、Java集合框架概览 Java集合框架是Java标准库的一个核心组成部分，用于处理各种数据结构如列表、集合和映射等。该框架提供了一组统一的接口和实现，使开发人员能够高效地管理和...
javascript 哈希表(hashtable)的简单实现
12-07
在JavaScript中，哈希表（Hashtable）是一种常用的数据结构，它通过...此外，JavaScript ES6引入了`Map`数据结构，它提供了更为完善和高效的操作，如`set`, `get`, `delete`, `has`等，可以替代自定义的哈希表实现。
哈希表与unordered_map
08-12
哈希表和unordered_map是相关概念，但在具体实现和使用上存在...总的来说，unordered_map是C++中使用哈希表实现的一种容器，提供了方便的接口和功能。哈希表是一种数据结构的概念，需要自己实现或使用第三方库来构建。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值