【小白学Java】D24 》》》Map集合 & HashMap集合 & LinkedHashMap集合&HashTable集合

最新推荐文章于 2021-11-26 11:52:14 发布
最新推荐文章于 2021-11-26 11:52:14 发布
阅读量677 收藏 3
点赞数 4
分类专栏： 小白学Java 文章标签： java Map HashMap LinkedHashMap 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dazuo_001/article/details/118824791
版权

【友情链接】———–—>Java中的各种集合大汇总，学习整理
【友情链接】————–> Collection集合
【友情链接】————–> ArrayList集合及其常用功能
【友情链接】————–> ArrayList应用＜两大案例的数据分组聚合＞
【友情链接】———–—> Iterator迭代器
【友情链接】———–—>List集合 & LinkedList集合 & Vector集合
【友情链接】———–—>set集合 & HashSet集合 & 哈希值& LinkedHashSet集合 &TreeSet集合&可变参数
【友情链接】———–—>Map集合 & HashMap集合 & LinkedHashMap集合&HashTable集合
【友情链接】———–—>Collections类集合工具类

一、了解Map集合

Map集合概述：
Interface Map<key,value> key：键的类型 value：值的类型

Map集合的特点:

  • 1.Map集合是一个双列集合，每个元素都包含两个值(key，value)
  • 2.Map集合中的元素key和value的数据类型可以相同，也可以不同
  • 3.Map集合中的元素，key是不允许重复的，但value可以重复
  • 4.Map集含中的元素，key和value是一 一对应的关系

二、 了解Map接口的常用子类集合

（1）、java.util. HashMap<K,V>集合∶

        HashMap集合实现了Map接口，HashMap集合的底层是一个哈希表结构(查询的速度特别的快)，HashMap集是一个无序的集合，元素的存储和取出的顺序不一定是一致的。因为要保证集合中的键key的唯一性和不重复性，所以需要重写键key的hashCode方法和equals()方法。

注意：Hashttap集合的底层哈希结构，在JDK1.8之前，是由数组加上单向链表组成的，而在JDK1.8之后，是由数组加上单向链表或者红黑树组成的。底层与HashSet很类似。

（2）、 java.util.LinkedHashMap<K,V>集合 ：

        LinkedHashMap集合继承了HashMap集合，LinkHashMap集合的底层采用的是哈希表加上链表的结构。 LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的。链表结构用来保证元素的存储和取出顺序的一致性（也就是用于保证迭代的顺序），而哈希表结构可以保证的键的唯一性和不重复性，但是LinkedHashMap集合需要重写键key的hashCode()方法和equals()方法。

举个例子：

//创建一个hashmap集合
HashMap<String, String> hashMap = new HashMap<>();
//添加元素
hashMap.put("banana","banana");
hashMap.put("yellow","yellow");
hashMap.put("orange","orange");
hashMap.put("apple","apple");
hashMap.put("red","red");
hashMap.put("banana","banana");
//打印
System.out.println(hashMap);
//打印结果{banana=banana, orange=orange, red=red, apple=apple, yellow=yellow}
//hashmap是无序的集合，不允许存储重复的元素，元素存取的顺序不一致

System.out.println("------————-这是一条分界线————--------");


//创键一个LinkedHashMap集合
LinkedHashMap<String, String> linkedHashMap = new LinkedHashMap<>();
//添加元素
linkedHashMap.put("banana","banana");
linkedHashMap.put("yellow","yellow");
linkedHashMap.put("orange","orange");
linkedHashMap.put("apple","apple");
linkedHashMap.put("red","red");
linkedHashMap.put("banana","banana");
//打印
System.out.println(linkedHashMap);
//打印结果{banana=banana, yellow=yellow, orange=orange, apple=apple, red=red}
//LinkedHashMap集合是一个有序的集合，不允许存储重复的元素，存取元素的顺序是一致的

在这里插入图片描述

三、Map集合中常用的功能

1. public V put(K key ,V value): 把指定的键与指定的值添加到Map集合中。

返回值 : V
在存储键值对时：
如果key不重复，返回值V为 null；
如果key重复，那么会用新的value来换Map集合中重复的value ，返回值是被替换的value的值

//使用多态，来创建一个map集合
Map<String,Integer> map=new HashMap<>();
//添加元素
Integer put = map.put("成德善", 25);
System.out.println(put);//null
System.out.println("-------------------------");
Integer put1 = map.put("成德善", 18);
System.out.println(put1);//返回被替换的value 25
System.out.println("-------------------------");
System.out.println(map);
map.put("成宝拉",18);
map.put("狗焕",20);
map.put("油腻大叔",35);
map.put("刘东龙",17);
System.out.println(map);

在这里插入图片描述

2. public V remove(Object key):把指定的键所对应的键值对元素`在Map集合中删除，返回被删除元素的值。

返回值:V
key存在,返回该册涂的值 ;
key不存在, 返回 nuLL

//使用多态，来创建一个map集合
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("成宝拉",18);
map.put("狗焕",20);
map.put("油腻大叔",35);
map.put("刘东龙",17);
System.out.println("before remove :\t"+map);

Integer remove = map.remove("油腻大叔");
System.out.println("remove:\t"+remove);

Integer remove1 = map.remove("成德善");
System.out.println(remove1);

System.out.println("after remove:\t"+map);

在这里插入图片描述

3.public v get(0bject hey)根据指定的键，在Map集合中获取对应的值。

返回值:
key存在,返回对应的value值
key不存在,返回null

//使用多态，来创建一个map集合
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("成宝拉",18);
map.put("狗焕",20);
map.put("油腻大叔",35);
map.put("刘东龙",17);
System.out.println(map);

Integer get = map.get("狗焕");
System.out.println(get);

Integer get2 = map.get("珍珠");
System.out.println(get2);

在这里插入图片描述

4.boolean containsKey(Object key）判断集合中是否包含指定的键。

包含返回true ,不包含返回false

//使用多态，来创建一个map集合
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("成宝拉",18);
map.put("狗焕",20);
map.put("油腻大叔",35);
map.put("刘东龙",17);
System.out.println(map);
boolean b = map.containsKey("刘东龙");
System.out.println(b);

boolean b1 = map.containsKey("成龙");
System.out.println(b1);

在这里插入图片描述

5.boolean containsValue(Object value)判断集合中是否包含指定value

包含返回true ,不包含返回false

//使用多态，来创建一个map集合
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("成宝拉",18);
map.put("狗焕",20);
map.put("油腻大叔",35);
map.put("刘东龙",17);
System.out.println(map);

boolean b = map.containsValue(28);
System.out.println(b);

boolean b1 = map.containsValue(35);
System.out.println(b1);

在这里插入图片描述

6.boolean isEmpty() 判断集合是否为空

//使用多态，来创建一个map集合
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("成宝拉",18);
map.put("狗焕",20);
map.put("油腻大叔",35);
map.put("刘东龙",17);
System.out.println(map);
//boolean isEmpty() 判断集合是否为空
boolean empty = map.isEmpty();
System.out.println(empty);

在这里插入图片描述

7.int size():集合的长度

//使用多态，来创建一个map集合
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("成宝拉",18);
map.put("狗焕",20);
map.put("油腻大叔",35);
map.put("刘东龙",17);
System.out.println(map);
//int size():集合的长度
int size = map.size();
System.out.println(size);

在这里插入图片描述

8.void clear():清空集合

//使用多态，来创建一个map集合
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("成宝拉",18);
map.put("狗焕",20);
map.put("油腻大叔",35);
map.put("刘东龙",17);
System.out.println(map);
//void clear():清空集合
map.clear();
System.out.println(map);
boolean empty1 = map.isEmpty();
System.out.println(empty1);

在这里插入图片描述

Map集合的两种遍历方式:

第一种遍历方式: 通过键找值

使用方法：Set KeySet()返回此映射中包含的键的Set集合。

//使用多态，来创建一个map集合
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("成宝拉",18);
map.put("狗焕",20);
map.put("油腻大叔",35);
map.put("刘东龙",17);
map.put("刘龙",36);
map.put("李龙",26);
map.put("张晓天",27);
System.out.println(map);
//把Map集合所有的key取出来,存储到一个set集合中
Set<String> set = map.keySet();
//遍历map集合
//1.使用迭代器和while循环遍历
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
    String key = iterator.next();//取键key
    Integer value = map.get(key);//取值value
    System.out.println(key+"\t=\t"+value);
}

System.out.println("888888888888888888888888888888888");
//2.使用增强for遍历
for (String key : map.keySet()) {
    System.out.println(key+"\t=\t"+map.get(key));
}

在这里插入图片描述

键值对对象Entry

Map.Entry <  K, V > :   在Map接口中有一个内部接口 Entry

        Map中存放的是两种对象，一种key(键)，一种value(值)，它们是yi yi对应的关系，而这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象也就是键值对对象，这样遍历Map集合，就可以从每一个键值对(Entry )对象中获取对应的键与对应的值。而Map集合一经创键，就会在Map集合中创键一个Entry对象，用来记录键与值(键值对对象，键与值的映射关系)。

Entry中提供了获取对应的键key和对应的值value的方法:

  • public getKey () : 获取Entry对象中的键key
  • public v getvalue() : 获取Entry对象中的值value

Map集合中也提供了获取所有Entry对象的方法:

  • public Set < Map.Entry<K,V> > entrySet() : 获取到Map集合中所有的键值对对象的Set集合

第二种遍历方式:使用Entry对象遍历

Map集含中的entrySet()方法;
Set<Nap.Entry<k,v>> entrySet(）返回此映射中包含的映射关系的Set集合。

//使用多态，来创建一个map集合
Map<String,Integer> map=new HashMap<>();
//添加元素
map.put("成宝拉",18);
map.put("狗焕",20);
map.put("油腻大叔",35);
map.put("刘东龙",17);
map.put("刘龙",36);
map.put("李龙",26);
map.put("张晓天",27);
System.out.println(map);

//使用map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到set集合
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
//遍历map
//1.使用迭代器 while遍历
Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
while (iterator.hasNext()){
   //取出每一个entry对象
   Map.Entry<String, Integer> entry = iterator.next();
   String key = entry.getKey();//取key
   Integer value = entry.getValue();//取value
   System.out.println(key+"\t=\t"+value);
   //System.out.println(entry);
}
System.out.println("****************************************");
//2.使用增强for遍历
for (Map.Entry<String, Integer> stringIntegerEntry : entrySet) {
   System.out.println(stringIntegerEntry);
}

北慕辰的博客

四、HashMap集合存储自定义类型元素

HashMap集合存储自定义类型元素键值对，必须要重写hashcode()方法和equals()方法,用于保证键key的不可重复（唯一）

举个例子;

//创建一个Student类，重写hashcode和equals方法
import java.util.Objects;

public class Student {
    private String name;
    private  int age;
    //重写equals()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
    //重写hashcode()方法
    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student() {

    }

    public Student(String name, int age) {

        this.name = name;
        this.age = age;
    }
}



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

public class demoHashMapSaveStudent {
    public static void main(String[] args) {
       test01();//测试<String,Student>
       System.out.println();
       System.out.println("--------------------------------------------");
       test02();//测试<Student,String>
    }

    public static void test01(){
        /*
        * HashMap存储自定义类型键值
        * key : String类型
        *       String类中已经重写了hashcode方法和equals方法,已经保证了key不重复
        * value :Student对象
        *        value可以重复(同名同年龄的人看作为同一个人)
        * */
        //创建hashmap集合
        HashMap<String, Student> hashMap = new HashMap<>();
        //添加元素
        hashMap.put("清华大学",new Student("小明",20));
        hashMap.put("北京大学",new Student("小张",21));
        hashMap.put("复旦大学",new Student("小明",19));
        hashMap.put("清华大学",new Student("小明",25));
        //遍历hashmap集合
        for (String key : hashMap.keySet()) {
            System.out.println(key+"\t:\t"+hashMap.get(key));
        }
    }
    public static void test02(){
        /*
         * HashMap存储自定义类型键值
         * key : Student对象
         *       Student对象需要重写hashcode方法和equals方法,才能保证key不重复（唯一），
         *       (同名同年龄的人看作同一个人，也就是重复的key)
         * value :String类型
         *           value可以重复
         * */
        //创建hashmap集合
        HashMap<Student,String> hashMap = new HashMap<>();
        //添加元素
        hashMap.put(new Student("小明",20),"北京人");
        hashMap.put(new Student("小红",30),"南京人");
        hashMap.put(new Student("小刘",25),"广东人");
        hashMap.put(new Student("小明",20),"上海人");
        //遍历map集合，使用entry
        Set<Map.Entry<Student, String>> entrySet = hashMap.entrySet();
        for (Map.Entry<Student, String> studentStringEntry : entrySet) {
            System.out.println(studentStringEntry);
        }
    }
}

测试结果截图：
在这里插入图片描述

五、了解HashTable集合

java.util.HashTable<K,V>集合也是实现了（implements） Map<K,V>接口

HashMap集合与HashTable集合相比较：

  • HasMap集合的底层是一个哈希表，是一个线程不安全的集合，为多线程的集合， HasMap集合的速度快， HasMap集合与之前说的所有的集合都可以存储 null 值和 null 键
  • HashTable集合的底层是一个哈希表，并且是一个线程安全的集含，为单线程集合，HashTable集合的速度慢，HashTabLe集合不能存储 null 值和 null 键

HashTable集合与Vector集合一样，都是在jdk1.2版本之后被更先进的集合(HashMap ，ArrayList)取代了；但是HashTabLe的子类Properties任然在使用，并且Properties集合是唯一的一个和 IO流 相结合的集合。

看个例子:

HashMap<String, String> hashMap = new HashMap<>();
hashMap.put(null ,"hashmap");
hashMap.put("hashMap",null);
hashMap.put(null,null);
System.out.println(hashMap);//打印{null=null, hashMap=null}

Hashtable<String, String> hashtable = new Hashtable<>();
hashtable.put(null ,"hashmap");
hashtable.put("hashMap",null);
hashtable.put(null,null);
System.out.println(hashtable);//java.lang.NullPointerException

在这里插入图片描述

制作不易，各位友友们，大佬们给点鼓励！

点赞👍 收藏+关注 一键三联走起！

北慕辰
关注
专栏目录
JAVA 24点游戏
gjie_me的博客
04-14 878
题目：24点游戏 题目分析： 采用判断是否是24，四张牌用a,b,c,d来代替，中间连接的运算符有3个，中间连接的运算符op1,op2，op3；a op1 b op2 c op3 d表达式，为了简化问题，先4张牌的顺序不变，运算符4种，表达式组合情况有64种，4*4*4 = 64；加上括号之后的情况，5种情况 1、(（a op1 b）op2 c)op3 d 2、（a op1 b）op2 (...
java四大集合_Java四大集合（ArrayList、LinkedList、HashSet、HashMap）用法
weixin_35873811的博客
02-13 412
boolean add(int index, Object obj) 将指定元素obj插入到集合中指定的位置Object remove(int index) 从集合中删除指定index处的元素，返回该元素void clear() 清空集合中所有元素Object set(int index, Object obj) 用指定元素obj替代集合中指定位置上的元素LinkedListLinkedList ...
常见集合框架：HashMap、HashTable、ConcurrentHashMap、ArrayList、Vocter、LinkedList、HashSet、TreeSet之间区别
小明的博客
11-19 1354
集合框架 ​ 这里进行快速的常用常见(面试)，的集合框架快速的介绍和了解，如下是集合框架的关系图，和一张简单的关系图，用于快速的了解集合框架的结构。本文并不是详细的介绍，知识进行常被问到的简单介绍 Iteraor接口 （迭代器） (迭代器接口)用于遍历集合中元素的接口，主要包含三种方法： boolean hasNext() E next() void remove() 也就是说如果实现Iterator接口，那么在遍历集合中元素的时候，只能往后遍历，被遍历过的元素不会再遍历到，通常无序集合实现的都是这
四种集合的遍历（HashMap、Queue、Stack、ArrayList）
sinat_28175429的博客
09-29 579
1.     HashMap遍历 /*HashMap的遍历 EntrySet遍历方法，可以得到一个Entry对象的结果集，然后使用Entry对象的getKey和getValue方法。 KeySet遍历方法，先使用keySet函数，获取到HashMap的所有Key的集合对象，然后循环所有的key， 通过HashMap的get方法，获取到对应的value。*/ packagecom.zyy.
对字符串分组聚合
weixin_44778537的博客
10-31 294
1、用HashSet分组（唯一），HashMap聚合（k，v） /* 统计一串字符串当中每个字母出现的个数 给定字符串abacba */ ArrayList<String> list = new ArrayList<>();//abacba list.add("a"); list.add("b"); list.add("a"); list.add("c"); list.add("b"); list.add("a"); //分组 HashSet&...
Java集合框架中的字符串魔法：键值对与Map的高效使用之道
[Java集合框架中的字符串魔法：键值对与Map的高效使用之道](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/375d24ee812e4028be0db492b7d7439d~tplv-k3u1fbpfcp-watermark.image?) # 1. Java集合框架与Map接口...
C&D西恩迪 TWR-3.3/4250-12/625-D24 模块电源说明书.pdf
10-18
性能规格和订购指南提供了详细信息，包括TWR-3.3/4250-12/625-D24、TWR-3.3/4250-12/625-D48、TWR-3.3/4250-15/500-D24和TWR-3.3/4250-15/500-D48等型号的产品规格。 通过这些知识点，我们可以了解到TWR系列电源的...
C&D西恩迪 UVQ-12/8-D24P 模块电源说明书.pdf
10-12
C&D西恩迪UVQ-12/8-D24P模块电源是低压半砖型隔离式DC/DC转换器，具备高效率和多种保护功能，在不同的工业应用中提供了优异的电气性能和可靠性。以下是基于给定文件信息的详细知识点： 1. 产品系列与型号概述 - 该...
C&D西恩迪TWR-3.3/4250-12/625-D24模块电源详细特性与规格
C&D西恩迪的TWR-3.3/4250-12/625-D24模块电源是一款高效、多功能的直流到直流转换器，适用于需要独立调节的3.3伏特（3.3V@4.25A）、±12伏特（±12V@±625mA）以及±15伏特（±15V@±500mA）输出的应用场景。...
D24极限运算法则PPT学习教案.pptx
10-07
【极限运算法则】 在数学分析中，极限运算法则是理解和计算函数极限的重要工具。这里主要探讨的是关于极限的一些基本定理和推论，尤其在处理函数相加、相乘和除法时的应用。 首先，定理1指出，如果两个函数\( f(x)...
LinkedHashMap中是否包含一个Key的判断
COOLBLOOD的专栏
07-15 8598
在LinkedHashMap中，如果需要使用一个对象作为key， 要做get时，往往没办法保存当初put操作时的key object的reference，此时，需要让key object覆盖如下hashCode()和equals(Object obj)的实现。这样就可以通过containsKey 来判断是否包含此对象了。 package com.tian.menu.entity; im
24点算法详解--Java代码实现
qq_39658819的博客
01-22 5514
在网上看了很多的24点，结果都不尽人意，然后从学长那弄来了代码仔细研究了一番，以下是我对该算法原理及实现的理解  注：对于52张 扑克牌构成的27万多种可能的组合，代码经测试最快能达到0.35秒，即可计算出所有解得情况，本文就输入四个数，得到其所有24点的解的高效的算法进行详解 理解原理（前提）：  1.采用四元转三元， 三元转二元，二元转一元的方法，在有四个数时，我们取出其中两个数，进
Java 实现的24点牌
§为艺术而技术§
07-10 1826
漫长的假期对于我来说总是枯燥无味的，闲来无聊便和同学玩起童年时经常玩的二十四点牌游戏来。此游戏说来简单，就是利用加减乘除以及括号将给出的四张牌组成一个值为24的表达式。但是其中却不乏一些有趣的题目，这不，我们刚玩了一会儿，便遇到了一个难题——3、6、6、10（其实后来想想，这也不算是个太难的题，只是当时我们的脑筋都没有转弯而已，呵呵）。 　　问题既然出现了，我们当然要解决。冥思苦想之际，我的脑中
java linkedhashmap 用法_Java LinkedHashMap containsKey()用法及代码示例
weixin_42641385的博客
02-27 490
java.util.LinkedHashMap.containsKey()方法用于检查特定键是否已映射到LinkedHashMap中。它使用key元素作为参数，如果该元素在映射中映射，则返回True。用法:Linked_Hash_Map.containsKey(key_element)参数：该方法仅采用一个参数key_element，该参数表示应该在映射内检查其映射的键。返回值：如果检测到键的存在...
Java代码实现24点计算
阿扎西的博客
11-26 6644
24点是我们小时候经常会玩的游戏。 4个数字，3个操作符，谁先算出24，谁就胜。 本文利用搜索回溯算法计算24点。 核心思路 我有1，2，3，4这四个数字。如何才能让计算机计算出24来呢？ 我们可以这么想，先取出1来，然后让1+2=3，然后再让3+3=6，6+4=10，发现结果不等于24，那我们可以后退一步（回溯）让6-4=2，发现结果也不等，再让6*4=24，结果为24。 图解 abcd代表四个数字 #mermaid-svg-b8DPfZqspk914XMJ .label{font-family:'tre
Java实现24点
qq_43911136的博客
04-13 1957
第三章作业 一、题目要求： 常见游戏规则： 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。 基本要求： 随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式 1.程序风格良好(使用自定义注释模板) 2.列出表达式无重复。...
Java中的集合类：HashMap
friend_X的博客
02-17 921
Java中的集合类 1、HashMap 1.1、HashMap的简介 1.2、HashMap的底层实现原理 1.3、HashMap的操作方法 1.3.1、构造方法 1.3.2、containsKey​方法和containsValue​方法 1.3.3、remove​方法 1.3.4、put方法 1.3.5、get方法 1.3.6、keySet方法和values方法 1.3.7、size方法和isEmpty方法
java实现24点经典游戏
IT精英之路的博客
09-26 2783
1.游戏简介 从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1).用户初始生命值为一给定值（比如3），初始分数为0。随机生成4个代表扑克牌牌面的数字或字母，由用户输入包含这4个数字或字母的运算表达式（可包含括号），如果表达式计算结果为24则代表用户赢了此局。 2.主要算法 利用栈来计算表达式的值,在与24进行比较. 2.1数据结构 ...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

北慕辰

你的鼓励是小北最大的动力

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

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

打赏作者

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

抵扣说明：

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

余额充值