代码中存在多个问题：
临时数组太短：因为 r 是最后一个元素的索引，大小应为 r - p + 1 . 传递要简单得多 r 索引超过要排序的切片的最后一个元素。
第一个 for 循环不正确：应该使用不同的索引 B 以及 A .
第二个 for 循环复制到 B[r - 1] 向下，但应该使用 B[r - p] 相反。
合并循环不正确：您应该测试 i 以及 j 在进入前仍在各自的一半的边界内 B[i] 和/或 B[j] .
[次要]没有必要 int q = Math.floor((p + r) / 2); 在java中作为 p 以及 r 你有类型吗 int ，因此除法将使用整数算法。
以下是一个修改版本：

public class Mergesort {

    private static int[] A = new int[]{ 4, 2, 1, 8, 6 };

    public static void main(String[] args) {
        merge_sort(0, A.length);
        System.out.println(Arrays.toString(A));
    }

    public static void merge_sort(int p, int r) {
        if (r - p >= 2) {
            int q = p + (r - p) / 2;
            merge_sort(p, q);
            merge_sort(q, r);
            merge(p, q, r);
        }
    }

    public static void merge(int p, int q, int r) {
        int m = q - p;  // zero based index of the right half
        int n = r - p;  // length of the merged slice
        int[] B = new int[n];
        int i, j, k;
        for (i = p, j = 0; j < m; j++)
            B[j] = A[i++];
        for (i = r, j = m; j < n; j++)
            B[j] = A[--i];
        for (i = 0, j = n, k = p; k < r; k++) {
            // for stable sorting, i and j must be tested against their boundary
            // A[k] = (i < m && (j <= m || B[i] <= B[j - 1])) ? B[i++] : B[--j];
            // stability is not an issue for an array of int
            A[k] = (B[i] <= B[j - 1]) ? B[i++] : B[--j];
        }
    }
}

反转后半部分可以实现更简单的合并循环，而无需边界测试。但是请注意，有一种更简单的方法，它使用的内存更少，效率也可能更高：

public static void merge(int p, int q, int r) {
        int m = q - p;  // length of the left half
        int[] B = new int[m];
        int i, j, k;
        // only save the left half
        for (i = p, j = 0; j < m; j++)
            B[j] = A[i++];
        for (i = 0, j = q, k = p; i < m; k++) {
            A[k] = (j >= r || B[i] <= A[j]) ? B[i++] : A[j++];
        }
    }