你几乎已经得到了它！！一旦你交换了偶数值，你就在重新交换它们。所以只要在数组的一半上进行交换。你可以看到这一点，如果你把

System.out.printf("Swapping %d with %d%n",
       array[firstNumIndex], array[secondNumIndex]);

字符串
在开始交换之前。要修复它，请将for loop更改为：

for (int i = 0; i < array.length/2; i++) {

型
这里有一个替代形式。
你只需要一个常规的for循环。

• 10 left刚好穿过阵列的一半。
• 根据left的值将right分配给当前最右边的位置。
• 检查以确保两者都是偶数值。
• 如果是，则交换它们。

请注意，这对偶数和奇数长度数组都有效。

int[] arr = {1,2,3,4,5,6,7,8,9,10,11};
swapEven(arr);
System.out.println(Arrays.toString(arr));

型
指纹

[1, 10, 3, 8, 5, 6, 7, 4, 9, 2, 11]

型
述的方法

public static void swapEven(int[] array) {
    if (array == null) {
        System.out.println("Array is null");
        return;
    }
    for (int left = 0; left < array.length / 2; left++) {
        int right = array.length - left - 1;
        if (array[left] % 2 == 0 && array[right] % 2 == 0) {
            int temp = array[left];
            array[left] = array[right];
            array[right] = temp;
        }
    }
}

型

**Note.**如果你需要反转一个数组，你可以通过忽略偶数值的检查来实现。

如果你在数组的整个长度上进行重复，所有的偶数元素将被交换两次（这将使它们全部返回到原始位置）。
相反，你应该在数组的一半上循环。你可以使用两个索引来跟踪前面和后面的位置，当它们相互通过时停止。

for (int i = 0, j = array.length - 1; i < j; i++, j--) {
    if (array[i] % 2 == 0 && array[j] % 2 == 0) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

字符串

问题似乎在于数组为空时的初始化方式。而不是将新数组分配给参数，您应该处理输入数组为空的情况。您还可以简化交换逻辑。您可以这样做：

import java.util.Arrays;

public class FirstProgram {
    public static void main(String[] args) {
        int[] myArray = new int[]{100, 2, 3, 45, 33, 8, 4, 54};
        swapEven(myArray);
        System.out.println(Arrays.toString(myArray));
    }

    public static void swapEven(int[] array) {
        if (array != null && array.length > 0) {
            for (int i = 0; i < array.length / 2; i++) {
                if (array[i] % 2 == 0 && array[array.length - 1 - i] % 2 == 0) {
                    int temp = array[i];
                    array[i] = array[array.length - 1 - i];
                    array[array.length - 1 - i] = temp;
                }
            }
        } else {
            System.out.println("Input array is empty or null.");
        }
    }
}

字符串

• "...在一个给定的整数数组中，如果第一个和最后一个数组元素的值都是偶数，则nums交换第二个和倒数第二个数组元素的值，依此类推。

这里有一个例子。
你只需要遍历数组的一半。
使用 （n − 1）− i 访问相反的索引。

void swap(int[] a) {
    for (int i = 0, t, n = a.length, m = n / 2; i < m; i++) {
        if (a[i] % 2 == 0 && a[n - 1 - i] % 2 == 0) {
            t = a[i];
            a[i] = a[n - 1 - i];
            a[n - 1 - i] = t;
        }
    }
}

字符串
或者，使用 stream。

void swap(int[] a) {
    int n = a.length;
    IntStream.range(0, n / 2)
             .forEach(
                 x -> {
                     if (a[x] % 2 == 0 && a[n - 1 - x] % 2 == 0) {
                         int t = a[x];
                         a[x] = a[n - 1 - x];
                         a[n - 1 - x] = t;
                     }
                 });
}

型
而且，如果您使用的是 List，则可以使用 Collections#swap 方法。

void swap(List<Integer> l) {
    for (int i = 0, n = l.size(), m = n / 2; i < m; i++)
        if (l.get(i) % 2 == 0 && l.get(n - 1 - i) % 2 == 0)
            Collections.swap(l, i, n - 1 - i);
}

型
输出

[4, 5, 3, 10]

[54, 4, 3, 45, 33, 8, 2, 100]