一个道说难不难，说简单不简单的Java编程题

循环数组 大于0的相加，看题目是这意思吧。
你上面举例的子数组可以是{10,200}，应该是210才对。

不要结果。要算法，要实现过程 

你理解错了 因为10的下标是0 ，200的下标是2 所以 他俩是不能够构成子数组的

8，-3，24 => {1,2,0,5,-1,-2,4,8,12}

遍历数组,相加,遇到<0的跳过,从下一个重新开始相加,最后比较这些和值.

import java.util.ArrayList;
import java.util.List;

public class test {

	/**
	 * @param args
	 */
	@SuppressWarnings("null")
	public static void main(String[] args) {
		//将外部参数转换到List内
		ArrayList<Integer> al = new ArrayList<Integer>();
		ArrayList<List> as = new ArrayList<List>();
		int l=args.length;
		for(int i=0;i<l;i++){
			al.add(Integer.parseInt(args[i]));
		}
		System.out.println("The input numbers are:");
		System.out.println(al.toString());
		
		//取出所有子数组
		for(int i=1;i<l;i++){
			for(int j=0;j<=l-i;j++){
			    as.add(al.subList(j, j+i));
			}
		}
		
		//找出和最大的List
		int index=0;
		int max=Sum(as.get(index));
		int length=as.size();
		for(int i=1;i<length;i++){
			int s=Sum(as.get(i));
			if(max < s){
				index = i;
				max = s;
			}
		}
		//打印出所有子数组及其和
		System.out.println("All sub arrays and it's sum are:");
		for(int i=0;i<as.size();i++){
			System.out.println(as.get(i).toString()+"\t"+Sum(as.get(i)));
		}
		//打印出和最大的子数组和它的和
		System.out.println("The max sub array is the "+index+"st(from index 0):");
		System.out.println(as.get(index).toString());
		System.out.println("It's sum is:");
		System.out.println(max);
	}
	
	private static int Sum(List<Integer> a){
		int s=0;
		for(int i=0;i<a.size();i++){
			s += a.get(i);
		}
		return s;
	}

}

测试

java test 1 2 3 1
*******out put*******
The input numbers are:
[1, 2, 3, 1]
All sub arrays and it's sum are:
[1]	1
[2]	2
[3]	3
[1]	1
[1, 2]	3
[2, 3]	5
[3, 1]	4
[1, 2, 3]	6
[2, 3, 1]	6
The max sub array is the 7st(from index 0):
[1, 2, 3]
It's sum is:
6

遇到<0就跳过吗?
如果前面一个100，后面跟个-1,看下也知道该加上的

import java.util.ArrayList;
import java.util.List;

public class FindTheMaxestArray {

/**
* @param args
*/
public static void main(String[] args) {
int[] originalArray = { 1, 2, 0, -2, 2, 1, -8, 9 };
System.out.print("原数组: ");
printArray(originalArray);

int[] maxestSubArray = getTheMaxestArray(originalArray);
System.out.print("最大子数组: ");
printArray(maxestSubArray);
}

/**
* 找出总和值最大的子数组
*
* @param parentArray
* @return
*/
public static int[] getTheMaxestArray(int[] parentArray) {
if (parentArray == null) {
throw new NullPointerException("array is null");
}

List<Integer> resultList = new ArrayList<Integer>();

if (parentArray.length == 1) {
resultList.add(parentArray[0]);
} else {
// 找出第一个元素，分为两种情况，第一个元素为子数组的元素以及第一个元素不是子数组的元素
int firstElement = parentArray[0];
int firstElementSum = firstElement;
int end = 1;

int tempSum;
for (int i = 2; i <= parentArray.length; i++) {
tempSum = sumArray(parentArray, 0, i);
if (tempSum > firstElementSum) {
firstElementSum = tempSum;
end = i;
}
}

// 找出去除第一个元素数组的最大子数组
int[] removeFirstElementArray = subArray(parentArray, 1,
parentArray.length);
int[] removeFirstElementMaxestArray = getTheMaxestArray(removeFirstElementArray);
int removeFirstElementSum = sumArray(removeFirstElementMaxestArray,
0, removeFirstElementMaxestArray.length);

// 比较包含第一个元素和不包含第一个元素的情况
int[] maxestSubArray;
if (firstElementSum >= removeFirstElementSum) {
maxestSubArray = subArray(parentArray, 0, end);
} else {
maxestSubArray = removeFirstElementMaxestArray;
}

for (int temp : maxestSubArray) {
resultList.add(temp);
}
}

int size = resultList.size();
int[] result = new int[size];
if (size > 0) {
for (int i = 0; i < size; i++) {
result[i] = resultList.get(i);
}
}

return result;
}

/**
* 求数组之和
*
* @param array
* @param start
*            开始位置
* @param end
*            结束位置(最后计算的元素位置的后面一个位置, 算头不算尾)
* @return 数组为空都返回0
*/
public static int sumArray(int[] array, int start, int end) {
if (array == null) {
throw new NullPointerException("array is null");
}

int sum = 0;

if (array.length > 0) {
int temp = 0;
for (int i = start; i < end; i++) {
temp = array[i];
sum += temp;
}
}

return sum;
}

/**
* 获取子数组
*
* @param array
*            原始数组
* @param start
*            开始位置
* @param end
*            结束位置(最后计算的元素位置的后面一个位置, 算头不算尾)
* @return
*/
public static int[] subArray(int[] array, int start, int end) {
if (array == null) {
throw new NullPointerException("array is null");
}

int size = end - start;
int[] temp = new int[size];

for (int i = 0; i < size; i++) {
temp[i] = array[start + i];
}

return temp;
}

/**
* 打印数组
*
* @param array
*/
public static void printArray(int[] array) {
if (array == null) {
System.out.println("null");
}

int size = array.length;
StringBuffer buffer = new StringBuffer();
buffer.append("{");

for (int i = 0; i < size; i++) {
buffer.append(array[i]);
if (i < size - 1) {
buffer.append(", ");
}
}

buffer.append("}");

System.out.println(buffer.toString());
}
}

import java.util.ArrayList;
import java.util.List;

public class FindTheMaxestArray {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] originalArray = { 1, 2, 0, -2, 2, 1, -8, 9 };
		System.out.print("原数组: ");
		printArray(originalArray);

		int[] maxestSubArray = getTheMaxestArray(originalArray);
		System.out.print("最大子数组: ");
		printArray(maxestSubArray);
	}

	/**
	 * 找出总和值最大的子数组
	 * 
	 * @param parentArray
	 * @return
	 */
	public static int[] getTheMaxestArray(int[] parentArray) {
		if (parentArray == null) {
			throw new NullPointerException("array is null");
		}

		List<Integer> resultList = new ArrayList<Integer>();

		if (parentArray.length == 1) {
			resultList.add(parentArray[0]);
		} else {
			// 找出第一个元素，分为两种情况，第一个元素为子数组的元素以及第一个元素不是子数组的元素
			int firstElement = parentArray[0];
			int firstElementSum = firstElement;
			int end = 1;

			int tempSum;
			for (int i = 2; i <= parentArray.length; i++) {
				tempSum = sumArray(parentArray, 0, i);
				if (tempSum > firstElementSum) {
					firstElementSum = tempSum;
					end = i;
				}
			}

			// 找出去除第一个元素数组的最大子数组
			int[] removeFirstElementArray = subArray(parentArray, 1,
					parentArray.length);
			int[] removeFirstElementMaxestArray = getTheMaxestArray(removeFirstElementArray);
			int removeFirstElementSum = sumArray(removeFirstElementMaxestArray,
					0, removeFirstElementMaxestArray.length);

			// 比较包含第一个元素和不包含第一个元素的情况
			int[] maxestSubArray;
			if (firstElementSum >= removeFirstElementSum) {
				maxestSubArray = subArray(parentArray, 0, end);
			} else {
				maxestSubArray = removeFirstElementMaxestArray;
			}

			for (int temp : maxestSubArray) {
				resultList.add(temp);
			}
		}

		int size = resultList.size();
		int[] result = new int[size];
		if (size > 0) {
			for (int i = 0; i < size; i++) {
				result[i] = resultList.get(i);
			}
		}

		return result;
	}

	/**
	 * 求数组之和
	 * 
	 * @param array
	 * @param start
	 *            开始位置
	 * @param end
	 *            结束位置(最后计算的元素位置的后面一个位置, 算头不算尾)
	 * @return 数组为空都返回0
	 */
	public static int sumArray(int[] array, int start, int end) {
		if (array == null) {
			throw new NullPointerException("array is null");
		}

		int sum = 0;

		if (array.length > 0) {
			int temp = 0;
			for (int i = start; i < end; i++) {
				temp = array[i];
				sum += temp;
			}
		}

		return sum;
	}

	/**
	 * 获取子数组
	 * 
	 * @param array
	 *            原始数组
	 * @param start
	 *            开始位置
	 * @param end
	 *            结束位置(最后计算的元素位置的后面一个位置, 算头不算尾)
	 * @return
	 */
	public static int[] subArray(int[] array, int start, int end) {
		if (array == null) {
			throw new NullPointerException("array is null");
		}

		int size = end - start;
		int[] temp = new int[size];

		for (int i = 0; i < size; i++) {
			temp[i] = array[start + i];
		}

		return temp;
	}

	/**
	 * 打印数组
	 * 
	 * @param array
	 */
	public static void printArray(int[] array) {
		if (array == null) {
			System.out.println("null");
		}

		int size = array.length;
		StringBuffer buffer = new StringBuffer();
		buffer.append("{");

		for (int i = 0; i < size; i++) {
			buffer.append(array[i]);
			if (i < size - 1) {
				buffer.append(", ");
			}
		}

		buffer.append("}");

		System.out.println(buffer.toString());
	}
}

这个应该是正确的，不过还是小小的修改一下
         int max = arr[0];
        int start =0;
        int len = 1;
        for (int i = 0; i < arr.length; i++) {
            int subSum = 0;
            for (int subLen = i; subLen < arr.length; subLen++) {
                subSum +=arr[subLen];
                if (subSum > max)
                {
                    max = subSum;
                    start = i;
                    len = subLen-start+1;
                }
            }
        }