數組最大子串和問題是一種非常經典的算法問題，Java中有多種求解方法，下面我們就來逐一介紹。

首先，我們先來看一個基本的暴力枚舉算法：

public int maxSubArray(int[] nums) {
int maxSum = nums[0];
for (int i = 0; i< nums.length; i++) {
int sum = 0;
for (int j = i; j< nums.length; j++) {
sum += nums[j];
if (sum >maxSum) {
maxSum = sum;
}
}
}
return maxSum;
}

以上算法的時間復雜度為O(n^2)，對于數據量較小的情況下可以使用。但對于大數據量的情況，需要使用更優秀的算法。

接下來，我們介紹一種動態規劃算法：

public int maxSubArray(int[] nums) {
int[] dp = new int[nums.length];
dp[0] = nums[0];
int maxSum = dp[0];
for (int i = 1; i< nums.length; i++) {
dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
maxSum = Math.max(maxSum, dp[i]);
}
return maxSum;
}

以上算法的時間復雜度為O(n)，比暴力算法優秀很多。通過設定狀態和狀態轉移方程來求解問題，可以在很短的時間內得到答案。

當然，以上算法還不是最優秀的解答方法。我們還可以使用分治法來求解數組最大子串和問題：

public int maxSubArray(int[] nums) {
return maxSubArrayDivide(nums, 0, nums.length - 1);
}
private int maxSubArrayDivide(int[] nums, int left, int right) {
if (left == right) {
return nums[left];
}
int mid = left + (right - left) / 2;
int maxLeft = maxSubArrayDivide(nums, left, mid);
int maxRight = maxSubArrayDivide(nums, mid + 1, right);
int maxMidLeft = Integer.MIN_VALUE, maxMidRight = Integer.MIN_VALUE;
int sum = 0;
for (int i = mid; i >= left; i--) {
sum += nums[i];
maxMidLeft = Math.max(maxMidLeft, sum);
}
sum = 0;
for (int i = mid + 1; i<= right; i++) {
sum += nums[i];
maxMidRight = Math.max(maxMidRight, sum);
}
return Math.max(Math.max(maxLeft, maxRight), maxMidLeft + maxMidRight);
}

以上算法的時間復雜度也是O(n)，但是在數據量更大的情況下，分治法比動態規劃法更優秀。

綜上所述，數組最大子串和問題有多種解決方法，我們可以根據不同的情況選擇不同的算法。