（1）DEFLATE

（2）Gzip

（3）Bzip2

• Bzip2 是 Julian Seward 开发并按照自由软件/开源软件协议发布的数据压缩算法及程序。
• Seward 在 1996 年 7 月第一次公开发布了 Bzip2 0.15 版，在随后几年中这个压缩工具稳定性得到改善并且日渐流行，Seward 在 2000 年晚些时候发布了 1.0 版。
• Bzip2 比传统的 Gzip 的压缩效率更高，但是它的压缩速度较慢。

（4）Lz4

• Lz4 是一种无损数据压缩算法，着重于压缩和解压缩速度。

（5）Lzo

• Lzo 是致力于解压速度的一种数据压缩算法，Lzo 是 Lempel-Ziv-Oberhumer 的缩写，这个算法是无损算法。

（6）Snappy

• Snappy（以前称 Zippy）是 Google 基于 LZ77 的思路用 C++ 语言编写的快速数据压缩与解压程序库，并在 2011 年开源。
• 它的目标并非最大压缩率或与其他压缩程序库的兼容性，而是非常高的速度和合理的压缩率。

注意：DEFLATE 压缩格式底层使用的是 zlib，Gzip 是对 DEFLATE 进行了封装，所以 Hadoop 只有 lzo 没有集成，其他的压缩格式都是可以正常使用的。

（1）下面是压缩格式的文件扩展名、是否可切分、压缩比、压缩速度和解压速度这几项进行对比：

注意：这个表中所说的是否可切分是针对 TextFile 文件，也就是普通文本文件而言的。因为针对某一些特殊的文件格式，结合不可切分的压缩格式之后，依然是可以支持切分的，这是由于这些特殊文件格式自身的特性决定的，和压缩格式的特性没有关系。

（5）针对压缩速度和解压速度：Bzip2 的压缩速度和解压速度都是最低的，其实也是可以理解的，想要压缩效果好，对应的压缩和解压肯定会多消耗一些时间。

3，压缩位置

4，各种压缩格式压缩后的数据文件大小比较

二、数据压缩样例

1，生成测试数据

public class GenerateData {
    public static void main(String[] args) throws Exception{
        String fileName = "D:\\words.dat";
        System.out.println("start: 开始生成200M文件->"+fileName);
        BufferedWriter bfw = new BufferedWriter(new FileWriter(fileName));
        int num = 0;
        while(num<7080000){
            bfw.write("hello_"+num+" hangge_"+num);
            bfw.newLine();
            num ++;
            if(num%10000==0){
                bfw.flush();
            }
        }
        System.out.println("end: 200M文件已生成");
    }
}

（2）运行后会生成一个 200MB 的文件，文件内容如下。每个单词都是唯一的，没有重复。

2，执行未压缩的任务

public class WordCountJob {
  /**
   * 创建自定义mapper类
   */
  public static class MyMapper extends Mapper<LongWritable,Text,Text,LongWritable>{
    /**
     * 需要实现map函数
     * 这个map函数就是可以接收k1,v1,产生k2,v2
     * @param k1
     * @param v1
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable k1, Text v1, Context context)
            throws IOException, InterruptedException {
      // k1代表的是每一行的行首偏移量，v1代表的是每一行内容
      // 对获取到的每一行数据进行切割，把单词切割出来
      String[] words = v1.toString().split(" ");

      // 迭代切割出来的单词数据
      for(String word:words){
        // 把迭代出来的单词封装成<k2,v2>的形式
        Text k2 = new Text(word);
        LongWritable v2 = new LongWritable(1L);
        // 输出k2,v2
        context.write(k2,v2);
      }
    }
  }

  /**
   * 创建自定义的reducer类
   */
  public static class MyReducer extends Reducer<Text,LongWritable,Text,LongWritable> {
    /**
     * 针对v2s的数据进行累加求和
     * @param k2
     * @param v2s
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(Text k2, Iterable<LongWritable> v2s, Context context)
            throws IOException, InterruptedException {
      //v2s {1,1,1,1}
      //创建一个sum变量，保存v2s的和
      long sum = 0L;
      for(LongWritable v2:v2s){
        sum += v2.get();
      }
      //组装k3,v3
      Text k3 = k2;
      LongWritable v3 = new LongWritable(sum);

      //输出结果
      context.write(k3,v3);
    }
  }

  /**
   * 组装job = map + reduce
   */
  public static void main(String[] args){
    try{
      //指定Job需要的配置参数
      Configuration conf = new Configuration();
      //解析命令行中通过-D传递过来的参数，添加到conf中
      String[] remainingArgs = new GenericOptionsParser(conf, args).getRemainingArgs();

      //创建一个Job
      Job job = Job.getInstance(conf);

      // 注意：这一行必须设置，否则在集群中执行的是找不到WordCountJob这个类
      job.setJarByClass(WordCountJob.class);

      // 指定输入路径
      FileInputFormat.setInputPaths(job,new Path(remainingArgs[0]));
      // 指定输出路径
      FileOutputFormat.setOutputPath(job,new Path(remainingArgs[1]));

      // 指定map相关的代码
      job.setMapperClass(MyMapper.class);
      // 指定k2的类型
      job.setMapOutputKeyClass(Text.class);
      // 指定v2的类型
      job.setMapOutputValueClass(LongWritable.class);

      // 指定reduce相关的代码
      job.setReducerClass(MyReducer.class);
      // 指定k3的类型
      job.setOutputKeyClass(Text.class);
      // 指定v3的类型
      job.setOutputValueClass(LongWritable.class);

      // 提交job
      job.waitForCompletion(true);
    }catch (Exception e){
      e.printStackTrace();
    }
  }
}

（2）将任务打包成 Jar 包上传至 Hadoop 集群的任意一台机器上，并且执行如下命令向集群提交 Jar 包：

hadoop jar hadoop-0.0.1-SNAPSHOT-jar-with-dependencies.jar WordCountJob /words.dat /out/no_compress

（3）我们查看任务执行时的日志信息，主要查看 number of splits 后面的值，这个值表示针对任务的输入数据会产生几个 Split。这里显示的是 2，说明这个 200M 的文件会产生 2 个 Split，最终也只会产生 2 个 map 任务。

hadoop jar hadoop-0.0.1-SNAPSHOT-jar-with-dependencies.jar WordCountJob -Dmapreduce.output.fileoutputformat.compress=true -Dmapreduce.output.fileoutputformat.compress.codec=org.apache.hadoop.io.compress.DeflateCodec /words.dat /out/compress_deflate

（2）任务执行完毕后，查看最终结果文件只有 32MB：

4，执行 Gzip 压缩格式的任务

hadoop jar hadoop-0.0.1-SNAPSHOT-jar-with-dependencies.jar WordCountJob -Dmapreduce.output.fileoutputformat.compress=true -Dmapreduce.output.fileoutputformat.compress.codec=org.apache.hadoop.io.compress.GzipCodec /words.dat /out/compress_gzip

（2）任务执行完毕后，查看最终结果文件同样只有 32MB：

5，执行 Bzip2 压缩格式的任务

hadoop jar hadoop-0.0.1-SNAPSHOT-jar-with-dependencies.jar WordCountJob -Dmapreduce.output.fileoutputformat.compress=true -Dmapreduce.output.fileoutputformat.compress.codec=org.apache.hadoop.io.compress.BZip2Codec /words.dat /out/compress_bzip2

（2）任务执行完毕后，查看最终结果文件同样只有 18MB：

6，执行 Snappy 压缩格式的任务

hadoop jar hadoop-0.0.1-SNAPSHOT-jar-with-dependencies.jar WordCountJob -Dmapreduce.output.fileoutputformat.compress=true -Dmapreduce.output.fileoutputformat.compress.codec=org.apache.hadoop.io.compress.SnappyCodec /words.dat /out/compress_snappy

（2）任务执行完毕后，查看最终结果文件为 61MB：

7，执行 Lz4 压缩格式的任务

hadoop jar hadoop-0.0.1-SNAPSHOT-jar-with-dependencies.jar WordCountJob -Dmapreduce.output.fileoutputformat.compress=true -Dmapreduce.output.fileoutputformat.compress.codec=org.apache.hadoop.io.compress.Lz4Codec /words.dat /out/compress_lz4

（2）任务执行完毕后，查看最终结果文件只有 53MB：
（4）解决办法是访问 Maven 中央仓库（点击访问），将 LZ4 的 jar 包下载下来。