记一次深刻的教训-----将mat数据转化为SequenceFile

深刻的体会就是，“java.lang.NullPointer.Exception”就是空指针异常可能是由于数组部分元素未被初始化引起的。

1）使用jmatio将mat数据转化为SequenceFile形式的数据，代码如下：

/**
 * Created with IntelliJ IDEA.
 * User: hadoop
 * Date: 16-3-6
 * Time: 上午10:56
 * To change this template use File | Settings | File Templates.
 */
import com.jmatio.io.MatFileReader;
import com.jmatio.types.*;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.*;
import java.net.URI;
import org.apache.hadoop.mapreduce.*;
public class mat2Seq {
public static void main(String[] args) throws IOException {
    writeMat2Seq("data/100_100/F100.mat","SeqOutput/F");
    writeMat2Seq("data/100_100/b100.mat","SeqOutput/b");
    writeMat2Seq("data/100_100/d100.mat","SeqOutput/d");
    writeMat2Seq("data/100_100/s100.mat","SeqOutput/s");
    writeMat2Seq("data/100_100/u100.mat","SeqOutput/u");
}

public static void writeMat2Seq(String matPath,String SeqOutput) throws IOException {
        MatFileReader reader=new MatFileReader(matPath);
        MLArray mlArray=reader.getMLArray("a");
        MLDouble doubleValue=(MLDouble)mlArray;
        double[][] matrix=doubleValue.getArray();
        Configuration conf =new Configuration();
        FileSystem fs=FileSystem.get(URI.create(SeqOutput),conf);
        IntWritable key=new IntWritable();
        DoubleArrayWritable value=new DoubleArrayWritable();
        SequenceFile.Writer writer=null;
        try {
            writer=SequenceFile.createWriter(fs,conf,new Path(SeqOutput),key.getClass(),
                    value.getClass());
            if (matPath.endsWith("F100.mat")){    //左矩阵F依次将行存储到Seq
                DoubleWritable[] rowVector=new DoubleWritable[matrix.length];
                for (int i=0;i<matrix.length;++i){
                    for (int j=0;j<matrix[0].length;++j){
                       rowVector[j]=new DoubleWritable(0);
                       rowVector[j].set(matrix[i][j]);
                    }
                    value.set(rowVector);
                    key.set(i);
                    writer.append(key,value);
                }
                writer.close();
            }
            else{          //其他右矩阵依次将列存储到Seq中
                DoubleWritable[] columnVector=new DoubleWritable[matrix[0].length];
                for (int i=0;i<matrix[0].length;++i){
                    for (int j=0;j<matrix.length;++j){
                        columnVector[j]=new DoubleWritable(0);
                        columnVector[j].set(matrix[j][i]);
                    }
                    value.set(columnVector);
                    key.set(i);
                    writer.append(key,value);
                }
                writer.close();

            }
        }
        finally {
        }
    System.out.println(matPath+"write done!");
    }
}
class DoubleArrayWritable extends ArrayWritable {
    public DoubleArrayWritable(){
        super(DoubleWritable.class);
    }
    public String toString(){
        StringBuilder sb=new StringBuilder();
        for (Writable val:get()){
            DoubleWritable doubleWritable=(DoubleWritable)val;
            sb.append(doubleWritable.get());
            sb.append(",");
        }
        sb.deleteCharAt(sb.length()-1);
        return sb.toString();
    }
}

以上使用的.mat文件，程序都可以好好的运行。但是当把文件换成一个B1k2k，也就是一个1000*2000的矩阵文件时，就报空指针的异常，“java.lang.NullPointerException”，具体如下：

 

 提示是在ArrayWritable.write()方法中出现空指针的异常，就开始怀疑是ArrayWritable这个类没写好(也就是怀疑人家有bug，然后就下了hadoop2.6.4，还是不行)，然后一路追查，到最后ArrayWritable的write()方法最终调用了BufferedOutputStream.write(),然后就开始是open-jdk的不兼容了，然后就重装了sun JDK。还是不行，然后就把java的io包里的.java源码拷贝到工程里，想着单步调试到BufferedOutputStream.write()，看看究竟发生了什么，怎奈jmatio需要用到io包，我又不行重新编译，所以就想先把.mat转化为.txt文件,但是呢，没成功，因为虚拟机磁盘空间不够了，没法了，想想是不是机子环境的问题呢(哈哈哈，想象力太好)，就传给谷总试试看能不能运行，谷总说你确定不是算法问题？答：不该呀。呵呵呵，结果谷总发来了两张图片，如下：

 

 

至此，终于找到了原因，就是代码有问题。columnVector数组是用来存储矩阵的一列，数组长度矩阵的行数，但是原先的代码里却将数组长度定义为矩阵的列数。

 DoubleWritable[] columnVector=new DoubleWritable[matrix[0].length];
 for (int i=0;i<matrix[0].length;++i){
 for (int j=0;j<matrix.length;++j){
       columnVector[j]=new DoubleWritable(0);
       columnVector[j].set(matrix[j][i]);
}
value.set(columnVector);
key.set(i);
writer.append(key,value);
}

这就解释了，为什么1k*1100的矩阵转化时会提示空指针异常，按照上述对columnVector的定义，这个列向量数组的长度是1100，但是在接下来给这个向量赋值时，是由矩阵的行数来控制，也就是说在赋值时只是对columnVector复制到第1000个元素，剩下的100个元素是空(如果是系统的基本类型，如int double，编译器会将其置为0，不过DoubleWritable不是基本类型)，也就是“null”，所以在接下来使用writer.append(key,vlaue)调用输出流写出的时候，自然会抛出“java.lang.NullPointerException”异常。经过修改的代码如下：

/**
 * Created with IntelliJ IDEA.
 * User: hadoop
 * Date: 16-3-6
 * Time: 上午10:56
 * To change this template use File | Settings | File Templates.
 */
//package java.io;
import com.jmatio.io.MatFileReader;
import com.jmatio.types.*;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.*;
public class mat2Seq {
    public static void main(String[] args) throws IOException {
        writeMat2Seq("data/1k_1k/F1k1k.mat","SeqOutput/F1k1k");
        writeMat2Seq("data/100_100/b100.mat","SeqOutput/b100");
        writeMat2Seq("data/1k1100/mat1k1100.mat","SeqOutput/test1k1100");
        writeMat2Seq("data/B1k2w.mat","SeqOutput/1k2w");

        //writeMat2Seq("data/1k_2w/B1k2w.mat","SeqOutput5/B1k2w");
    }

    public static void writeMat2Seq(String matPath,String SeqOutput) throws IOException {
        MatFileReader reader=new MatFileReader(matPath);
        MLArray mlArray=reader.getMLArray("a");
        MLDouble doubleValue=(MLDouble)mlArray;
        double[][] matrix=doubleValue.getArray();
        Configuration conf =new Configuration();
        //FileSystem fs=FileSystem.get(URI.create(SeqOutput),conf);
        FileSystem fs=FileSystem.get(conf);
        Path path=new Path(SeqOutput);
        //FSDataOutputStream outputStream=fs.create(path);
        IntWritable key=new IntWritable();
        DoubleArrayWritable value=new DoubleArrayWritable();
        SequenceFile.Writer writer=null;
        try {
            writer=SequenceFile.createWriter(fs,conf,path,key.getClass(),value.getClass());

            // SequenceFile.Writer.Option
            if (matPath.endsWith("F1k.mat")){    //左矩阵F依次将行存储到Seq
                DoubleWritable[] rowVector=new DoubleWritable[matrix[0].length];
                for (int i=0;i<matrix.length;++i){
                    for (int j=0;j<matrix[0].length;++j){
                        rowVector[j]=new DoubleWritable(0);
                        rowVector[j].set(matrix[i][j]);
                    }
                    value.set(rowVector);
                    key.set(i);
                    writer.append(key,value);
                }
                writer.close();
                //outputStream.close();
                fs.close();
            }
            else{          //其他右矩阵依次将列存储到Seq中
                //DoubleWritable[] columnVector=new DoubleWritable[matrix[0].length];
                DoubleWritable[] columnVector=new DoubleWritable[matrix.length];
                for (int i=0;i<matrix[0].length;++i){
                    for (int j=0;j<matrix.length;++j){
                        columnVector[j]=new DoubleWritable(0);
                        columnVector[j].set(matrix[j][i]);
                    }
                    value.set(columnVector);
                    key.set(i);
                    writer.append(key,value);
                }
                writer.close();
                //outputStream.close();
                fs.close();

            }
        }
        finally {
        }
        System.out.println(matPath+"write done!");
    }
}
class DoubleArrayWritable extends ArrayWritable {
    public DoubleArrayWritable(){
        super(DoubleWritable.class);
    }
    /*
    public String toString(){
        StringBuilder sb=new StringBuilder();
        for (Writable val:get()){
            DoubleWritable doubleWritable=(DoubleWritable)val;
            sb.append(doubleWritable.get());
            sb.append(",");
        }
        sb.deleteCharAt(sb.length()-1);
        return sb.toString();
    }
    */
}

 另外，就是把DoubleArrayWritable的toString()方法注释掉是有原因的，如果使用这个新定义的toString()方法，写入SequenceFile中的value形式就是0.344,0.435......,这种矩阵形式(使用hadoop fs -text)，形式一目了然，但是文件写入速度慢(B1k2w文件需要两分钟才可以完成)。如果使用Object提供的toString()方法的话，写入的value形式就是DoubleArrayWritable@34d79f形式，看着不直观，如果要查看value的值还必须使用程序反序列化，但是这种方法写入的内容很少，文件的写入速度很快(B1k2w文件只需要1~2s就可完成)。所以还是不要重载toString()方法。