One Dimensional Kadane Implementation for Largest Sum Contiguous Subarray

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class LargestSumContiguousSubarray {

   
    public static void main(String[] args) throws IOException {
       
        BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter the size of input integer array: ");
        int input_size=input.read();
       
        // take a integer array to store all input upto input_size
        int input_array[] = new int[input_size];
        for(int count=0;count<input_array.length;count++)
        {
            input_array[count]=input.read();
        }
       
        // function call to calculate largest sum contiguous subarray
       
        int largestSumContiguousSum=findLargestSumContiguousSubarray(input_array,input_size);
        System.out.println(largestSumContiguousSum);

    }

   
    // function to calculate largest sum contiguous subarray using Kadane's one dimentional algorithm
    private static int findLargestSumContiguousSubarray(int[] input_array,
            int input_size) {
       
        int final_maxSum=0,current_maxSum=0;
        boolean allNegative=true;
        // to handle the case when all numbers are negative
       
        for(int count=0;count<input_size;count++)
        {
            if(!(input_array[count]<0))
            {
                allNegative=false;
            }
           
            if(final_maxSum<input_array[count])
            {
                final_maxSum=input_array[count];
            }
        }
        // if all numbers are negative then return the maximum of them
        if(allNegative){
            return final_maxSum;
        }
       
        // actual implementation of kadane's algorithm
        for(int count=0;count<input_size;count++)
        {
            current_maxSum=current_maxSum+input_array[count];
            if(current_maxSum<0)
            {
                current_maxSum=0;
            }
            else
            {
                if(final_maxSum<current_maxSum)
                {
                    final_maxSum=current_maxSum;
                }
            }
        }
       
        return final_maxSum;
    }

}