头歌大数据MapReduce基础编程

最新推荐文章于 2024-08-01 16:11:59 发布
最新推荐文章于 2024-08-01 16:11:59 发布
阅读量6.7k 收藏 65
点赞数 17
分类专栏： 头歌 文章标签： 大数据 mapreduce hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxc872202364/article/details/133953786
版权

文章目录

第1关：合并去重

任务描述

本关任务：编程实现文件合并和去重操作。

相关知识

为了实现文件的合并去重，我们首先要知道文件中都有些什么，将文件内容进行“拆解”，映射（Map）到不同节点；然后在通过归约（Reduce）去除重复部分。
在这里插入图片描述
Map过程
用法如下：
重载map函数，直接将输入中的value复制到输出数据的key上。

public static class Map extends Mapper<Object, Text, Text, Text>{}

Reduce过程

重载reduce函数，直接将输入中的key复制到输出数据的key上。

public static class Reduce extends Reducer<Text, Text, Text, Text>{}

编程要求

对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。
为了完成文件合并去重的任务，你编写的程序要能将含有重复内容的不同文件合并到一个没有重复的整合文件，规则如下：

  1. 第一列按学号排列；
  2. 学号相同，按x，y，z排列。

测试说明

程序会对你编写的代码进行测试：
输入已经指定了测试文本数据：需要你的程序输出合并去重后的结果。
下面是输入文件和输出文件的一个样例供参考。
输入文件A的样例如下：

20150101     x
20150102     y
20150103     x
20150104     y
20150105     z
20150106     x

输入文件B的样例如下：

20150101      y
20150102      y
20150103      x
20150104      z
20150105      y

根据输入文件A和B合并得到的输出文件C的样例如下：

20150101      x
20150101      y
20150102      y
20150103      x
20150104      y
20150104      z
20150105      y
20150105      z
20150106      x

示例代码


import java.io.IOException;  
import org.apache.hadoop.conf.Configuration;  
import org.apache.hadoop.fs.Path;  
import org.apache.hadoop.io.IntWritable;  
import org.apache.hadoop.io.Text;  
import org.apache.hadoop.mapreduce.Job;  
import org.apache.hadoop.mapreduce.Mapper;  
import org.apache.hadoop.mapreduce.Reducer;  
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
import org.apache.hadoop.util.GenericOptionsParser;
public class Merge {
    /**  
     * @param args  
     * 对A,B两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C  
     */  
    //重载map函数，直接将输入中的value复制到输出数据的key上  
    /********** Begin **********/  
    public static class Map extends Mapper<Object, Text, Text, Text>{  
        private static Text text = new Text();  
        public void map(Object key, Text value, Context context) throws IOException,InterruptedException{  
            text = value;  
            context.write(text, new Text(""));  
        }  
    }  
    /********** End **********/  
    //重载reduce函数，直接将输入中的key复制到输出数据的key上  
    /********** Begin **********/  
    public static class Reduce extends Reducer<Text, Text, Text, Text>{  
        public void reduce(Text key, Iterable<Text> values, Context context ) throws IOException,InterruptedException{  
            context.write(key, new Text(""));  
        }  
    }  
    /********** End **********/  
    public static void main(String[] args) throws Exception{  
        // TODO Auto-generated method stub  
        Configuration conf = new Configuration();  
        conf.set("fs.default.name","hdfs://localhost:9000");  
        String[] otherArgs = new String[]{"input","output"}; /* 直接设置输入参数 */  
        if (otherArgs.length != 2) {  
            System.err.println("Usage: wordcount <in> <out>");  
            System.exit(2);  
            }  
        Job job = Job.getInstance(conf,"Merge and duplicate removal");  
        job.setJarByClass(Merge.class);  
        job.setMapperClass(Map.class);  
        job.setCombinerClass(Reduce.class);  
        job.setReducerClass(Reduce.class);  
        job.setOutputKeyClass(Text.class);  
        job.setOutputValueClass(Text.class);  
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));  
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));  
        System.exit(job.waitForCompletion(true) ? 0 : 1);  
    }
}

第1关：第2关：整合排序

任务描述

本关任务：编写程序实现对输入文件的排序。

相关知识

为了实现文件的整合排序，我们首先要知道文件中都有些什么，将文件内容进行“拆解”，映射（Map）到不同节点；然后在通过归约（Reduce）的过程中进行排序输出。
在这里插入图片描述
Map过程

  1. 输入多个文件，每个文件中的每行内容均为一个整数；
  2. map函数读取输入中的value，将其转化成IntWritable类型，最后作为输出key。
public static class Map extends Mapper<Object, Text, IntWritable, IntWritable>{
private static IntWritable data = new IntWritable();
}

Reduce过程

  1. reduce函数将map输入的key复制到输出的value上；
  2. 根据输入的value-list中元素的个数决定key的输出次数,定义一个全局变量line_num来代表key的位次。
public static class Reduce extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable>{
private static IntWritable line_num = new IntWritable(1);
}

返回Partiton ID

  1. 自定义Partition函数，此函数根据输入数据的最大值和MapReduce框架中Partition的数量获取将输入数据按照大小分块的边界；
  2. 根据输入数值和边界的关系返回对应的Partiton ID。
public static class Partition extends Partitioner<IntWritable, IntWritable>{
public int getPartition(IntWritable key, IntWritable value, int num_Partition){
int Maxnumber = 65223;//int型的最大数值
}

编程要求

为了完成合并文件并排序的功能，你编写的程序要能将整合排序后的结果输出，规则如下：

  1. 现在有多个输入文件，每个文件中的每行内容均为一个整数。要求读取所有文件中的整数，进行升序排序后，输出到一个新的文件中；
  2. 输出的数据格式为每行两个整数，第一个数字为第二个整数的排序位次，第二个整数为原待排列的整数。

测试说明

程序会对你编写的代码进行测试：
下面是输入文件和输出文件的一个样例供参考。
输入文件1的样例如下：

33
37
12
40

输入文件2的样例如下：

4
16
39
5

输入文件3的样例如下：

1
45
25

根据输入文件1、2和3得到的输出文件如下：

1 1
2 4
3 5
4 12
5 16
6 25
7 33
8 37
9 39
10 40
11 45

示例代码

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;  
import org.apache.hadoop.fs.Path;  
import org.apache.hadoop.io.IntWritable;  
import org.apache.hadoop.io.Text;  
import org.apache.hadoop.mapreduce.Job;  
import org.apache.hadoop.mapreduce.Mapper;  
import org.apache.hadoop.mapreduce.Partitioner;  
import org.apache.hadoop.mapreduce.Reducer;  
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
import org.apache.hadoop.util.GenericOptionsParser;
public class MergeSort {
    /**  
     * @param args  
     * 输入多个文件，每个文件中的每行内容均为一个整数  
     * 输出到一个新的文件中，输出的数据格式为每行两个整数，第一个数字为第二个整数的排序位次，第二个整数为原待排列的整数  
     */  
    //map函数读取输入中的value，将其转化成IntWritable类型，最后作为输出key  
    public static class Map extends Mapper<Object, Text, IntWritable, IntWritable>{
        private static IntWritable data = new IntWritable();  
        public void map(Object key, Text value, Context context) throws IOException,InterruptedException{  
    /********** Begin **********/  
            String text = value.toString();  
            data.set(Integer.parseInt(text));  
            context.write(data, new IntWritable(1));  
    /********** End **********/  
        }  
    }  
    //reduce函数将map输入的key复制到输出的value上，然后根据输入的value-list中元素的个数决定key的输出次数,定义一个全局变量line_num来代表key的位次  
    public static class Reduce extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable>{
        private static IntWritable line_num = new IntWritable(1);  
        public void reduce(IntWritable key, Iterable<IntWritable> values, Context context) throws IOException,InterruptedException{  
    /********** Begin **********/  
            for(IntWritable val : values){  
                context.write(line_num, key);  
                line_num = new IntWritable(line_num.get() + 1);  
            }  
    /********** End **********/  
        }  
    }  
    //自定义Partition函数，此函数根据输入数据的最大值和MapReduce框架中Partition的数量获取将输入数据按照大小分块的边界，然后根据输入数值和边界的关系返回对应的Partiton ID  
    public static class Partition extends Partitioner<IntWritable, IntWritable>{  
        public int getPartition(IntWritable key, IntWritable value, int num_Partition){  
    /********** Begin **********/  
            int Maxnumber = 65223;//int型的最大数值  
            int bound = Maxnumber/num_Partition+1;  
            int keynumber = key.get();  
            for (int i = 0; i<num_Partition; i++){  
                if(keynumber<bound * (i+1) && keynumber>=bound * i){  
                    return i;  
                }  
            }  
            return -1;  
    /********** End **********/  
        }  
    }  
    public static void main(String[] args) throws Exception{  
        // TODO Auto-generated method stub  
        Configuration conf = new Configuration();  
        conf.set("fs.default.name","hdfs://localhost:9000");  
        String[] otherArgs = new String[]{"input","output"}; /* 直接设置输入参数 */  
        if (otherArgs.length != 2) {  
            System.err.println("Usage: wordcount <in> <out>");  
            System.exit(2);  
            }  
        Job job = Job.getInstance(conf,"Merge and sort");  
        job.setJarByClass(MergeSort.class);  
        job.setMapperClass(Map.class);  
        job.setReducerClass(Reduce.class);  
        job.setPartitionerClass(Partition.class);  
        job.setOutputKeyClass(IntWritable.class);  
        job.setOutputValueClass(IntWritable.class);  
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));  
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));  
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

第3关：信息挖掘

任务描述

本关任务：对给定的表格进行信息挖掘。

相关知识

Map过程

  1. Map将输入文件按照空格分割成child和parent，然后正序输出一次作为右表，反序输出一次作为左表，需要注意的是在输出的value中必须加上左右表区别标志；
  2. 在Map阶段，将父子关系与相反的子父关系，同时在各个value前补上前缀-与+标识此key-value中的value是正序还是逆序产生的，之后进入context。
public static class Map extends Mapper<Object, Text, Text, Text>{
        public void map(Object key, Text value, Context context) throws IOException,InterruptedException{
            String child_name = new String();
            String parent_name = new String();
}

Reduce过程

public static class Reduce extends Reducer<Text, Text, Text, Text>{
        public void reduce(Text key, Iterable<Text> values,Context context) throws IOException,InterruptedException{
            if(time == 0){   //输出表头
                context.write(new Text("grand_child"), new Text("grand_parent"));
                time++;
            }
}

编程要求

为了完成信息挖掘的任务，你编写的程序要能挖掘父子辈关系，给出祖孙辈关系的表格。规则如下：

  1. 孙子在前，祖父在后；
  2. 孙子相同，祖父的名字按照A-Z排列。

测试说明

程序会对你编写的代码进行测试：
下面给出一个child-parent的表格，要求挖掘其中的父子辈关系，给出祖孙辈关系的表格。
输入文件内容如下：

child          parent
Steven        Lucy
Steven        Jack
Jone         Lucy
Jone         Jack
Lucy         Mary
Lucy         Frank
Jack         Alice
Jack         Jesse
David       Alice
David       Jesse
Philip       David
Philip       Alma
Mark       David
Mark       Alma

输出文件内容如下：

grandchild       grandparent
Steven          Alice
Steven          Jesse
Jone            Alice
Jone            Jesse
Steven          Mary
Steven          Frank
Jone            Mary
Jone            Frank
Philip           Alice
Philip           Jesse
Mark           Alice
Mark           Jesse

示例代码

import java.io.IOException;  
import java.util.*;
import org.apache.hadoop.conf.Configuration;  
import org.apache.hadoop.fs.Path;  
import org.apache.hadoop.io.IntWritable;  
import org.apache.hadoop.io.Text;  
import org.apache.hadoop.mapreduce.Job;  
import org.apache.hadoop.mapreduce.Mapper;  
import org.apache.hadoop.mapreduce.Reducer;  
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
import org.apache.hadoop.util.GenericOptionsParser;
public class simple_data_mining {  
    public static int time = 0;
    /**  
     * @param args  
     * 输入一个child-parent的表格  
     * 输出一个体现grandchild-grandparent关系的表格  
     */  
    //Map将输入文件按照空格分割成child和parent，然后正序输出一次作为右表，反序输出一次作为左表，需要注意的是在输出的value中必须加上左右表区别标志  
    public static class Map extends Mapper<Object, Text, Text, Text>{  
        public void map(Object key, Text value, Context context) throws IOException,InterruptedException{  
    /********** Begin **********/  
            String child_name = new String();  
            String parent_name = new String();  
            String relation_type = new String();  
            String line = value.toString();  
            int i = 0;  
            while(line.charAt(i) != ' '){  
                i++;  
            }  
            String[] values = {line.substring(0,i),line.substring(i+1)};  
            if(values[0].compareTo("child") != 0){  
                child_name = values[0];  
                parent_name = values[1];  
                relation_type = "1";//左右表区分标志  
                context.write(new Text(values[1]), new Text(relation_type+"+"+child_name+"+"+parent_name));  
                //左表  
                relation_type = "2";  
                context.write(new Text(values[0]), new Text(relation_type+"+"+child_name+"+"+parent_name));  
                //右表  
            }  
    /********** End **********/  
        }  
    }  
    public static class Reduce extends Reducer<Text, Text, Text, Text>{  
        public void reduce(Text key, Iterable<Text> values,Context context) throws IOException,InterruptedException{  
    /********** Begin **********/  
            if(time == 0){   //输出表头  
                context.write(new Text("grand_child"), new Text("grand_parent"));  
                time++;  
            }  
            int grand_child_num = 0;  
            String grand_child[] = new String[10];  
            int grand_parent_num = 0;  
            String grand_parent[]= new String[10];  
            Iterator ite = values.iterator();  
            while(ite.hasNext()){  
                String record = ite.next().toString();  
                int len = record.length();  
                int i = 2;  
                if(len == 0) continue;  
                char relation_type = record.charAt(0);  
                String child_name = new String();  
                String parent_name = new String();  
                //获取value-list中value的child  
                while(record.charAt(i) != '+'){  
                    child_name = child_name + record.charAt(i);  
                    i++;  
                }  
                i=i+1;  
                //获取value-list中value的parent  
                while(i<len){  
                    parent_name = parent_name+record.charAt(i);  
                    i++;  
                }  
                //左表，取出child放入grand_child  
                if(relation_type == '1'){  
                    grand_child[grand_child_num] = child_name;  
                    grand_child_num++;  
                }  
                else{//右表，取出parent放入grand_parent  
                    grand_parent[grand_parent_num] = parent_name;  
                    grand_parent_num++;  
                }  
            }
            if(grand_parent_num != 0 && grand_child_num != 0 ){  
                for(int m = 0;m<grand_child_num;m++){  
                    for(int n=0;n<grand_parent_num;n++){  
                        context.write(new Text(grand_child[m]), new Text(grand_parent[n]));  
                        //输出结果  
                    }  
                }  
            }  
    /********** End **********/  
        }  
    }  
    public static void main(String[] args) throws Exception{  
        // TODO Auto-generated method stub  
        Configuration conf = new Configuration();  
        conf.set("fs.default.name","hdfs://localhost:9000");  
        String[] otherArgs = new String[]{"input","output"}; /* 直接设置输入参数 */  
        if (otherArgs.length != 2) {  
            System.err.println("Usage: wordcount <in> <out>");  
            System.exit(2);  
            }  
        Job job = Job.getInstance(conf,"Single table join ");  
        job.setJarByClass(simple_data_mining.class);  
        job.setMapperClass(Map.class);  
        job.setReducerClass(Reduce.class);  
        job.setOutputKeyClass(Text.class);  
        job.setOutputValueClass(Text.class);  
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));  
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));  
        System.exit(job.waitForCompletion(true) ? 0 : 1);  
    }
}
mr-element
关注
  • 17
    点赞
  • 踩
  • 65
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
MapReduce基础编程
Junds0的博客
05-26 1482
第1关：合并去重 本关任务：编程实现文件合并和去重操作。 import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.
大数据技术基础实验报告-MapReduce编程 (2).docx
10-31
。。。
MapReduce入门编程
C_helped的博客
05-11 886
MapReduce入门编程、环境配置、官方WordCount源码、集群
头歌大数据——MapReduce 基础实战 答案 无解析
kercii的博客
05-18 1万+
头歌大数据——MapReduce 基础实战 答案 无解析
头歌-第1关：MapReduce的编程开发-排序
2301_79646631的博客
04-02 1787
在 MapReduce 的 Shuffle 的过程中执行了三次排序，分别是： map 中的溢写阶段：根据分区以及 key 进行快速排序。map 中合并溢写文件：将同一分区的多个溢写文件进行归并排序，合成一个大的溢写文件。reduce 输入阶段：将同一分区，来自不同 map task 的数据文件进行归并排序。在 MapReduce 整个过程中，默认是会对输出的键值对按照 key 进行排序的，而且是使用快速排序。map 输出的排序的，其实也就是上面的溢写过程中的排序。
头哥实践平台之MapReduce基础实战
m0_74459049的博客
11-12 6057
头哥实践平台之MapReduce基础实战
【小白视角】大数据基础实践(五) MapReduce编程基础操作
面向生活编程
06-23 4825
目录1. MapReduce 简介1.1 起源1.2 模型简介1.3 MRv1体系结构1.4 YARN1.4.1 YARN体系结构1.4.2 YARN工作流程2. MapReduce 工作流程3. Java Api要点4. 实验过程最后 1. MapReduce 简介 1.1 起源 在函数式语言里，map表示对一个列表（List）中的每个元素做计算，reduce表示对一个列表中的每个元素做迭代计算。 它们具体的计算是通过传入的函数来实现的，map和reduce提供的是计算的框架。 在MapReduce
大数据Mapreduce编程——矩阵乘法
qq_46138648的博客
02-28 4093
大数据基础编程mapreduce之矩阵乘法
大数据从入门到实战 - 第3章 MapReduce基础实战
热门推荐
小啊呜的博客
01-13 4万+
大数据从入门到实战 - 第3章 MapReduce基础实战 一、关于此次实践 1、实战简介 2、全部任务 二、实践详解 1、第 1 关：成绩统计 2、第 2 关：文件内容合并去重 3、第 3 关：信息挖掘 - 挖掘父子关系 叮嘟！这里是小啊呜的学习课程资料整理。好记性不如烂笔头，今天也是努力进步的一天。一起加油进阶吧！
大数据课程——MapReduce编程基础
weixin_43334251的博客
06-28 405
大数据课程——MapReduce编程基础 实验内容以及要求 在文档规模较小的时候，使用传统编程方式也能统计出文本中出现的单词数量，但是当文档规模巨大的时候（比如数据大小达到GB、PB级别的时候），就必须使用MapReduce来进行统计了。 请使用MapReduce编程框架， 编写程序WordCount，统计文本中，每个单词出现的次数，并给予详细的步骤以及实验测试结果。 自己说两句 该实验主要是学习MapReduce的相关概念，重点是要理解Map、Reduce这两个阶段做了什么事情，并且在整个MapRed
大数据技术基础实验报告-MapReduce编程.doc
08-21
在这个实验报告中，我们将探讨如何在Eclipse环境中设置和使用MapReduce编程。 首先，为了在Eclipse上编写和运行MapReduce程序，我们需要安装`hadoop-eclipse-plugin`。这个插件允许开发者直接在IDE中开发、调试和...
大数据实验四-MapReduce编程实践
04-03
### 大数据实验四-MapReduce编程实践 #### 一、实验内容与目的 ##### 实验内容概述 本次实验的主要内容是使用MapReduce框架来实现WordCount词频统计功能，即统计HDFS（Hadoop Distributed File System）系统中多个...
大数据实验5实验报告：MapReduce 初级编程实践
06-20
【MapReduce初级编程实践】是大数据处理中的一项基础任务，主要应用于大规模数据集的并行计算。在这个实验中，我们关注的是如何利用MapReduce来实现文件的合并与去重操作。MapReduce是一种分布式计算模型，由Google...
大数据基础编程、实验和案例教程 第2版
03-20
MapReduce作为Hadoop的核心计算模型，是大数据处理的关键，书中提供了MapReduce的基础编程教程，帮助读者理解并编写MapReduce程序。 此外，Hive作为一个数据仓库工具，用于处理和分析存储在Hadoop中的大型数据集，...
大数据之Mapreduce
06-09
MapReduce是一种编程模型，用于大规模数据集（大于1TB）的并行运算。概念"Map（映射）"和"Reduce（归约）"，是它们的主要思想，都是从函数式编程语言里借来的，还有从矢量编程语言里借来的特性。它极大地方便了编程...
大数据框架基础MapReduce编程实例：单词计数
大数据基础学习
06-28 1126
本节介绍如何编写基本的 MapReduce 程序实现数据分析。本节代码是基于 Hadoop 2.7.3 开发的。 任务准备 单词计数（WordCount）的任务是对一组输入文档中的单词进行分别计数。假设文件的量比较大，每个文档又包含大量的单词，则无法使用传统的线性程序进行处理，而这类问题正是 MapReduce 可以发挥优势的地方。 在前面《MapReduce实例分析：单词计数》教程中已经介...
大数据信用查询什么样的平台比较靠谱?
xiaoyikj的博客
08-01 471
随着互联网的发展和普及，大数据技术逐渐应用到各行各业中，其中之一就是信用查询领域，大数据信用查询平台能够为用户提供全面、准确的大数据信用评估，然而，由于市场上出现了许多不同的大数据信用查询平台，我们如何才能选择一个靠谱可信的平台呢?市面上很查询大数据的平台都只有一个单链接，用户查询完成之后，对报告有不清楚的地方，根本没有办法找到专人为其分析，如果一份报告自己看不懂，没有人解答，那么这次的钱就是白花了，而小易大数据平台则是市面上为数不多的提供大数据报告免费解读的平台，深受用户好评。
hive的内部表（MANAGED_TABLE）和外部表（EXTERNAL_TABLE）的区别
最新发布
qq_58462591的博客
08-01 169
外部表：外部表的存储在hdfs中，是我们指定的文件目录，当我们删除数据或者删除分区的时候不会将元数据删除，数据还会在hdfs目录中，我们还可以进行数据挂载。内部表：内部表的存储是在hdfs的默认目录下，当我们删除数据或者删除分区的时候会将元数据删除，数据文件也会被删除。运行指令找到table_type 如果为MANAGED_TABLE，那就是内部表，内部表和外部表的主要区别在于数据的存储方式。如果是EXTERNAL_TABLE,那就是外部表。
mapreduce基础编程
05-10
以下是MapReduce基础编程的步骤： 1. 输入数据的划分：将输入数据分成若干个小块，每个小块可以被独立处理。 2. Map函数：定义一个Map函数，在Map阶段中对输入数据进行转换，将输入数据处理成键值对的形式。 3. ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

mr-element

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

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

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

打赏作者

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

抵扣说明：

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

余额充值