Convert text line of integers into array of integers in fastest way

I have a small homeworks, I need to convert text line of integers contains 10,000 numbers. I have tried this code below:

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int[] a = Arrays.stream(br.readLine().split("\\s+")).mapToInt(Integer::parseInt).toArray();

It's worked, but it's still not fast enough and I got Time Limited Exeeded error. Is there any way I can make it run faster?

One way is to use the Scanner class, and iterate on the Scanner#nextInt method.

Scanner scanner = new Scanner(System.in);
int[] a = new int[10_000];
int index = 0;
while (index < a.length) a[index++] = scanner.nextInt();

You might find that the regular expression and integer conversion are convenient but not necessarily performant. In the code you posted, the regex evaluator has to examine every character to find the separators, then create a new string for each number it finds, and call the conversion routine to create an integer (which involves looking at each character of the string again). There's a lot of work going on under the hood.

You might consider parsing and converting in a single step. If you know that the input is valid (i.e. there aren't any values out of range and there aren't any non-numeric characters), then a tightly coded loop along these lines might do the trick. Note that I'm not really a Java programmer, but you should be able to get the gist of the idea:

List<int> tempList;  // this is a dynamic list that grows with append
string inputString;

inputString = br.readLine();
int i = 0;  // number is built here
bool firstDigit = false;
for (x = 0 to length of inputString) {
    if (inputString[x] == ' ') {
        // if the input character is a space and you've seen
        // at least one digit, then this is the end of that number.
        // Write it to the output list and reset.
        if (firstDigit) {
            tempList.append(i);
            i = 0;
            firstDigit = false;
        }
        continue;  // go get next character
    }
    i = (i*10) + inputString[x] - '0';
    firstDigit = true;
}
// We've reached the end of the string.
// There might not be a space at the end, so the last value
// is still in the variable i and hasn't been written to output
if (firstDigit) {
    tempList.append(i);
}
// and then convert that expandable list to an array
return tempList.ToArray()

This could potentially be much faster because it goes through the array examining each character exactly once. In addition, it doesn't create any temporary strings.

If you know that there are exactly 10,000 numbers on the line, you can speed this up even more by allocating your return array at the start. When you read a number, add it to the array and increment the index. Something like:

int a[10000];
aindex = 0;

And then in your loop in place of tempList.append(i), you have:

a[aindex] = i;
aindex++;

That will eliminate the need for the dynamic list and the ToArray at the end.