Cómo deshacerse del problema de Java TLE

Sucede muchas veces que ha escrito código Java correcto con tanta optimización como sea necesario de acuerdo con las restricciones. Pero, obtienes TLE ????. 
Esto sucede debido al tiempo que tarda Java en tomar entrada y escribir salida utilizando la clase Scanner, que es lenta en comparación con la clase BufferedReader y StringBuffer. Lea en detalle sobre Scanner Class aquí . 
¿Eche un vistazo a algunos consejos para deshacerse de este problema de TLE (cuando su lógica es correcta, obviamente)? 
 

Consejo 1: evite usar la clase Scanner e intente usar la clase BufferedReader . 
Consejo 2: intente usar la clase StringBuffer en caso de que tenga que imprimir una gran cantidad de datos.

Tomemos un problema de la práctica de GeeksforGeeks y resolvamos el problema de TLE: 
Problema: segregar una array de 0, 1 y 2 
En resumen, el problema es, dada una array de 0, 1 y 2. Tenemos que segregar todos los 0 al comienzo de la array, todos los 1 en la mitad de la array y todos los 2 en el último de la array. 
Ejemplos: 
 

Input : 1 1 2 0 0 2 1
Output : 0 0 1 1 1 2 2

Enfoque: array separada de 0, 1 y 2
A continuación se muestra la implementación del enfoque anterior: 
 

// Program to segregate the
// array of 0s, 1s and 2s
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
    public static void main(String[] args)
    {
        // Using Scanner class to take input
        Scanner sc = new Scanner(System.in);
 
        // Number of testcase input
        int t = sc.nextInt();
 
        // Iterating through all the testcases
        while (t-- > 0) {
 
            // Input n, i.e. size of array
            int n = sc.nextInt();
 
            int arr[] = new int[n];
 
            // Taking input of array elements
            for (int i = 0; i < n; i++)
                arr[i] = sc.nextInt();
 
            // Calling function to segregate
            // input array
            segregateArr(arr, n);
 
            // printing the modified array
            for (int i = 0; i < n; i++) {
                System.out.print(arr[i] + " ");
            }
 
            System.out.println();
        }
        sc.close();
    }
 
    // Function to segregate 0s, 1s and 2s
    public static void segregateArr(int arr[], int n)
    {
        /*
        low : to keep left index
        high : to keep right index
        mid : to get middle element
        */
        int low = 0, high = n - 1, mid = 0;
 
        // Iterating through the array and
        // segregating elements
        while (mid <= high) {
 
            // If element at mid is 0
            // move it to left
            if (arr[mid] == 0) {
                int temp = arr[low];
                arr[low] = arr[mid];
                arr[mid] = temp;
                low++;
                mid++;
            }
 
            // If element at mid is 1
            // nothing to do
            else if (arr[mid] == 1) {
                mid++;
            }
 
            // If element at mid is 2
            // move it to last
            else {
                int temp = arr[mid];
                arr[mid] = arr[high];
                arr[high] = temp;
                high--;
            }
        }
    }
}

De acuerdo con nuestras expectativas, debería pasar todos los casos de prueba y ser aceptado en la práctica de GeeksforGeeks . Pero, cuando enviamos este código en GeeksforGeeks IDE, muestra TLE. 
 

Esto significa que hemos excedido el límite de tiempo como se esperaba. No hay problema, usemos los consejos dados anteriormente . 
 

1. Use BufferedReader para recibir información.
2. Use StringBuffer para guardar e imprimir la salida.

Enfoque: array segregada de 0, 1 y 2
A continuación se muestra la implementación del código Java para segregar 0, 1 y 2 
 

// Java program to segregate
// array of 0s, 1s and 2s
import java.io.*;
import java.util.*;
 
class GFG {
    // Driver Code
    public static void main(String[] args) throws IOException
    {
 
        // Using BufferedReader class to take input
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 
        // taking input of number of testcase
        int t = Integer.parseInt(br.readLine());
 
        while (t-- > 0) {
            // n : size of array
            int n = Integer.parseInt(br.readLine());
 
            // Declaring array
            int arr[] = new int[n];
 
            // to read multiple integers line
            String line = br.readLine();
            String[] strs = line.trim().split("\\s+");
 
            // array elements input
            for (int i = 0; i < n; i++)
                arr[i] = Integer.parseInt(strs[i]);
 
            // Calling Functions to segregate Array elements
            segregateArr(arr, n);
 
            // Using string buffer to append each output in a string
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < n; i++)
                sb.append(arr[i] + " ");
 
            // finally printing the string
            System.out.println(sb);
        }
        br.close();
    }
 
    // Function to segregate 0s, 1s and 2s
    public static void segregateArr(int arr[], int n)
    {
        /*
        low : to keep left index
        high : to keep right index
        mid : to get middle element
        */
        int low = 0, high = n - 1, mid = 0;
 
        // Iterating through the array and
        // segregating elements
        while (mid <= high) {
 
            // If element at mid is 0
            // move it to left
            if (arr[mid] == 0) {
                int temp = arr[low];
                arr[low] = arr[mid];
                arr[mid] = temp;
                low++;
                mid++;
            }
 
            // If element at mid is 1
            // nothing to do
            else if (arr[mid] == 1) {
                mid++;
            }
 
            // If element at mid is 2
            // move it to last
            else {
                int temp = arr[mid];
                arr[mid] = arr[high];
                arr[high] = temp;
                high--;
            }
        }
    }
}

¡Excelente! Has subido de nivel. 
¿Problema de Java TLE? Parece bastante simple :). Puedes intentarlo ahora .