数组求和（2）

(1)代码：

import java.util.Random;


public class max {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int n=1000;
        int C[]=new int[n];
        int D[]=new int[n];
        int a=0;
        int MAX=0;
        int b=0;
        long MAX1=0;
        long b1=0;
        double MAX2=0;
        double b2=0;
        int MAX3=0;
        int b3=0;
        int m1=2147483600;
        int m2=2147483647;
        Random rand=new Random();
        //随机产生数组C[N]
        for(int i=0;i<n;i++)
        {
            a=rand.nextInt(2);
            if(a==0)
            {
               C[i]=(int) (m1+Math.random()*( m2-m1+1));
            }
            else
            {
               C[i]=-(int) (m1+Math.random()*(m2-m1+1));
            }
        }
        //随机产生数组D[N]
        for(int i=0;i<n;i++)
        {
            a=rand.nextInt(2);
            if(a==0)
            {
               D[i]=(int) (Math.random()*(100));
            }
            else
            {
               D[i]=-(int) (Math.random()*(100));
            }
        }
        //计算int32 型溢出时的结果 
        b=C[0];
        MAX=b;
        for(int i=1;i<n;i++)
        {
            if(b<0)
            {
                b=C[i];
                if(MAX<b)
                {
                   MAX=b;
                }
            }
            else
            {
                if(C[i]<=0)
                {
                    if(MAX<b)
                    {
                        MAX=b;
                    }
                    b=b+C[i];
                }
                else
                { 
                    b=b+C[i];
                    if(MAX<b)
                    {
                        MAX=b;
                    }
                }
                
            }
        }
        //通过转化成double型计算
        b2=C[0];
        MAX2=b2;
        for(int i=1;i<n;i++)
        {
            if(b2<0)
            {
                b2=C[i];
                if(MAX2<b2)
                {
                   MAX2=b2;
                }
            }
            else
            {
                if(C[i]<=0)
                {
                    if(MAX2<b2)
                    {
                        MAX2=b2;
                    }
                    b2=b2+C[i];
                }
                else
                { 
                    b2=b2+C[i];
                    if(MAX2<b2)
                    {
                        MAX2=b2;
                    }
                }
                
            }
        }
        //通过转化成long型计算
        b1=Long.valueOf(C[0]);
        MAX1=b1;
        for(int i=1;i<n;i++)
        {
            if(b1<0)
            {
                b1=Long.valueOf(C[i]);
                if(MAX1<b1)
                {
                   MAX1=b1;
                }
            }
            else
            {
                if(C[i]<=0)
                {
                    if(MAX1<b1)
                    {
                        MAX1=b1;
                    }
                    b1=b1+Long.valueOf(C[i]);
                }
                else
                { 
                    b1=b1+Long.valueOf(C[i]);
                    if(MAX1<b1)
                    {
                        MAX1=b1;
                    }
                }
                
            }
        }
        //普通的程序处理1000个元素的结果
        b3=D[0];
        MAX3=b3;
        for(int i=1;i<n;i++)
        {
            if(b3<0)
            {
                b3=D[i];
                if(MAX3<b3)
                {
                   MAX3=b3;
                }
            }
            else
            {
                if(D[i]<=0)
                {
                    if(MAX3<b3)
                    {
                        MAX3=b3;
                    }
                    b3=b3+D[i];
                }
                else
                { 
                    b3=b3+D[i];
                    if(MAX3<b3)
                    {
                        MAX3=b3;
                    }
                }
                
            }
        }
        
        System.out.println("测试int31型 数组为：");
        for(int i=0;i<n;i++)
        {
            System.out.print(C[i]+" ");
            if((i+1)%100==0)
            {
                System.out.println();
            }
        }
        
        System.out.println("测试程序处理1000个元素 的数组为：");
        for(int i=0;i<n;i++)
        {
            System.out.print(D[i]+" ");
            if((i+1)%100==0)
            {
                System.out.println();
            }
        }
        
        System.out.println();
        
        System.out.println("数组元素为1000个，100以内随机取数：");
        System.out.println("最大数组和为："+MAX3);
        System.out.println();
        
        System.out.println("int32 类型溢出测试：");
        System.out.println("溢出显示的结果，最大数组和为："+MAX);
        System.out.println("解决以后的结果，最大数组和为：(1)求最大子数组和时用double型："+MAX2);
        System.out.println("                    (2)求最大子数组和时用long型："+MAX1);
        
        
    }
    
}

（2）截图：

（3）总结：

团队开发可以使解决问题的的方法更多，在本次开发中如果仅用int32，超出范围时显示的结果是int32范围的最大值。

解决：利用long型，或double型增大数值范围

（4）团队：