请用JAVA解决这个算法问题？

把数组[1,1,1,0,-1,-1,-1]通过交换元素位置，变成[-1,-1,-1,0,1,1,1]。要求只能遇到以下四种情况才可以交换位置：
(1,0)→（0,1）
(0,-1)→（-1,0）
(1,-1,0)→（0,-1,1）
(0,1,-1)→（-1,1,0）
比如第一步可以是[1,1,0,1,-1,-1,-1] 或者[1,1,1,-1,0,-1,-1]。
请用Java解决这个问题，要求输出每次交换后的数组。

暴力遍历

import java.util.Arrays;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        long startTime = Calendar.getInstance().getTimeInMillis();

        int[] origin = {1, 1, 1, 0, -1, -1, -1};
        List<String> list = new LinkedList<>();
        boolean rst = doChange(list, origin, 3);
        if (rst) {
            for (String str : list) {
                System.out.println(str);
            }
        }

        System.out.println("共耗时：" + (Calendar.getInstance().getTimeInMillis() - startTime) + "ms");
    }

    private static boolean doChange(List<String> list, int[] val, int p) {
        if (p == 3 && val[0] + val[1] + val[2] == -3 && val[4] + val[5] + val[6] == 3) {
            return true;
        }
        if (p + 1 < val.length && val[p + 1] == -1) {
            if (check(list, val, p, 1)) {
                return true;
            }
        } else if (p + 2 < val.length && val[p + 2] == -1) {
            if (check(list, val, p, 2)) {
                return true;
            }
        }

        if (p - 1 >= 0 && val[p - 1] == 1) {
            return check(list, val, p, -1);
        } else if (p - 2 >= 0 && val[p - 2] == 1) {
            return check(list, val, p, -2);
        }
        return false;
    }

    private static boolean check(List<String> list, int[] val, int p, int offset) {
        int np = swap(val, p, p + offset);
        list.add(Arrays.toString(val));
        boolean rst = doChange(list, val, np);
        if (rst) {
            return true;
        }
        list.remove(list.size() - 1);
        swap(val, p, p + offset);
        return false;
    }

    private static int swap(int[] val, int p1, int p2) {
        int t = val[p1];
        val[p1] = val[p2];
        val[p2] = t;
        return val[p1] != 0 ? p2 : p1;
    }
}

运行结果：

直接用递归比较好，我个人分析，重点不在于用循环还是递归，应该还是4中条件的优先级顺序控制。
如果控制不好，则计算次数会非常多，或者一直循环下去。
如果控制科学，则计算次数会非常少。