二维数组求其矩形最大子数组和以及单元测试/代码覆盖率

题目：二维数组求其矩形最大子数组和以及单元测试/代码覆盖率

要求：

1，以指定格式的文本文件形式输入数组。

2，数组由一维变为二维。

3，给出单元测试/代码覆盖率的最终覆盖率的报告

即是要求输入：一个二维数组和它的大小；输出：这个二维数组中最大的矩形子数组的和

例如：

输入的二维数组	输出结果
1,2,3,4,
-1,7,8,-4	27
1,2,2,2



-1,-2,-3,-4,
-1,-7,-8,-4,	-1
-1,-2,-2,-2

思路：

首先解决将信息写入txt文件中。
在读取txt文件中信息。
将读取的信息进行分割处理，得到行数和列数，以及需要处理的二维数据
将二位数组的数据进行处理得到最大和。

一.代码实现

1，java语言代码如下：

`package cm1;

import javax.annotation.processing.FilerException;
import java.io.*;
import java.nio.Buffer;
import java.util.Arrays;

public class str1 {
//处理矩阵
public int maxSubsequence(int[] var1) {
if (var1.length == 0) {
return 0;
} else {
int var2 = -2147483648;
int[] var3 = new int[var1.length];
var3[0] = var1[0];

        for(int var4 = 1; var4 < var1.length; ++var4) {
            var3[var4] = var3[var4 - 1] > 0 ? var3[var4 - 1] + var1[var4] : var1[var4];
            if (var2 < var3[var4]) {
                var2 = var3[var4];
            }
        }

        return var2;
    }
}
public int subMaxMatrix(int[][] matrix) {

    int[][] total = matrix;
    for (int i = 1; i < matrix.length; i++) {
        for (int j = 0; j < matrix[0].length; j++) {
            total[i][j] += total[i - 1][j];
        }
    }
    int maximum = Integer.MIN_VALUE;
    for (int i = 0; i < matrix.length; i++) {
        for (int j = i; j < matrix.length; j++) {

            int[] result = new int[matrix[0].length];
            for (int f = 0; f < matrix[0].length; f++) {
                if (i == 0) {
                    result[f] = total[j][f];
                } else {
                    result[f] = total[j][f] - total[i - 1][f];
                }
            }
            int maximal = maxSubsequence(result);

            if (maximal > maximum) {
                maximum = maximal;
            }
        }
    }
    return maximum;
}

//写入文本内容，并且在读取文本中内容,获取二维数据的数据
public int File(){
    //创建信息文本的文件
    File file = new File("D:/A", "a.txt");
    //创建字节IO流
    FileOutputStream fos = null;
    FileInputStream fis;
    //创建字符流
    InputStreamReader isr;
    //创建缓存流
    BufferedReader buf = null;
    String str;
    int row;//行
    int line;//列
    int List[][] = null;//存放写入的二位数组的数据

    //写入信息
    try {
        //创建输出的字节流对象
        fos = new FileOutputStream(file);
        //创建缓存输入流
        buf = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入数据到文件中");
        //输入行号以逗号结尾（如：3，）
        str = buf.readLine();
        //将行号信息写入文本
        fos.write(str.getBytes());
        //将读取控制台输入字符串，并将字符串进行切割，后将字符转int类型数据
        row = Integer.parseInt(str.split(",")[0]);

        //输入列号以逗号结尾（如：4，）
        str = buf.readLine();
        //将读取控制台输入字符串，并将字符串进行切割，后将字符转int类型数据
        line = Integer.parseInt(str.split(",")[0]);
        //将列号信息写入文本
        fos.write("\n".getBytes());
        fos.write(str.getBytes());


        //在控制台显示输入的数据
        System.out.println(row);
        System.out.println(line);

        //创建存放输入二位数组的对象
        List = new int[row][line];

        //将从控制台输入数据，并且写入txt文件中
        int row_count = 0;//要输入数据的总行数
        while (row_count < row) {
            str = buf.readLine();
            //添加换行符
            fos.write("\n".getBytes());
            //将矩阵信息写入文本
            fos.write(str.getBytes());
            //在控制台显示输入的数据
            System.out.println(str);
            row_count++;
        }

        //读取信息
        //创建输入的字符流对象
        // 从文件系统中的某个文件中获取字节
        fis = new FileInputStream(file);
        //字符流转字节流
        isr = new InputStreamReader(fis);
        // 从字符输入流中读取文件中的内容,封装了一个new InputStreamReader的对象
        buf = new BufferedReader(isr);
        String content = null;
        int n1 = 0;
        System.out.println("####################\n读取文件信息");
        //循环来读取该文件中的数据
        while ((content = buf.readLine()) != null) {
            if (n1 == 0) {
                //行
                row = Integer.parseInt(content.split(",")[0]);
            } else if (n1 == 1) {
                //列
                line = Integer.parseInt(content.split(",")[0]);
                System.out.println("line" + line);
            } else {
                //存放写入的二位数组的数据
                for (int n2 = 0; n2 < line; n2++) {
                    //将字符串以逗号进行切割，并且转换为int类型
                    List[n1 - 2][n2] = Integer.parseInt(content.split(",")[n2]);
                    System.out.println(List[n1 - 2][n2]);
                }
            }
            n1++;
        }
        System.out.println("#####################\n");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //关闭文件
        if (fos != null) {
            try {
                fos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (buf != null) {
            try {
                buf.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    //遍历输出数组数据
    if (List != null) {
        for (int[] i : List) {
            for (int j : i) {
                System.out.println(j);
            }
        }
    }
    int max=subMaxMatrix(List);
    return(max);
}

public static void main(String[] args) {
    str1 a=new str1();
    int p=a.File();
    System.out.println("最大相邻矩阵和为：");
    System.out.println(p);

}

}
`

2，运行结果：

二. 单元测试

1,代码如下：建立一个测试类，这里只测试核心代码

`
package cm1;
public class Test {
public int maxSubsequence(int[] var1) {
if (var1.length == 0) {
return 0;
} else {
int var2 = -2147483648;
int[] var3 = new int[var1.length];
var3[0] = var1[0];

        for(int var4 = 1; var4 < var1.length; ++var4) {
            var3[var4] = var3[var4 - 1] > 0 ? var3[var4 - 1] + var1[var4] : var1[var4];
            if (var2 < var3[var4]) {
                var2 = var3[var4];
            }
        }

        return var2;
    }
}
public int subMaxMatrix(int[][] matrix) {

    int[][] total = matrix;
    for (int i = 1; i < matrix.length; i++) {
        for (int j = 0; j < matrix[0].length; j++) {
            total[i][j] += total[i - 1][j];
        }
    }

    int maximum = Integer.MIN_VALUE;
    for (int i = 0; i < matrix.length; i++) {
        for (int j = i; j < matrix.length; j++) {

            int[] result = new int[matrix[0].length];
            for (int f = 0; f < matrix[0].length; f++) {
                if (i == 0) {
                    result[f] = total[j][f];
                } else {
                    result[f] = total[j][f] - total[i - 1][f];
                }
            }
            int maximal = maxSubsequence(result);

            if (maximal > maximum) {
                maximum = maximal;
            }
        }
    }

    return maximum;
}

@org.junit.Test
public void test(){
    Test t = new Test();
    int[][] m = new int[][]{
            {1,-2,3},
            {3,4,-5},
            {1,2,-3},
            {-1,2,3},
    };
    int a=t.subMaxMatrix(m);
    System.out.println(a);
}

}
`