Melhorar codigo

import java.io.PrintStream;
import java.math.BigInteger;
import java.util.Random;
import java.util.Scanner;

/**
 *
 * @author filip
 */
public class MTDISC {

    /**
     * Ponto de entrada do programa Java
     */
    public static void main(String[] args) {
        MTDISC programa = new MTDISC();
        programa.executar();
    }

    private final Scanner entrada = new Scanner(System.in);
    private final PrintStream saida = System.out;

    /**
     * Executa este programa
     */
    public void executar() {
        saida.println("Insira um valor: ");
        long tempoInicial = System.currentTimeMillis();
        int valor = Integer.parseInt(entrada.nextLine());
        saida.println("Fatorial: " + fatorial(valor));
        long tempoFinal = System.currentTimeMillis();
        long tempoExe = tempoFinal - tempoInicial;
        saida.println("Tempo de execução: " + tempoExe + " milissegundos");

        // Introdução dos valores da matriz no formato x,y,z,...
        saida.println("Introduza os valores: ");
        String stringDeNumeros = entrada.nextLine();
        // converte a string para um vetor de strings
        String[] vetorString = stringDeNumeros.split(",");
        int[] vetorInt = stringsParaInts(vetorString);

        // converte o vetor para uma matriz
        int[][] matriz = converteVetorEmMatriz(vetorInt);

        // imprime a matriz
        imprimirMatriz(matriz);

        // definir ordem da matriz
        saida.println(" ");
        saida.println("Insira a ordem da matriz a gerar: ");
        int ordem = Integer.parseInt(entrada.nextLine());

        // gerar matrizes aleatoriamente com valores entre [0,100] com as diagonais em zero.
        int[][] matrizAleatoria = gerarMatriz(ordem, 100);
        saida.println(" ");

        // Imprimir matriz gerada aleatoriamente
        saida.println("Matriz gerada aleatoriamente de ordem " + ordem + ":");
        saida.println(" ");
        imprimirMatriz(matrizAleatoria);
    }

    /**
     * Converte o vetor para uma matriz
     */
    private int[][] converteVetorEmMatriz(int[] vetor) {
        int ordem = (int) Math.sqrt(vetor.length);
        int[][] matriz = new int[ordem][ordem];
        try {
            int posicao = 0;
            for (int linha = 0; linha < ordem; linha++) {
                for (int coluna = 0; coluna < ordem; coluna++) {
                    matriz[linha][coluna] = vetor[posicao++];
                }
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            saida.println("Erro: Não introduziu valores correspondentes a uma matriz quadrada! " + e);
        }
        return matriz;
    }

    /**
     * Fatorial de um numero
     */
    private BigInteger fatorial(int numero) {
        BigInteger factorial = new BigInteger("1");
        for (int i = 1; i <= numero; i++) {
            factorial = factorial.multiply(new BigInteger(String.valueOf(i)));
        }
        return factorial;
    }

    /**
     * Gerar matrizes de ordem informada aleatoriamente com valores entre 0 e o limite informado, com as diagonais em zero.
     */
    private int[][] gerarMatriz(int ordem, int limite) {
        Random gerador = new Random();
        int matriz[][] = new int[ordem][ordem];
        for (int linha = 0; linha < ordem; linha++) {
            for (int coluna = 0; coluna < ordem; coluna++) {
                int valor = linha == coluna ? 0 : gerador.nextInt(limite);
                matriz[linha][coluna] = valor;
            }
        }
        return matriz;
    }

    /**
     * Imprime a matriz passada por parametro
     */
    private void imprimirMatriz(int[][] matriz) {
        for (int linha = 0; linha < matriz.length; linha++) {
            for (int coluna = 0; coluna < matriz[linha].length; coluna++) {
                String espaco = matriz[linha][coluna] < 10 ? "  " : " ";
                saida.print(espaco + matriz[linha][coluna] + espaco);
            }
            saida.println(" ");
        }
    }

    /**
     * Converte um array de String para um array de int
     */
    private int[] stringsParaInts(String[] strings) {
        int ints[] = new int[strings.length];
        try {
            for (int i = 0; i < strings.length; ++i) {
                ints[i] = Integer.parseInt(strings[i].trim());
            }
        } catch (NumberFormatException e) {
            saida.println("Erro: Não introduziu apenas numeros! " + e);
        }
        return ints;
    }
}