今日总结：返回一个整数数组中最大子数组的和三阶段总结

第一阶段：

源代码：

package test;
import java.util.*;
public class Ssss {


     public static int Largest(int list[], int length){
        int i,max=list[0];
        if(list!=null) {
            
        
        for(i=0;i<length;i++)
        {
            if(list[i]>max)
            {
                max=list[i];
            }
        }}
        return max;
    }
        public static void main(String[] args) {
            
            Scanner sc=new Scanner(System.in);
            
            int i,j,k=0,z=0,flag=0,max=0;
            int sum=sc.nextInt();
            int[] array=new int[sum];
            
            for(i=0;i<sum;i++)
            {
                array[i]=sc.nextInt();
            }
            max=array[0];
            for(i=0;i<sum;i++)
            {
                
                for(j=i;j<sum;j++)
                {
                    k+=array[j];
                    if(k>max)
                    {
                        flag=1;
                        max=k;
                    }
                }
                k=0;
            }
            System.out.println(Largest(array,sum));
            System.out.println(max);
        }

    }

第一次运行结果：

第二次运动结果：

很明显，当数过于大的时候（超过int的临界值），程序就会报错。由于这是第一个阶段，所以并没有深究。

设计思路：运用双循环进行最基础的计算方法，外循环控制内循环的初始位置，并且是依次前进，内循环从设定的初始位置开始向后加和，最终找到最大的子数组的和。虽然过程繁杂，但思路很简单，保证了每一个子数组的参与。

第二阶段：（2022.3.18）

源代码：

package test;
import java.math.BigInteger;
import java.util.*;
import java.io.*;
public class Test {
    public static void main(String[] args) {
        
        int i=0,j=0,p=0;
        BigInteger max=new BigInteger("0");
        BigInteger k=new BigInteger("0");
        try{

        BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("zzz.txt"),"UTF-8"));
        String cols="0";
        String element="0";
        
        int flag=0;
        while(i!=3)
        {
            
            if(i==0)
            {
                i++;
                br.readLine();
                continue;
            }
            if(i==1)
            {
                cols=br.readLine();
            }
            if(i==2)
            {
                element=br.readLine();
            }
            i++;
        }
        String regEx="[,]";
        String aa="";
        String newString1=cols.replaceAll(regEx,aa);
        
        flag=Integer.valueOf(newString1);
        
        String[] array = new String[flag];
        
        String[] strArr = element.split(",");
        
        BigInteger[] a=new BigInteger[flag];
        for(i=0;i<strArr.length;i++) {
            a[i]=new BigInteger(strArr[i]);
        }
        max=a[0];
        for(i=0;i<flag;i++)
        {
            
            for(j=i;j<flag;j++)
            {
                k=k.add(a[j]);
                if(k.compareTo(max)==1)
                {
                    p=1;
                    max=k;
                }
            }
            k=k.subtract(k);
        }
        System.out.println(max);
        
    }catch(IOException e) {
        System.out.println("文件参数有错");
        System.exit(0);
    }catch (Exception e) { 
        
        System.out.println("文件参数有错");
        System.exit(0);
 }

    }
}

zzz.txt文件内容：

运行结果：

zzz.txt文件内容：

运行结果：

设计思路：（显然，本次阶段的编写解决了大数以及文件参数错误不会异常终止的问题），1.读取文件操作使用的是FileInputStream,

FileInputStream 是 Java 语言中抽象类 InputStream 用来具体实现类的创建对象。FileInputStream 流被称为文件字节输入流，意思指对文件数据以字节的形式进行读取操作如读取图片视频等。

为了防止出现乱码的问题，这里将字节流转换（InputStreamReader）成字符流存入缓冲流（BufferReader）中。（----------详情请阅前几篇随笔）

然后使用readLine（）读取文件中每一行内容，利用正则和split切割的方法解决“，”问题，求值方法同第一阶段。

2.使用BigInteger类解决大数问题

3.try{}catch（Exception e）{} 解决文件参数错误问题。

第三阶段：（2022.3.19）

package test;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.math.BigInteger;
import java.io.InputStreamReader;
import java.util.*;

public class Twice1 {
    public static void main(String[] args) {
        try {
            BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("nnn.txt"),"UTF-8"));
            int row=Integer.valueOf(br.readLine());
            int col=Integer.valueOf(br.readLine());
            int q,k,count=0,j;
            BigInteger big;
            BigInteger[][] brr = new BigInteger[row][col];
            String[][] arr = new String[row][col];
            String[]   qrr = null;
            String element="0";
            while((element=br.readLine())!=null)
            {
                qrr = element.split(",");
                
                
                for(q=0;q<qrr.length;q++)
                {
                    arr[count][q] = qrr[q];        //存入二维字符串数组
                }
                count++;
            }
            
            for(k=0;k<row;k++)
            {
                for(j=0;j<col;j++)
                {
                    brr[k][j] = new BigInteger(arr[k][j]);  //字符串转换大整数
                }
            }
            
            big=SeekMax(brr,row,col);
            System.out.println(big);
                
        }catch(Exception e) {
            System.out.println("文件参数有错");
        }
    }
    public static BigInteger SeekMax(BigInteger[][] arr,int row,int col) {
        int i,j,k,rowend=0,colend=0,il,jl;
        BigInteger temp=new BigInteger("0");
        BigInteger max=arr[0][0];
        for(colend=0;colend<col;colend++)     //局限二维数组的列
        {
            for(rowend=0;rowend<row;rowend++) {    //局限二维数组的行
                for(j=0;j<=colend;j++)            
                {
                    for(i=0;i<=rowend;i++)
                    {
                        for(jl=j;jl<=colend;jl++)   /*在小的子数组中求和
                        {
                            for(il=i;il<=rowend;il++)
                            {
                                temp=temp.add(arr[il][jl]);
                                
                                if(temp.compareTo(max)==1&&il==rowend)   //保证是子数组是矩阵
                                {
                                    max=temp;
                                }
                                
                            }
                        }                            */
                        
                        temp=temp.subtract(temp);
                    }
                }
            }
            
        }
        return max;
    }

}