【MR】MapReduce 常见的排序

最新推荐文章于 2024-09-19 17:35:00 发布
最新推荐文章于 2024-09-19 17:35:00 发布
阅读量1.2w 收藏 35
点赞数 4
分类专栏： Hadoop HADOOP学习之路 文章标签： mapreduce 排序 hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangjjuan/article/details/78063279
版权

【MR】MapReduce 常见的排序

一，Hadoop默认的排序算法，只会针对key值进行排序，按照字典顺序排序。
直接上代码
Map端

package Hadoop.MR.sort;
import java.io.IOException;

/**
 * 文本排序-map分组，在Hadoop默认的排序算法中，只会针对key值进行排序
 * @author Young
 * created on 2017-6-30
 */
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class SortMapper extends Mapper<LongWritable, Text, Text, NullWritable> {

    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, NullWritable>.Context context)
            throws IOException, InterruptedException {
        // TODO Auto-generated method stub
        String line = value.toString();//获取文本内容
        context.write(new Text(line), NullWritable.get());
    }

}

Reduce端

package Hadoop.MR.sort;
import java.io.IOException;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
/**
 * 文本排序-reduce端排序，在Hadoop默认的排序算法中，只会针对key值进行排序
 * @author Young
 * created on 2017-6-30
 */
import org.apache.hadoop.mapreduce.Reducer;

public class SortReducer extends Reducer<Text, NullWritable, Text, NullWritable> {

    @Override
    protected void reduce(Text k2, Iterable<NullWritable> v2,
            Reducer<Text, NullWritable, Text, NullWritable>.Context context) throws IOException, InterruptedException {
        // TODO Auto-generated method stub
        context.write(k2, NullWritable.get());
    }

}

驱动程序

package Hadoop.MR.sort;

import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

/**
 * 排序驱动程序
 * @author Young
 * @version 创建时间：2017年6月30日上午9:31:50
 */
public class SortDriver extends Configured implements Tool {
    public int run(String[] arg0) throws Exception {
        if (arg0.length != 2){
            System.err.printf("Usage:%s[generic options]<input> <output>\n",getClass().getSimpleName());
            ToolRunner.printGenericCommandUsage(System.err);
            return -1;
        }
//      Configuration conf = new Configuration();
//      Job job = new Job(getConf(),"Max Temperture");
        Job job = Job.getInstance(getConf(), "Sort");
        job.setJarByClass(getClass());

        FileInputFormat.addInputPath(job, new Path(arg0[0]));
        FileOutputFormat.setOutputPath(job, new Path(arg0[1]));

        job.setMapperClass(SortMapper.class);
        job.setReducerClass(SortReducer.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);

        return job.waitForCompletion(true)?0:1;
    }


    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        int exitCode = ToolRunner.run(new SortDriver(), args);
        System.exit(exitCode);
    }
}

排序前后
这里写图片描述

二，自定义，先根据第一列排序，若相同则根据第二列排序，
自定义Bean，

package Hadoop.MR.mysort;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

import org.apache.hadoop.io.WritableComparable;
/**
 * 实现WritableComparable接口,重写compareTo进行排序
 * @author Young
 * @version 创建时间：2017年6月30日上午9:54:14
 */
public class SortBean implements WritableComparable<SortBean> {
    private long firstNum;
    private long secondNum;
    public SortBean(){
    }
    public SortBean(long first,long second){
        this.firstNum=first;
        this.secondNum=second;
    }
    public void readFields(DataInput in) throws IOException {
        // TODO Auto-generated method stub
        this.firstNum=in.readLong();
        this.secondNum=in.readLong();
    }
    public void write(DataOutput out) throws IOException {
        // TODO Auto-generated method stub
        out.writeLong(firstNum);
        out.writeLong(secondNum);
    }
    public int compareTo(SortBean o) {
        // TODO Auto-generated method stub
        //返回1则交换，-1则不交换。
        if(this.firstNum==o.getFirstNum()){
            return this.secondNum>o.getSecondNum() ? 1:-1;
        }
        else{
            return this.firstNum>o.getFirstNum() ? 1:-1;
        }
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.firstNum+" "+this.secondNum;
    }
    public long getFirstNum() {
        return firstNum;
    }
    public void setFirstNum(long firstNum) {
        this.firstNum = firstNum;
    }
    public long getSecondNum() {
        return secondNum;
    }
    public void setSecondNum(long secondNum) {
        this.secondNum = secondNum;
    }
}

Map端

package Hadoop.MR.mysort;

import java.io.IOException;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
/**
 * 自定排序map端
 * @author Young
 * @version 创建时间：2017年6月30日上午10:20:12
 */
public class MySortMapper extends Mapper<LongWritable, Text, SortBean,NullWritable> {
    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, 

SortBean, NullWritable>.Context context)
            throws IOException, InterruptedException {
        // TODO Auto-generated method stub
        String line = value.toString();
        String []num=line.split("\t");
        long firstNum=Long.parseLong(num[0]);
        long secondNum=Long.parseLong(num[1]);
        SortBean bean = new SortBean(firstNum,secondNum);
        context.write(bean, NullWritable.get());
    }
}

Reduce端

package Hadoop.MR.mysort;

import java.io.IOException;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Reducer;
/**
 * 自定义排序reduce端
 * @author Young
 * @version 创建时间：2017年6月30日上午10:30:42
 */
public class MySortReducer extends Reducer<SortBean, NullWritable, SortBean, NullWritable> {
    @Override
    protected void reduce(SortBean k2, Iterable<NullWritable> v2,
            Reducer<SortBean, NullWritable, SortBean, NullWritable>.Context context)
            throws IOException, InterruptedException {
        // TODO Auto-generated method stub
        context.write(k2, NullWritable.get());
    }

}

驱动程序

package Hadoop.MR.mysort;

import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;


/**
 * 自定义排序驱动程序
 * @author Young
 * @version 创建时间：2017年6月30日上午10:38:23
 */
public class MySortDriver extends Configured implements Tool {
    public int run(String[] arg0) throws Exception {
        if (arg0.length != 2){
            System.err.printf("Usage:%s[generic options]<input> <output>\n",getClass().getSimpleName());
            ToolRunner.printGenericCommandUsage(System.err);
            return -1;
        }
//      Configuration conf = new Configuration();
//      Job job = new Job(getConf(),"Max Temperture");
        Job job = Job.getInstance(getConf(), "MySort");
        job.setJarByClass(getClass());

        FileInputFormat.addInputPath(job, new Path(arg0[0]));
        FileOutputFormat.setOutputPath(job, new Path(arg0[1]));

        job.setMapperClass(MySortMapper.class);
        job.setReducerClass(MySortReducer.class);

        job.setOutputKeyClass(SortBean.class);
        job.setOutputValueClass(NullWritable.class);

        return job.waitForCompletion(true)?0:1;
    }


    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        int exitCode = ToolRunner.run(new MySortDriver(), args);
        System.exit(exitCode);
    }
}

排序前后
这里写图片描述

三，求最值
Map端

package Hadoop.MR.max;
import java.io.IOException;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
/**
 * 最大值Map阶段
 * @author Young
 * @version 创建时间：2017年9月5日下午3:47:02
 */
public class MaxMapper extends Mapper<LongWritable, Text, Text, DoubleWritable> {
    @Override
    protected void map(LongWritable key, Text value,
            Mapper<LongWritable, Text, Text, DoubleWritable>.Context context)
            throws IOException, InterruptedException {
        String lines[]=value.toString().split("\t");
        String account=lines[0];
        double income=Double.parseDouble(lines[1]);
        context.write(new Text(account), new DoubleWritable(income));
    }
}

Reduce端

package Hadoop.MR.max;
import java.io.IOException;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
/**
 * 最大值Reduce阶段
 * @author Young
 * @version 创建时间：2017年9月5日下午4:15:29
 */
public class MaxReducer extends Reducer<Text, DoubleWritable, Text, DoubleWritable> {
    @Override
    protected void reduce(Text key, Iterable<DoubleWritable> value,
            Reducer<Text, DoubleWritable, Text, DoubleWritable>.Context context)
            throws IOException, InterruptedException {
        double Max=Double.MIN_VALUE;
        for(DoubleWritable v:value){
            Max=Math.max(Max, v.get());
        }
        context.write(key, new DoubleWritable(Max));
    }
}

驱动程序

package Hadoop.MR.max;

import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
/**
 * 最大值驱动类
 * @author Young
 * @version 创建时间：2017年9月5日下午4:17:32
 */
public class MaxDriver extends Configured implements Tool {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        int exitCode = ToolRunner.run(new MaxDriver(), args);
        System.exit(exitCode);
    }

    public int run(String[] arg0) throws Exception {
        if (arg0.length != 2){
            System.err.printf("Usage:%s[generic options]<input> <output>\n",getClass().getSimpleName());
            ToolRunner.printGenericCommandUsage(System.err);
            return -1;
        }
        Job job = Job.getInstance(getConf(), "Max");
        job.setJarByClass(getClass());
        FileInputFormat.addInputPath(job, new Path(arg0[0]));
        FileOutputFormat.setOutputPath(job, new Path(arg0[1]));
        job.setMapperClass(MaxMapper.class);
        job.setReducerClass(MaxReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(DoubleWritable.class);
        return job.waitForCompletion(true)?0:1;
    }
}

排序前后
这里写图片描述

四，TopN，文件中包含不同的key，键值不唯一，取每个键值前三个最小值。
Map端

package Hadoop.MR.topn;

import java.io.IOException;

import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
/**
 * 取前n名Map阶段
 * @author Young
 * @version 创建时间：2017年9月10日下午3:26:00
 */
public class TopNMapper extends Mapper<LongWritable,Text,Text ,DoubleWritable> {
    private Text k=new Text();
    private DoubleWritable v=new DoubleWritable();
    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text ,DoubleWritable>.Context context)
            throws IOException, InterruptedException {
        String lines[]=value.toString().split("\t");
        String account=lines[0];
        double income=Double.parseDouble(lines[1]);
        v.set(income);
        k.set(account);
        context.write(k,v);
    }
}

Reduce端

package Hadoop.MR.topn;

import java.io.IOException;
import java.util.TreeSet;

import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
/**
 * 取前n名reduce阶段
 * @author Young
 * @version 创建时间：2017年9月10日下午3:49:01
 */
public class TopNReducer extends Reducer<Text ,DoubleWritable,Text ,DoubleWritable> {
    private  TreeSet<Double> incomeTreeSet = new TreeSet<Double>();
    private  DoubleWritable v=new DoubleWritable();
    private  int n=3;
    @Override
    protected void reduce( Text key, Iterable<DoubleWritable> value,
            Reducer<Text ,DoubleWritable, Text ,DoubleWritable>.Context 

context)
            throws IOException, InterruptedException {
        // TODO Auto-generated method stub
           for (DoubleWritable val : value) {  
               incomeTreeSet.add(val.get());  
               if (incomeTreeSet.size() > n) {  
                   incomeTreeSet.remove(incomeTreeSet.first());  
               }  
           }  
           for (Double in: incomeTreeSet) {  
               v.set(in);  
               context.write(key, v);  
           } 
    }
}

驱动程序

package Hadoop.MR.topn;

import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

/**
 * 取前n名驱动程序
 * @author Young
 * @version 创建时间：2017年9月10日下午3:59:49
 */
public class TopNDriver extends Configured implements Tool {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        int exitCode = ToolRunner.run(new TopNDriver(), args);
        System.exit(exitCode);
    }

    public int run(String[] arg0) throws Exception {
         //TODO Auto-generated method stub
        if (arg0.length != 2){
            System.err.printf("Usage:%s[generic options]<input> <output>\n",getClass().getSimpleName());
            ToolRunner.printGenericCommandUsage(System.err);
            return -1;
        }
        Job job = Job.getInstance(getConf(), "TopN");
        job.setJarByClass(getClass());

        FileInputFormat.addInputPath(job, new Path(arg0[0]));
        FileOutputFormat.setOutputPath(job, new Path(arg0[1]));

        job.setMapperClass(TopNMapper.class);
        job.setReducerClass(TopNReducer.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(DoubleWritable.class);

        return job.waitForCompletion(true)?0:1;
    }
}

结果
这里写图片描述
结果是有了，但是后来觉得这样会把Reduce给拖死，TreeSet的排序以及换位会消耗很多内存资源。想在Map就把排序做好，然后Reduce直接取前n就好了，不过没想到。有更好的算法的，请拍砖。

MapReduce对大数据进行排序的实践
qq_42439715的博客
06-12 3730
从一个小的例子开始:Map和reduce之间的shuffle(洗牌)是将key值相同的放在一块,sort(排序)是按照key值进行排序.例如like出现了两次,就会把like放在一起.you也是.然后根据key值进行按照字典的顺序进行排序.下面我想将下面的数据按照时间进行排序,并且ID相同的在一块.具体的数据格式:(数据简化成如下,其实还包含其他的一些数据)6395        14738405...
mapreduce常见案例
weixin_43853330的博客
06-14 4472
常见案例 1.二次排序 2.共同好友 3.点击流分析模型 案例一1：二次排序 原始数据 目标数据 代码 –Map/Reduce不需要改变，主要是SortComparator通过继承WritableComparator类，重写了compare方法，改变了hadoop默认的排序规则。 步骤1.建立对象存储数据，继承WritableComparable，添加序列化、反序列化、比较器 package...
MapReduce排序
功不唐捐，玉汝于成
05-20 1515
MapReduce排序、全排序、二次排序、区内排序
hadoop架构-----MapReduce机制（终于又明白了！）
最新发布
weixin_74257347的博客
09-19 1254
定义：分布式运算程序的编程框架，是基于hadoop的数据分析和应用的核心框架。包括自己处理业务的相关代码+自身的默认代码易于编程 ：用户只关心业务逻辑，实现框架的接口；良好的扩展性：可以动态增加服务器；高容错性：将任务转给其他节点；适合海量数据计算。不擅长实时计算；不擅长流式计算；不擅长DAG有向无环图计算。数据计算基于磁盘，效率较低，Spark计算基于内存。
简单描述MapReduce（mr是什么？）
王傲旗的大数据之路
03-04 623
概念 Hadoop MapReduce 是一个分布式计算框架，用于编写批处理应用程序。编写好的程序可以提交到 Hadoop 集群上用于并行处理大规模的数据集。 MapReduce作业通常将输入数据集拆分为独立的块，这些任务由map任务以完全并行的方式进行处理。框架对map的输出进行排序，然后将其输入到reduce任务。 通常，作业的输入和输出都存储在文件系统中。该框架负责安排任务，监视任务并重新执行失败的任务。 MapReduce可以分成Map和Reduce两部分理解。 1.Map：映射过程，把一组数据按
【转】大数据【五十九】Map Reduce中的排序
sunshine77_的博客
11-10 877
一。排序的分类 排序贯穿于Map任务和Reduce任务，是MapReduce非常重要的一环，排序操作属于MapReduce计算框架的默认行为，不管流程是否需要，都会进行排序。在MapReduce计算框架中，主要用到了两种排序方法：快速排序和归并排序 快速排序： 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都小，然后再按此方法对这两部分数据...
MR（MapReduce）架构
qq_66563605的博客
07-21 1153
mapreducer
MapReduce 常见的编程场景 1
weixin_44387652的博客
10-23 703
MapReduce 常见的编程场景 11、MapReduce 多 Job 串联1.1、需求1.2、实例2、TopN 算法实现-自定义 GroupComparator2.1、需求2.2、分析3、MapReduce 全局计数器3.1、介绍3.2、需求3.3、实例4、MapJoin-DistributedCache 应用4.1、MapReduce Join 介绍4.2、需求4.3、实现 1、MapReduce 多 Job 串联 1.1、需求 一个稍复杂点的处理逻辑往往需要多个 MapReduce 程序串联处理，多
hadoop学习笔记（四）MapReduce常见实例一：去重、求平均值
Lee的学习笔记
12-20 1624
去重  问题：有一个名为buyer_favorite1的数据文件，记录了用户收藏的商品以及收藏的日期 文件中包含（用户id，商品id，收藏日期）三个字段，数据内容以“\t”分割 要求根据商品id进行去重，统计用户收藏商品中都有哪些商品被收藏，输出去重后所有的商品id和收藏了该商品的用户id 。 数据内容如下： 用户id 商品id 收藏日期 10181 1000481 20...
MR-5.MapReduce排序
艾文
01-26 934
部分排序 部分排序可以调用默认的HashPartitioner按照键排序顺序文件。 应用场景，大部分的业务需求，都是用来统计每个指标的数据结果，故这种场景比较实用，通过分区把大的数据分配到多台机器上同时执行，提高执行的效率。   全局排序 如何用Hadoop产生一个全局排序文件呢？最简单的方法是使用一个分区（默认HashPartitioner）。但该方法处理大型文件效率极低。一般有两种方
【压缩误区大扫除】：MapReduce常见问题与对策
[【压缩误区大扫除】：MapReduce常见问题与对策](https://i-blog.csdnimg.cn/direct/910b5d6bf0854b218502489fef2e29e0.png) # 1. MapReduce简介与误区概览 ## 1.1 MapReduce概念介绍 MapReduce是一种编程模型，...
MapReduce中的排序
weixin_30700099的博客
07-16 294
hadoop的计算模型就是map/reduce，每一个计算任务会被分割成很多互不依赖的map/reduce计算单元，将所有的计算单元执行完毕后整个计算任务就完成了。因为计算单元之间互不依赖所以计算单元可以分配到不同的计算机上执行，这样就可以将计算压力平摊到多个机器上面。当然性能线性提高是有条件的，前提是计算任务所采用的算法必须能够适应map/reduce模式。例如对于海量数据排序任务...
MR-1.MapReduce概述
艾文
01-26 599
是一计算模型。输入部分来自于HDFS，输出部分写入到HDFS。 分为两阶段，先是map阶段然后是reduce阶段。 1.        map读取hdfs中的数据，然后把原始数据进行规范处理 2.        reduce是接受map阶段输出的数据，自身进行汇总，然后把结果写入到hdfs中
mapreduce分组统计_Hadoop实战-MapReduce之分组(group-by)统计(七)
weixin_39819138的博客
12-21 342
1、数据准备使用MapReduce计算age.txt中年龄最大、最小、均值name,min,max,countMike,35,20,1Mike,5,15,2Mike,20,13,1Steven,40,20,10Ken,28,68,1Ken,14,198,10Cindy,32,31,1002、预期结果Mike520 4Steven,40,20,10Ken 14 198 11Cindy,32,...
MR -- MapReduce详细流程
a1786742005的博客
02-29 275
Hadoop之mapReduce有几种排序及排序发生的阶段
qq_38603049的博客
10-25 1716
1）排序的分类： （1）部分排序： MapReduce根据输入记录的键对数据集排序。保证输出的每个文件内部排序。 （2）全排序： 如何用Hadoop产生一个全局排序的文件？最简单的方法是使用一个分区。但该方法在处理大型文件时效率极低，因为一台机器必须处理所有输出文件，从而完全丧失了MapReduce所提供的并行架构。 替代方案：首先创建一系列排好序的文件；其次，串联这些文件；最后，生成一个全局排序...
MapReduce的排序
白墨的小白博客
09-27 791
排序是数据分析中最常用的操作，没有之一。 单字段升序： 利用 mapreduce 自身的排序机制，把需要排序的字段作为 key 即可 自定义排序规则： 方案一：自定义 key 1. 自定义类实现 WritableComparable 接口，设置泛型为自定义类 2. 声明需要排序的字段，添加 setter && getter 3...
Hadoop mapreduce 实现MR_DesicionTreeBuilder 决策树
01-28
这可能是指某本书的第10章第4节，该章节详细介绍了如何在 Hadoop MapReduce 中实现 MR_DesicionTreeBuilder。书中可能会涵盖以下内容： - 数据模型和输入输出格式 - Map 和 Reduce 函数的实现细节 - 特征选择...
MapReduce实现sql的group by和join
天天向上
06-18 2264
一、group by： HiveQL：select deptno, sum(sal) from emp group by deptno order by deptno; 场景模拟：要求计算出每个部门的工资总额。 package com.szh.hadoop; import java.io.File; import java.io.IOException; import java.net....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值