Hadoop 学习笔记 （十） MapReduce实现排序 全局变量 - 雨渐渐 - 博客园
随笔 - 574, 文章 - 1, 评论 - 19, 引用 - 0
一些疑问：1 全排序的话，最后的应该sortJob.setNumReduceTasks(1);2 如果多个reduce task都去修改 一个静态的 IntWritable ，IntWritable会乱序吧~输入数据：file1232654321575665223file259562265092file326546import java.io.IOE
import org.apache.hadoop.conf.C
import org.apache.hadoop.fs.P
import org.apache.hadoop.io.IntW
import org.apache.hadoop.io.NullW
import org.apache.hadoop.io.T
import org.apache.hadoop.mapreduce.J
import org.apache.hadoop.mapreduce.M
import org.apache.hadoop.mapreduce.R
import org.apache.hadoop.mapreduce.lib.input.FileInputF
import org.apache.hadoop.mapreduce.lib.input.TextInputF
import org.apache.hadoop.mapreduce.lib.output.FileOutputF
public class MySort {
public static class IntSortMapper extends Mapper&Object, Text, IntWritable, NullWritable&{
private IntWritable val = new IntWritable();
public void map(Object key, Text value, Context context) throws IOException, InterruptedException{
String line = value.toString().trim();
val.set(Integer.parseInt(line));
context.write(val, NullWritable.get());
public static class IntSortReducer extends Reducer&IntWritable, NullWritable, IntWritable,IntWritable&{
private IntWritable k = new IntWritable();
public void reduce(IntWritable key, Iterable&NullWritable& values, Context context) throws IOException, InterruptedException{
for (NullWritable value : values) {
context.write(k, key);
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
String dir_in = "hdfs://localhost:9000/in_sort";
String dir_out = "hdfs://localhost:9000/out_sort";
Path in = new Path(dir_in);
Path out = new Path(dir_out);
Configuration conf = new Configuration();
Job sortJob = new Job(conf, "my_sort");
sortJob.setJarByClass(MySort.class);
sortJob.setInputFormatClass(TextInputFormat.class);
sortJob.setMapperClass(IntSortMapper.class);
//sortJob.setCombinerClass(SortReducer.class);
//countJob.setPartitionerClass(HashPartitioner.class);
sortJob.setMapOutputKeyClass(IntWritable.class);
sortJob.setMapOutputValueClass(NullWritable.class);
FileInputFormat.addInputPath(sortJob, in);
sortJob.setReducerClass(IntSortReducer.class);
sortJob.setNumReduceTasks(1);
sortJob.setOutputKeyClass(IntWritable.class);
sortJob.setOutputValueClass(IntWritable.class);
//countJob.setOutputFormatClass(SequenceFileOutputFormat.class);
FileOutputFormat.setOutputPath(sortJob, out);
sortJob.waitForCompletion(true);
修改reduce函数（不是用Iterable）
public static class IntSortReducer extends Reducer&IntWritable, NullWritable, IntWritable,IntWritable&{
private IntWritable k = new IntWritable();
public void reduce(IntWritable key, NullWritable value, Context context) throws IOException, InterruptedException{
//for (NullWritable value : values) {
context.write(k, key);
结果：（不是很理解，为啥去掉iterable后就只输出一个value
key哪去了呢）
import java.io.IOE
import org.apache.hadoop.conf.C
import org.apache.hadoop.fs.P
import org.apache.hadoop.io.IntW
import org.apache.hadoop.io.NullW
import org.apache.hadoop.io.T
import org.apache.hadoop.mapreduce.J
import org.apache.hadoop.mapreduce.M
import org.apache.hadoop.mapreduce.R
import org.apache.hadoop.mapreduce.lib.input.FileInputF
import org.apache.hadoop.mapreduce.lib.input.TextInputF
import org.apache.hadoop.mapreduce.lib.output.FileOutputF
public class MySort {
public static class IntSortMapper extends Mapper&Object, Text, IntWritable, NullWritable&{
private IntWritable val = new IntWritable();
public void map(Object key, Text value, Context context) throws IOException, InterruptedException{
String line = value.toString().trim();
val.set(Integer.parseInt(line));
context.write(val, NullWritable.get());
public static class IntSortReducer extends Reducer&IntWritable, NullWritable, IntWritable,IntWritable&{
private static IntWritable num = new IntWritable(1);
public void reduce(IntWritable key, Iterable&NullWritable& values, Context context) throws IOException, InterruptedException{
for (NullWritable value : values) {
context.write(num, key);
num = new IntWritable(num.get() + 1);
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
String dir_in = "hdfs://localhost:9000/in_sort";
String dir_out = "hdfs://localhost:9000/out_sort";
Path in = new Path(dir_in);
Path out = new Path(dir_out);
Configuration conf = new Configuration();
Job sortJob = new Job(conf, "my_sort");
sortJob.setJarByClass(MySort.class);
sortJob.setInputFormatClass(TextInputFormat.class);
sortJob.setMapperClass(IntSortMapper.class);
//sortJob.setCombinerClass(SortReducer.class);
//countJob.setPartitionerClass(HashPartitioner.class);
sortJob.setMapOutputKeyClass(IntWritable.class);
sortJob.setMapOutputValueClass(NullWritable.class);
FileInputFormat.addInputPath(sortJob, in);
sortJob.setReducerClass(IntSortReducer.class);
sortJob.setNumReduceTasks(1);
sortJob.setOutputKeyClass(IntWritable.class);
sortJob.setOutputValueClass(IntWritable.class);
//countJob.setOutputFormatClass(SequenceFileOutputFormat.class);
FileOutputFormat.setOutputPath(sortJob, out);
sortJob.waitForCompletion(true);
}1&& &22&& &63&& &154&& &225&& &266&& &327&& &328&& &549&& &9210&& &65011&& &65412&& &75613&& &595614&& &65223安全检查中...
请打开浏览器的javascript，然后刷新浏览器
< 浏览器安全检查中...
还剩 5 秒&三种方法实现Hadoop(MapReduce)全局排序(2) &#8211; 过往记忆
欢迎关注Hadoop、Spark、Flink、Hive、Hbase、Flume等大数据资料分享微信公共账号：iteblog_hadoop。
文章总数：886
浏览总数：11,688,700
评论：4898
分类目录：93 个 注册用户数：2760 最后更新：日
欢迎关注微信公共帐号：iteblog_hadoop大数据猿：bigdata_ai
我在前面的文章介绍了MapReduce中两种全排序的方法及其实现。但是上面的两种方法都是有很大的局限性：方法一在数据量很大的时候会出现OOM问题；方法二虽然能够将数据分散到多个Reduce中，但是问题也很明显：我们必须手动地找到各个Reduce的分界点，尽量使得分散到每个Reduce的数据量均衡。而且每次修改Reduce的个数时，都得手动去找一次Key的分界点！非常不灵活。本文这里介绍的第三种使用MapReduce全局排序的方法算是比较通用了，而且是内置的实现。文章目录使用TotalOrderPartitioner进行全排序我们都知道内置有个 HashPartitioner 分区实现类，MapReduce默认就是使用它；但其实内置还有个名为 TotalOrderPartitioner 的分区实现类，看名字就清楚它其实就是解决全排序的问题。如果你去看他的实现，其主要做的事实际上和我们上文介绍的 IteblogPartitioner 分区实现类很类似，也就是根据Key的分界点将不同的Key发送到相应的分区。问题是，上文用到的分界点是我们人为计算的；而这里用到的分界点是由程序解决的！数据抽样寻找合适的Key分割点需要我们对数据的分布有个大概的了解；如果数据量很大的话，我们不可能对所有的数据进行分析然后选出 N-1 （N代表Reduce的个数）个分割点，最适合的方式是对数据进行抽样，然后对抽样的数据进行分析并选出合适的分割点。Hadoop提供了三种抽样的方法：SplitSampler：从s个split中选取前n条记录取样RandomSampler：随机取样IntervalSampler：从s个split里面按照一定间隔取样，通常适用于有序数据这三个抽样都实现了K[] getSample(InputFormat inf, Job job) throws IOException, InterruptedE 方法；通过调用这个方法我们可以返回抽样到的Key数组，除了 IntervalSampler 类返回的抽样Key是有序的，其他都无序。获取到采样好的Key数组之后，需要对其进行排序，然后选择好N-1 （N代表Reduce的个数）个分割点，最后将这些Key分割点存储到指定的HDFS文件中，存储的文件格式是SequenceFile，使用如下：
TotalOrderPartitioner.setPartitionFile(job.getConfiguration(), new Path(args[2]));
InputSampler.Sampler&Text, Text& sampler = new InputSampler.RandomSampler&&(0.01, );
InputSampler.writePartitionFile(job, sampler);
TotalOrderPartitioner上面通过 InputSampler.writePartitionFile(job, sampler); 存储好了分割点，然后 TotalOrderPartitioner 类会在 setConf 函数中读取这个文件，并根据Key的类型分别创建不同的数据结构：如果 Key 的类型是 BinaryComparable （BytesWritable 和 Text ），并且 mapreduce.totalorderpartitioner.naturalorder 属性的指是 true ，则会构建trie 树，便于后面的查找；在计算机科学中，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点所对应的键才有相关的值。（摘自：）其他情况会构建一个 BinarySearchNode，用二分查找最后程序通过调用 getPartition 函数决定当前Key应该发送到哪个Reduce中：
public int getPartition(K key, V value, int numPartitions) {
return partitions.findPartition(key);
程序实现下面是使用 TotalOrderPartitioner 类进行全局排序的完整代码：
package com.iteblog.mapreduce.
import org.apache.hadoop.conf.C
import org.apache.hadoop.conf.C
import org.apache.hadoop.fs.P
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.J
import org.apache.hadoop.mapreduce.M
import org.apache.hadoop.mapreduce.R
import org.apache.hadoop.mapreduce.lib.input.FileInputF
import org.apache.hadoop.mapreduce.lib.input.KeyValueTextInputF
import org.apache.hadoop.mapreduce.lib.output.FileOutputF
import org.apache.hadoop.mapreduce.lib.partition.InputS
import org.apache.hadoop.mapreduce.lib.partition.TotalOrderP
import org.apache.hadoop.util.T
import org.apache.hadoop.util.ToolR
import java.io.IOE
public class TotalSortV3 extends Configured implements Tool {
static class SimpleMapper extends Mapper&Text, Text, Text, IntWritable& {
protected void map(Text key, Text value,
Context context) throws IOException, InterruptedException {
IntWritable intWritable = new IntWritable(Integer.parseInt(key.toString()));
context.write(key, intWritable);
static class SimpleReducer extends Reducer&Text, IntWritable, IntWritable, NullWritable& {
protected void reduce(Text key, Iterable&IntWritable& values,
Context context) throws IOException, InterruptedException {
for (IntWritable value : values)
context.write(value, NullWritable.get());
public static class KeyComparator extends WritableComparator {
protected KeyComparator() {
super(Text.class, true);
public int compare(WritableComparable w1, WritableComparable w2) {
int v1 = Integer.parseInt(w1.toString());
int v2 = Integer.parseInt(w2.toString());
return v1 - v2;
public int run(String[] args) throws Exception {
Configuration conf = getConf();
Job job = Job.getInstance(conf, &Total Order Sorting&);
job.setJarByClass(TotalSortV3.class);
job.setInputFormatClass(KeyValueTextInputFormat.class);
job.setSortComparatorClass(KeyComparator.class);
FileInputFormat.addInputPath(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
job.setNumReduceTasks(3);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(IntWritable.class);
job.setOutputValueClass(NullWritable.class);
TotalOrderPartitioner.setPartitionFile(job.getConfiguration(), new Path(args[2]));
InputSampler.Sampler&Text, Text& sampler = new InputSampler.RandomSampler&&(0.01, );
InputSampler.writePartitionFile(job, sampler);
job.setPartitionerClass(TotalOrderPartitioner.class);
job.setMapperClass(SimpleMapper.class);
job.setReducerClass(SimpleReducer.class);
job.setJobName(&iteblog&);
return job.waitForCompletion(true) ? 0 : 1;
public static void main(String[] args) throws Exception {
int exitCode = ToolRunner.run(new TotalSortV3(), args);
System.exit(exitCode);
[iteblog@ /home/iteblog]$ hadoop jar total-sort-0.1.jar com.iteblog.mapreduce.sort.TotalSortV3 /user/iteblog/input /user/iteblog/output /user/iteblog/partitions
##生成的 Key 分割点
[iteblog@ ~]$ hadoop fs -text /user/iteblog/partitions
10978 (null)
21611 (null)
[iteblog@ ~]$ hadoop fs -ls /user/iteblog/output/
Found 4 items
-rw-r--r--
3 iteblog supergroup
16:56 /user/iteblog/output/_SUCCESS
-rw-r--r--
3 iteblog supergroup
7-05-09 16:56 /user/iteblog/output/part-r-00000
-rw-r--r--
3 iteblog supergroup
7-05-09 16:56 /user/iteblog/output/part-r-00001
-rw-r--r--
3 iteblog supergroup
7-05-09 16:56 /user/iteblog/output/part-r-00002
[iteblog@ ~]$ hadoop fs -text /user/iteblog/output/part-r-00000 | head -n 10
[iteblog@ ~]$ hadoop fs -text /user/iteblog/output/part-r-00000 | tail -n 10
[iteblog@ ~]$ hadoop fs -text /user/iteblog/output/part-r-00001 | head -n 10
[iteblog@ ~]$ hadoop fs -text /user/iteblog/output/part-r-00001 | tail -n 10
[iteblog@ ~]$ hadoop fs -text /user/iteblog/output/part-r-00002 | head -n 10
[iteblog@ ~]$ hadoop fs -text /user/iteblog/output/part-r-00002 | tail -n 10
注意事项1、我们这里使用的 InputFormat 类是 KeyValueTextInputFormat ，而不是 TextInputFormat 。因为采样是对Key进行的，而 TextInputFormat 的 Key 是偏移量，这样的采样结果是无意义的；而如果使用 KeyValueTextInputFormat 作为输入类型，则可以将数据存放在 Key 中，从而得到正确的采样结果。2、我们 map 输出 Key 的类型是 Text ，这是没办法的，因为 InputSampler.writePartitionFile 函数实现的原因，必须要求 map 输入和输出 Key 的类型一致，否则会出现如下的异常：
Exception in thread &main& java.io.IOException: wrong key class: org.apache.hadoop.io.Text is not class org.apache.hadoop.io.LongWritable
at org.apache.hadoop.io.SequenceFile$RecordCompressWriter.append(SequenceFile.java:1380)
at com.iteblog.mapreduce.sort.TotalSortV3.writePartitionFile(TotalSortV3.java:106)
at com.iteblog.mapreduce.sort.TotalSortV3.run(TotalSortV3.java:47)
at org.apache.hadoop.util.ToolRunner.run(ToolRunner.java:70)
at org.apache.hadoop.util.ToolRunner.run(ToolRunner.java:84)
at com.iteblog.mapreduce.sort.TotalSortV3.main(TotalSortV3.java:73)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:606)
at org.apache.hadoop.util.RunJar.main(RunJar.java:212)
优秀人才不缺工作机会，只缺适合自己的好机会。但是他们往往没有精力从海量机会中找到最适合的那个。100offer 会对平台上的人才和企业进行严格筛选，让「最好的人才」和「最好的公司」相遇。注册 100offer，谈谈你对下一份工作的期待。一周内，收到 5-10 个满足你要求的好机会！本博客文章除特别声明，全部都是原创！禁止个人和公司转载本文、谢谢理解：本文链接:
下面文章您可能感兴趣相关文章推荐
做毕设用到Hadoop的全排序处理大数据，接触Hadoop已经2个月了，进展缓慢，深刻认识到进入到一个好的团队、共同研究是多么的重要，以此纪念我的大四一个人的毕设。废话不多说，我实现了整形和字符串型的...
(1)、关于mapreduce
mapreduce很适合数据之间相关性较低且数据量庞大的情况，map操作将原始数据经过特定操作打散后输出，作为中间结果，hadoop通过shuffle操作对中间结果排序...
要求首先按照第一列升序排列，当第一列相同时，第二列升序排列；不多说直接上代码
1、Mapper类的实现
* Mapper类的实现
* @author liuyazhuang
有人说mapreduce中不是有一个自动排序和分组（按key排序和分组）的嘛，我们为什么还需要自己写排序算法呢？
因为很多时候这种自动排序无法满足我们的需求，所以我们需要自定义排序算法！
需求1：...
Erlang的作者Joe Armstrong发表了一段代码来表示MapReduce版本的Erlang标准lists:map/2方法
Map阶段：在这个阶段，通过Map过程，将原始数据列表，处理成中间...
采样器是hadoop内自带的一个可以对目标文件部分数据进行提取的工具类,以方便我们对这些采样的数据做一些参考或者处理。hadoop提供了多种采样器供我们使用，以满足不同的需求。另外，采样器不同于普通m...
MapReduce实现全排序的方式
Ｈｉｖｅ编程指南，记录排序的规则：
Hive中的排序：
1.order by:
会对所有的数据进行一个全局排序，所有的数据都会通过一个Reduce进行处理，对于
大规模的数据会...
自己学习排序和二次排序的知识整理如下。
1.Hadoop的序列化格式介绍:Writable
2.Hadoop的key排序逻辑
4.如何自定义自己的Writable类型
5.如何实...
1、1TB（或1分钟）排序的冠军
作为分布式数据处理的框架，集群的数据处理能力究竟有多快？或许1TB排序可以作为衡量的标准之一。
1TB排序，就是对1TB（1024GB，大约100亿行数据...
他的最新文章
他的热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)MapReduce实现二次排序 - 简书
MapReduce实现二次排序
二次排序的需求说明
在mapreduce操作时，shuffle阶段会多次根据key值排序。但是在shuffle分组后，相同key值的values序列的顺序是不确定的(如下图)。如果想要此时value值也是排序好的，这种需求就是二次排序。
测试的文件数据
未经过二次排序的输出结果
第一种实现思路
直接在reduce端对分组后的values进行排序。
reduce关键代码
public void reduce(Text key, Iterable&IntWritable& values, Context context)
throws IOException, InterruptedException {
List&Integer& valuesList = new ArrayList&Integer&();
// 取出value
for(IntWritable value : values) {
valuesList.add(value.get());
// 进行排序
Collections.sort(valuesList);
for(Integer value : valuesList) {
context.write(key, new IntWritable(value));
很容易发现，这样把排序工作都放到reduce端完成，当values序列长度非常大的时候，会对CPU和内存造成极大的负载。
注意的地方（容易被“坑”）
在reduce端对values进行迭代的时候，不要直接直接存储value值或者key值，因为reduce方法会反复执行多次，但key和value相关的对象只有两个，reduce会反复重用这两个对象。需要用相应的数据类型.get()取出后再存储。
第二种实现思路
将map端输出的&key,value&中的key和value组合成一个新的key（称为newKey），value值不变。这里就变成&(key,value),value&，在针对newKey排序的时候，如果key相同，就再对value进行排序。
需要自定义的地方
自定义数据类型实现组合key
实现方式：继承WritableComparable
自定义partioner，形成newKey后保持分区规则任然按照key进行。保证不打乱原来的分区。
实现方式：继承partitioner
自动以分组，保持分组规则任然按照key进行。不打乱原来的分组
实现方式：继承RawComparator
自定义数据类型关键代码
import java.io.DataI
import java.io.DataO
import java.io.IOE
import org.apache.hadoop.io.WritableC
public class PairWritable implements WritableComparable&PairWritable& {
// 组合key
public PairWritable() {
public PairWritable(String first, int second) {
this.set(first, second);
* 方便设置字段
public void set(String first, int second) {
this.first =
this.second =
* 反序列化
public void readFields(DataInput arg0) throws IOException {
this.first = arg0.readUTF();
this.second = arg0.readInt();
public void write(DataOutput arg0) throws IOException {
arg0.writeUTF(first);
arg0.writeInt(second);
* 重写比较器
public int compareTo(PairWritable o) {
int comp = pareTo(o.first);
if(comp != 0) {
} else { // 若第一个字段相等，则比较第二个字段
return Integer.valueOf(this.second).compareTo(
Integer.valueOf(o.getSecond()));
public int getSecond() {
public void setSecond(int second) {
this.second =
public String getFirst() {
public void setFirst(String first) {
this.first =
自定义分区规则
import org.apache.hadoop.io.IntW
import org.apache.hadoop.mapreduce.P
public class SecondPartitioner extends Partitioner&PairWritable, IntWritable& {
public int getPartition(PairWritable key, IntWritable value, int numPartitions) {
* 默认的实现 (key.hashCode() & Integer.MAX_VALUE) % numPartitions
* 让key中first字段作为分区依据
return (key.getFirst().hashCode() & Integer.MAX_VALUE) % numP
自定义分组比较器
import org.apache.hadoop.io.RawC
import org.apache.hadoop.io.WritableC
public class SecondGroupComparator implements RawComparator&PairWritable& {
* 对象比较
public int compare(PairWritable o1, PairWritable o2) {
return o1.getFirst().compareTo(o2.getFirst());
* 字节比较
* arg0,arg3为要比较的两个字节数组
* arg1,arg2表示第一个字节数组要进行比较的收尾位置，arg4,arg5表示第二个
* 从第一个字节比到组合key中second的前一个字节，因为second为int型，所以长度为4
public int compare(byte[] arg0, int arg1, int arg2, byte[] arg3, int arg4, int arg5) {
pareBytes(arg0, 0, arg2-4, arg3, 0, arg5-4);
map关键代码
private PairWritable mapOutKey = new PairWritable();
private IntWritable mapOutValue = new IntWritable();
public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
String lineValue = value.toString();
String[] strs = lineValue.split("\t");
//设置组合key和value ==& &(key,value),value&
mapOutKey.set(strs[0], Integer.valueOf(strs[1]));
mapOutValue.set(Integer.valueOf(strs[1]));
context.write(mapOutKey, mapOutValue);
reduce关键代码
private Text outPutKey = new Text();
public void reduce(PairWritable key, Iterable&IntWritable& values, Context context)
throws IOException, InterruptedException {
//迭代输出
for(IntWritable value : values) {
outPutKey.set(key.getFirst());
context.write(outPutKey, value);
Why Stock Markets CrashThis page intentionally left blankWhy Stock Markets CrashCritical Events in ComplexFinancial SystemsD i d i e r S ...
Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智能路由，微代理，控制总线）。分布式系统的协调导致了样板模式, 使用Spring Cloud开发人员可以快速地支持实现这些模式的服务和应用程序。他们将在任何分布式...
摘自：http://staticor.io/post/hadoop/hadoop-definitive-guide-note#toc_7 Developing a MapReduce ApplicationRunning on a ClusterLaun...
1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语法，集合的语法，io的语法，虚拟机方面的语法。 1、一个&.java&源文件中是否可以包括多个类（不是内部类）？有什么限制？ 可以有多个类，但只能有一个publ...
cs.AI - 人工智能cs.CL - 计算与语言cs.CR - 加密与安全cs.CV - 机器视觉与模式识别cs.CY - 计算与社会cs.DC - 分布式、并行与集群计算cs.DS - 数据结构与算法cs.HC - 人机接口cs.IR - 信息检索cs.IT - 信息论...
离开你的第四天，依旧想念不停！
嘻嘻嘻，荷花可以说是我最喜欢画的花了! 因为简单又好看。 以下的各种姿态的荷花希望能带给初学者一些帮助吧！
去年公司改制，公司被北京的一家投资公司被收购。但是因为买卖之间没有商量好。双方都认为没有达到预期的效果。所以从去年被收购后开始，公司发生了太多的变故。 很多人都辞职了。辞职的还算好。就是苦了这些没辞职的，公司的这种人心惶惶让员工根本没有心思安心工作了。 话又说回来，有时候我...
现随着技术迅速发展，阿尔卑斯轻触开关在一些工业领域上需求也是比较多的，然而市面上有些阿尔卑斯轻触开关代理商为了竞争，把价格降低作为相关销售的手段，其实代理商他们之所以把价格降低，是在材料生产上做了手脚，并未按标准的材料去生产，导致阿尔卑斯轻触开关在使用上寿命上未到到规格书的...
十点半时 又累又困 本来在乐视看睡在我上铺的兄弟 好卡 结果不看了 QQ和微信也没有消息 开了明早八点的闹钟 关了台灯 睡觉 半个小时的时间 回忆了好多 所以醒来打字 二十一号到家 今天是十九号 下星期回校 最放不下谁 奶奶 回来的当天下午去看奶奶 当时在睡觉 醒来后走着摇...