内存排序TOPN

最新推荐文章于 2022-02-26 14:44:33 发布
最新推荐文章于 2022-02-26 14:44:33 发布
阅读量1.2k 收藏 4
点赞数
分类专栏： MapReduce 文章标签： MapReduce案例 TOPN
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35078688/article/details/83018566
版权

取出前三名的值
简单排序：直接通过Reducer端中的reduce方法可以直接进行排序 Mapper端中也会进行排序 Mapper端中也会进行排序（以key进行排排序）

内存排序：将数据存储到一个容器中(集合),这个集合是存储在内存中，
对集合中的数据进行排序称之为内存排序

第一种：

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
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;


/**
 * Description： TOPN<br/>
 * Copyright (c) , 2018, xlj <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:TOPN.java <br/>
 * 
 * @version : 1.0
 */
public class TOPN {
	 //实现MapReduce
	/*1.实现Mapper端的逻辑
	 * KEYIN：文件中读取的偏移量-->LongWritable(固定的) 
	 * VALUEIN：文件中实际读取的内容-->Text
	 * KEYOUT:Mapper处理完成后传递给Reducer中的KEYIN的数据类型-->不固定，根据需求来
	 * VALUEOUT：Mapper端处理完成后传递给Reducer中的VALUEIN的数据类型-->不固定，根据需求来
	 */
	public static class MyMapper extends  Mapper<LongWritable, Text, Text, Text>{
		/* 进入Map处理逻辑之前会执行一次的方法
		 */
		@Override
		protected void setup(Context context)
				throws IOException, InterruptedException {
		}
		/*
		 * 需要实现Mapper端的处理逻辑
		 * key:是文件中数据的偏移量，数据类型是由泛型中定义得来的KEYIN
		 * value:是文件中实际的内容，数据类型是泛型中定义得来的VALUEIN
		 * context：将处理过后产生的KV，写成文件输出
		 */
		@Override
		protected void map(LongWritable key, Text value, Context context)
				throws IOException, InterruptedException {
			String []words = value.toString().split(" ");
			for (String word : words) {
				context.write(new Text(word), new Text("1"));
			}
		}
		/* 
		 * 在Map处理逻辑之后会执行一次，可以处理一些逻辑
		 */
		@Override
		protected void cleanup(Context context)
				throws IOException, InterruptedException {
			
		}
	}
	
	//实现Reducer端的逻辑
   /*
    * Reducer相当于对Mapper端处理过后的数据进行一个实际的处理业务
    * KEYIN-->Mapper处理过后输出key的数据类型，由Mapper的泛型中第三个参数决定
    * VALUE-->Mapper处理过后输出value的数据类型，由Mapper的泛型中第四个参数决定
    * KEYOUT-->Reducer端处理完数据之后要写出key的数据类
    * VALUEOUT-->Reducer处理完数据之后，要写出value的 数据类
    */
	public static class MyReduce extends Reducer<Text, Text, Text, Text>{
		
		Map<String,Integer> map = new HashMap<>();
		/* 执行Reducer端先执行一次的方法
		 */
		@Override
		protected void setup(Context context) throws IOException, InterruptedException {
			
		}
		
		/*
		 *reduce方法是处理业务的核心逻辑 
		 *key: 是从Mapper端处理完成后，产生key的数据
		 *values-->是从 Mapper端处理完成之后相同key的values的数据集合
		 *context-->写出实际 处理完成后KV的方法 
		 */
		@Override
		protected void reduce(Text key, Iterable<Text> values, Context context)
				throws IOException, InterruptedException {
			int  count = 0;
			//<hello,list<1,1>
			for (Text t : values) {
				count += Integer.parseInt(t.toString());
			}
			/*
			 * 因为当前单词统计的个数存储到一个集合中进行排序
			 * 因为集合中的单词要排序，实体排序是统计单词个数的值，那么
			 * 单纯的存储单词个数是无法得知是哪个单词
			 * 所以我们将单词定义在reduce方法 中，那么集合只能在方法体中使用，然后排序输出
			 * 若将集合定义在reduce方法中，那么集合只能在方法体中使用，然后排序输出
			 * 若将集合声明为成员变量，那么在其他地方就可以使用，
			 * 那么此时可以用cleanup来做最终输出
			 */
			map.put(key.toString(), count);
			
		}
		/* 
		 * 执行完reduce方法执行的方法
		 * 
		 */
		@Override
		protected void cleanup(Context context)
				throws IOException, InterruptedException {
			
				Set<Map.Entry<String, Integer>> mapSet = map.entrySet();
				List<Map.Entry<String, Integer>> list = new ArrayList<>(mapSet); 
				
				Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
				@Override
				public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
					return o2.getValue().compareTo(o1.getValue())  ;
				}
			});
				
			int i = 0;//作为一个计数器
			Iterator<Entry<String, Integer>> it = list.iterator();
			while(it.hasNext()) {
				if(i  ==  3) {//当 i = 3时,则停止输出
					break;
				}
				Map.Entry<String, Integer> words= it.next();
				String key = words.getKey();
				Integer value = words.getValue();
				context.write(new Text(key+""), new Text(value+""));
				i++;
			}
		}
	}
	/**
	 * 实现job,完成作业配置
	 */
	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		//1.获取配置对象
		Configuration conf = new Configuration();
		//2.创建Job对象(创建作业)
		/*
		 * 这个方法一共有两个参数版本
		 * getInstance(conf) --------直接传入配置对象
		 * getInstance(conf,"WordCountCombiner")---传入配置对象和类的名字
		 */
		Job job = Job.getInstance(conf);
		//3.设置运行job的class
		job.setJarByClass(TOPN.class);
		
		//4.设置Mapper端的运行类和输出key，输出value的数据类型
		job.setMapperClass(MyMapper.class);
		job.setMapOutputKeyClass(Text.class);
		job.setOutputValueClass(Text.class);
		
		//5.读取数据来源
		
		//这两个方法处理是一样的，只是最后一个参数不同，
		/*
		 * FileInputFormat.addInputPath(job, new Path("input/data1"));
		 * 
		 * add:证明只有 一个路径，
		 * 
		 * FileInputFormat.setInputPaths(job, new Path("input/data1"));
		 * set证明后面是可变参数，多个
		 * 
		 * 因为当前运行的是本地MR，所以数据是 从本地读取，若需要在集群中运行，这个位置的参数应该是args[0]
		 */
		//FileInputFormat.addInputPath(job, new Path("input/data2"));
		FileInputFormat.setInputPaths(job, new Path("input/data3"));
		
		//优化设置
		//一般可以写分区设置，多文件输出设置，Combiner设置
		/*
		 * 并不是所有job都适用于Combiner，只有操作满足结合规律才可以进行设置
		 * 如 求和，求最大值，topN 等可以使用Combiner
		 * 
		 * Combiner不一定需要存在，只有数据量较大，需要做优化的时候可以使用
		 */
		
		//6.社会Reducer端的运行类和输出key和输出value的数据类型
		job.setReducerClass(MyReduce.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(Text.class);
		
		//7.处理完文件之后输出的路径
		//ps：因为当前运行的是本地MR，所以数据是写到本地的，若需要再集群中运行，这个位置的参数应该是args[1]
		//数据是存储到HDFS中
		FileOutputFormat.setOutputPath(job, new Path("output1"));
		
		//8.提交作业
		int isok = job.waitForCompletion(true)?0:-1;
		System.exit(isok);
	}
}

第二种：

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
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;


/**
 * Description： TOPN<br/>
 * Copyright (c) , 2018, xlj <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:TOPN.java <br/>
 * 
 * @version : 1.0
 */
public class TOPN2 {
	 //实现MapReduce
	/*1.实现Mapper端的逻辑
	 * KEYIN：文件中读取的偏移量-->LongWritable(固定的) 
	 * VALUEIN：文件中实际读取的内容-->Text
	 * KEYOUT:Mapper处理完成后传递给Reducer中的KEYIN的数据类型-->不固定，根据需求来
	 * VALUEOUT：Mapper端处理完成后传递给Reducer中的VALUEIN的数据类型-->不固定，根据需求来
	 */
	public static class MyMapper extends  Mapper<LongWritable, Text, Text, Text>{
		/* 进入Map处理逻辑之前会执行一次的方法
		 */
		@Override
		protected void setup(Context context)
				throws IOException, InterruptedException {
		}
		/*
		 * 需要实现Mapper端的处理逻辑
		 * key:是文件中数据的偏移量，数据类型是由泛型中定义得来的KEYIN
		 * value:是文件中实际的内容，数据类型是泛型中定义得来的VALUEIN
		 * context：将处理过后产生的KV，写成文件输出
		 */
		@Override
		protected void map(LongWritable key, Text value, Context context)
				throws IOException, InterruptedException {
			String []words = value.toString().split(" ");
			for (String word : words) {
				context.write(new Text(word), new Text("1"));
			}
		}
		/* 
		 * 在Map处理逻辑之后会执行一次，可以处理一些逻辑
		 */
		@Override
		protected void cleanup(Context context)
				throws IOException, InterruptedException {
			
		}
	}
	
	//实现Reducer端的逻辑
   /*
    * Reducer相当于对Mapper端处理过后的数据进行一个实际的处理业务
    * KEYIN-->Mapper处理过后输出key的数据类型，由Mapper的泛型中第三个参数决定
    * VALUE-->Mapper处理过后输出value的数据类型，由Mapper的泛型中第四个参数决定
    * KEYOUT-->Reducer端处理完数据之后要写出key的数据类
    * VALUEOUT-->Reducer处理完数据之后，要写出value的 数据类
    */
	public static class MyReduce extends Reducer<Text, Text, Text, Text>{
		
		List<String> list = new ArrayList<>();
		/* 执行Reducer端先执行一次的方法
		 */
		@Override
		protected void setup(Context context) throws IOException, InterruptedException {
			
		}
		
		/*
		 *reduce方法是处理业务的核心逻辑 
		 *key: 是从Mapper端处理完成后，产生key的数据
		 *values-->是从 Mapper端处理完成之后相同key的values的数据集合
		 *context-->写出实际 处理完成后KV的方法 
		 */
		@Override
		protected void reduce(Text key, Iterable<Text> values, Context context)
				throws IOException, InterruptedException {
			int  count = 0;
			//<hello,list<1,1>
			for (Text t : values) {
				count += Integer.parseInt(t.toString());
			}
			/*
			 * 因为当前单词统计的个数存储到一个集合中进行排序
			 * 因为集合中的单词要排序，实体排序是统计单词个数的值，那么
			 * 单纯的存储单词个数是无法得知是哪个单词
			 * 所以我们将单词定义在reduce方法 中，那么集合只能在方法体中使用，然后排序输出
			 * 若将集合定义在reduce方法中，那么集合只能在方法体中使用，然后排序输出
			 * 若将集合声明为成员变量，那么在其他地方就可以使用，
			 * 那么此时可以用cleanup来做最终输出
			 */
			list.add(key.toString()+"_"+count);
		}
		/* 
		 * 执行完reduce方法执行的方法
		 * 
		 */
		@Override
		protected void cleanup(Context context)
				throws IOException, InterruptedException {
			//对集合中的数进行排序
			for (int i = 0; i < list.size(); i++) {
				for (int j = i+1; j < list.size(); j++) {
					/*
					 * 当前集合中是字符串
					 * 不能 使用字符串和字符串进行比较
					 * 所以这里需要将字符串进行一个拆分，取出后面的值进行比较
					 * 这样一来就能知道谁最大了，取出后面的值进行比较
					 * 降序排序 从达到小
					 */
					if(Integer.parseInt(list.get(i).split("_")[1]) < Integer.parseInt(list.get(j).split("_")[1])) {
						String tmp = "";
						tmp = list.get(i);
						list.set(i, list.get(j));
						list.set(j, tmp);
					}
					
				}
			}
			for (int i = 0; i < 3; i++) {
				String [] str  = list.get(i).split("_");
				context.write(new Text(str[0]), new Text(str[1]));
			}
				
		}
	}
	/**
	 * 实现job,完成作业配置
	 */
	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
		//1.获取配置对象
		Configuration conf = new Configuration();
		//2.创建Job对象(创建作业)
		/*
		 * 这个方法一共有两个参数版本
		 * getInstance(conf) --------直接传入配置对象
		 * getInstance(conf,"WordCountCombiner")---传入配置对象和类的名字
		 */
		Job job = Job.getInstance(conf);
		//3.设置运行job的class
		job.setJarByClass(TOPN2.class);
		
		//4.设置Mapper端的运行类和输出key，输出value的数据类型
		job.setMapperClass(MyMapper.class);
		job.setMapOutputKeyClass(Text.class);
		job.setOutputValueClass(Text.class);
		
		//5.读取数据来源
		
		//这两个方法处理是一样的，只是最后一个参数不同，
		/*
		 * FileInputFormat.addInputPath(job, new Path("input/data1"));
		 * 
		 * add:证明只有 一个路径，
		 * 
		 * FileInputFormat.setInputPaths(job, new Path("input/data1"));
		 * set证明后面是可变参数，多个
		 * 
		 * 因为当前运行的是本地MR，所以数据是 从本地读取，若需要在集群中运行，这个位置的参数应该是args[0]
		 */
		//FileInputFormat.addInputPath(job, new Path("input/data2"));
		FileInputFormat.setInputPaths(job, new Path("input/data3"));
		
		//优化设置
		//一般可以写分区设置，多文件输出设置，Combiner设置
		/*
		 * 并不是所有job都适用于Combiner，只有操作满足结合规律才可以进行设置
		 * 如 求和，求最大值，topN 等可以使用Combiner
		 * 
		 * Combiner不一定需要存在，只有数据量较大，需要做优化的时候可以使用
		 */
		
		//6.社会Reducer端的运行类和输出key和输出value的数据类型
		job.setReducerClass(MyReduce.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(Text.class);
		
		//7.处理完文件之后输出的路径
		//ps：因为当前运行的是本地MR，所以数据是写到本地的，若需要再集群中运行，这个位置的参数应该是args[1]
		//数据是存储到HDFS中
		FileOutputFormat.setOutputPath(job, new Path("output1"));
		
		//8.提交作业
		int isok = job.waitForCompletion(true)?0:-1;
		System.exit(isok);
	}

在这里插入图片描述
在这里插入图片描述

file.txt

hello xiaoming hello xiaoming xiaoming is best xiaoming better
hadoop is good
spark is nice

结果

在这里插入图片描述

哪有天生的学霸，一切都是厚积薄发
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
理解C++的内存顺序（memory ordering）
夏天的狂风的专栏
06-10 257
在计算机科学中，内存顺序是一个理论模型，它描述了多线程程序中的内存访问行为。内存顺序定义了多个线程之间如何交互，以及它们如何共享和操作内存。在C++中，内存顺序是通过枚举来定义的。和。它们定义了不同的内存顺序语义，从最弱的到最强的。C++的内存顺序为并发编程提供了强大的支持。通过理解内存顺序，你可以编写出更高效、更安全的多线程程序。希望本文能帮助你理解C++的内存顺序，为你的并发编程之旅提供指导。在实际编程中，你可能会遇到更复杂的情况，例如需要处理多个原子操作的结果，或者需要使用更弱的内存顺序来提高性能。
最大堆的TopN排序
06-27
可以用于对任意数据类型进行topN排序，同时保持数据原来的序号或位置，在信息检索上非常使用，代码简单高效，使用简单。
内存顺序（Memory Order）
weixin_40581617的博客
10-10 2630
这篇文章主要介绍内存顺序（Memory Order），然后会结合 RocksDB | LevelDB 中的 SkipList 源码来具体分析 RocksDB SkipList 如何通过内存顺序和原子操作做到无锁并发（一写多读）。 Memory Order 内存顺序描述了计算机 CPU 获取内存的顺序，内存的排序既可能发生在编译器编译期间，也可能发生在 CPU 指令执行期间。 为了尽可能地提高...
排序_内存排序
m0_37357063的博客
09-08 1812
目录 0.各种排序算法对比 ​1.冒泡排序 2.选择排序 3.直接插入排序 4.Shell排序（缩小增量插入排序） 5.归并排序 6.快速排序 7.堆排序和优先队列 7.1堆排序 7.1.1初始建堆 7.1.2 输出堆顶后调整为新堆 7.2利用建立堆实现一优先队列 0.各种排序算法对比 1.冒泡排序 //冒泡排序，平均时间O(n^2),最好O(n)，最坏O(...
内存中对集合进排序-JoSQL
chenhou2839的博客
02-27 217
范例： package com.wef.util; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.text.Collator; import java.u...
内存&cpu占比排序
tryyourbest0928的博客
06-18 555
需求：列出机器上现有进程内存和cpu使用情况，按内存或者cpu使用排序，占比从大到小 $ ps -eo pmem,pcpu,pid,etime,rss,vsize,args | sort -k 1 -r | less %MEM %CPU PID ELAPSED RSS VSZ COMMAND 0.4 0.0 13600 50-23:25:23 15788 574304 /usr/bin/python2 -Es /usr/sbin/tuned -l -P 0.2 0.0 21
Spark的TopN示例
06-10
其中，"Spark的TopN示例"是常见的数据挖掘任务，用于找出数据集中出现频率最高的N个元素或者按某种指标排序的前N个元素。在Spark中，TopN算法的实现方式多种多样，主要分为针对唯一键的TopN、非唯一键的TopN以及在每...
tpn.rar_TPN_topN
09-14
而TopN算法则能在不完全排序的情况下，仅维护一个大小为N的集合，确保任何时候这个集合中都包含当前已遍历到的N个最大（或最小）元素。 堆是一种特殊的树形数据结构，满足堆性质：父节点的值要么大于等于（大顶堆）...
按内存占用排序和按CPU占用排序的Linux TOP命令.docx
09-27
Linux TOP 命令详解 Linux TOP 命令是系统维护和电脑内存维护的重要工具之...Linux TOP 命令是一个功能强大且实用的系统维护工具，它可以帮助系统管理员实时监控系统的 CPU 和内存使用情况，并对进程进行排序和管理。
寻找最优的topn算法
10-25
在处理大量数据时，经常需要解决TopN问题，即根据某个可排序的属性（通常是数值型），从数据集中找出最大的前N个记录。尽管这个问题相对简单，但要设计出高效的算法并不容易。本文将对几种常见的TopN算法进行分析...
查找和排序算法1
08-04
在IT领域，排序和查找算法是编程基础中的关键部分，它们在处理大量数据时起着至关重要的作用。这里我们将深入探讨几种...在选择算法时，应考虑数据规模、是否已排序、内存限制等因素，选择最适合当前问题的解决方案。
大数据小内存排序
q1057589665的专栏
03-21 4683
需求：有一个很大的文件需要对内容进行排序（ps:内容可简单理解为数字），如何在有限的内存下进行排序，内存很小。 分析： 1.文件很大我们需要分而治之，分为若干文件 2.内存小，划分小文件的时候要注意，文件内容应该可以足够放入内存 3.拆分小文件的时候，对改文件内容进行排序（ps:非本文章重点故省略） 4.对有序的文件进行归并排序以上就是大致的思路，下面直接上代码，代码略有粗糙，各位看客包涵
八大内存排序算法
sinat_27180563的博客
06-02 2862
类型一、选择排序 （1）冒泡排序： a.每趟排序，最大沉底; b.排列元素个数逐渐（从尾）减一，因为每趟排序，最后一位已确定； c.每次冒泡序列：0 ~ i-1 TimeCost：O(N^2) SpaceCost：O(N) 代码： void BubbleSort(int[] nums){ int i,j; for(i=nums.length; i>0; i--){ for(j=0; j<i; j++){ if(nums[j] > nums[j+1]) swap(
关于TOPN问题与堆排序
见端而知末
02-26 2204
1、TOPN问题本质就是在一个海量的数据里面取最大的N个元素的问题。然后呢，围绕这个问题，还会有其它一些问题。 2、如果这个数据量不是很大，比如100个数据，取最大的10个，那先排序
常见的排序方法
cctchen的博客
07-08 357
每天进步一点，珍惜生活，珍惜时间！         每天交工作日志时，都有一种时间真快的赶脚。年纪越大，越发觉得时间真是快啊，每天对着代码，然后不知不觉时间没了。想想都害怕。就像一梦千年一样。好了，不啰嗦了，今天主要学习一下八个排序方法。         排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过
海量数据找topN
iwtbs
03-05 1143
文章目录从10亿个数据（int型占据4B）中找中位数，内存限制为1GB从10亿数中选取前1000大的数字 从10亿个数据（int型占据4B）中找中位数，内存限制为1GB 不可能一次性把数据全部加载到内存中，再使用快速排序算法，因为10亿*4B大约为4GB，内存不够 可以一次性读入1GB的数据（分10次读取），然后对读入的1GB数据按照最高位即第32位的值进行分类并写入文件，如果最高位是1，写入fi...
九大排序
ChangWen的博客
06-03 1019
一、概述　　排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序（使用内存），而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说九大排序就是内部排序。 　　内部排序有可以分为以下几类： 　　(1)、插入排序：直接插入排序、希尔排序、二分法插入排序。 　　(2)、选择排序：简单选择排序、堆排序。 　　(3)、交换排序：冒泡排序、快速排序
数据结构之内部排序--排序的基本概念
Night Fury 的博客
03-17 956
排序 有n个记录的序列R1,R2,...,RnR1,R2,...,Rn{R_1,R_2,...,R_n},其相应的关键字的序列是K1,K2,...,KnK1,K2,...,Kn{K_1,K_2,...,K_n},相应的下标序列1,2,…,n。通过排序，找出当前的下标序列1,2,…,n的一种排列p1,p2,...，pnp1,p2,...，pnp_1,p_2,...，p_n，使得相应的关键字满足如下...
海量数据快速查找出现频率topN
jinjin603的博客
11-29 1385
海量数据寻找出现频率最多的topN，且内存受到限制，该如何处理呢？主要思想就是分治。如果使用框架处理，hadoop的MapReduce运算框架是可以解决的，且是分布式的处理。但是单机版该如何处理呢。空闲时间使用python3实现了一版，做一下记录。 import collections import re import sys import time """ 找出一个超大文件中出现频率最高的10...
linuxtop命令排序
最新发布
07-28
你可以使用`top`命令来查看当前系统的进程信息，并可以按照指定的列进行排序。以下是一些常见的排序选项： 1. CPU 使用率：按下`P`键，然后按下`Enter`键。 2. 内存使用率：按下`M`键，然后按下`Enter`键。 3. 运行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值