MergeSort -- ArrayIndexOutOfBoundsException

package analisealgoritmo;

import java.util.Scanner;

public class AnaliseAlgoritmo {

    /**
     * Metodo Main, Cria o vetor final onde serão armazenados os dados organizados
     * e recebe uma entrada do usuário que determinará o tamanho do Vetor.
     * 
     */
    public static void main(String[] args) {
        int x = 0;
        int[] vetorfinal = new int[x];
        System.out.println("Insira um número");
        try {
            Scanner input = new Scanner(System.in);
            x = input.nextInt();

        } catch (NumberFormatException nb) {
            nb.printStackTrace();
        }
        if (testaQuadrado(x)) {
            vetorfinal = mergeSort(geraVetor(x));
            System.out.println();
            System.out.println();
            System.out.println();
            formataMatriz(vetorfinal, x);
        } else {
            System.out.println("Não é um quadrado perfeito");
        }

    }

    /**
     * Gera vetor de acordo com o tamanho inserido no main,
     * caso o tamanho seja '0' retorna nulo, caso contrário
     * cria um vetor de números aleatórios
     */
    public static int[] geraVetor(int tamanho) {

        if (tamanho == 0) {
            return null;
        }

        int[] vetor = new int[tamanho];
        for (int i = 0; i < tamanho; i++) {
            vetor[i] = (int) (Math.random() * 1000);

            System.out.print(vetor[i] + ". ");

        }
        return vetor;
    }

    /**
     * O Vetor no final deve ser impresso de forma quadrada perfeita, portanto esse 
     * método se responsabiliza por checar se o numero inserido é um quadrado perfeito.
     */
    public static boolean testaQuadrado(double i) {
        if (i == 0) {
            return false;
        }

        Double resultado = Math.sqrt(i);
        if (resultado != null) {
            return resultado.intValue() == resultado.doubleValue();
        } else {
            return false;
        }
    }

    /**
     * MergeSort recursivo Baseado nos livros Algoritmos 2º ed. da editora Campus e 
     * Sorting and Searching do Knuth 
     * Caso o quadrado seja um numero impar ocorre Erro. (Preciso corrigir esse erro)
     */
    public static int[] mergeSort(int[] vetor) {
        if (vetor == null) {
            return null;
        }

        if (vetor.length <= 1) {
            return vetor;
        }
        int meio;
 
            meio = ((vetor.length) / 2);
       
        int[] direita = new int[meio];
        int[] esquerda = new int[vetor.length - meio];

        System.arraycopy(vetor, 0, esquerda, 0, meio);
        System.arraycopy(vetor, meio, direita, 0, vetor.length - meio);

        direita = mergeSort(direita);
        esquerda = mergeSort(esquerda);

        return merge(esquerda, direita);
    }

    /**
     * Algoritmo 100% Baseado em Knuth que organiza definitivamente.
     *  
     */
    public static int[] merge(int[] esquerda, int[] direita) {

        if (esquerda == null || direita == null) {
            return null;
        }

        int[] result = new int[esquerda.length + direita.length];

        int i = 0, j = 0, k = 0;

        while (i < esquerda.length && j < direita.length) {

            if (esquerda[i] > direita[j]) {
                result[k] = direita[j];
                j++;
            } else {
                result[k] = esquerda[i];
                i++;
            }
            k++;
        }
        while (i < esquerda.length) {
            result[k] = esquerda[i];
            i++;
            k++;
        }

        while (j < direita.length) {
            result[k] = direita[j];
            j++;
            k++;

        }

        return result;
    }

    /**
     * Aqui ocorre a impressão dos vetores em um quadrado perfeito ordenando
     * crescentemente as colunas.
     *  
     */
    public static void formataMatriz(int[] vetorfinal, int tamanho) {

        if (vetorfinal == null || tamanho == 0) {
            System.out.println("Valores nulos encontrados");
        }
        int[] finalvetor = vetorfinal;

        int z = (int) Math.sqrt(tamanho);
        int matriz[][] = new int[z][z];


        for (int i = 0; i < finalvetor.length; i++) {
            matriz[(int) i / z][i % z] = finalvetor[i];
        }

        for (int i = 0; i < z; i++) {
            for (int j = 0; j < z; j++) {
                System.out.print(matriz[j][i] + "  ");
            }
            System.out.println();
        }

    }
}