Java 将所有非零整数移动到数组的开头

我正在尝试将所有非零整数移到数组“a”的开始/左侧。（例如，{0,0,4,3,0}变为{4,3,0,0}）

这是我的节目。它编译并运行时没有错误，但数组最终只有零。如有任何建议，将不胜感激

int[] squeezeLeft(int[] a) {
    int count = 0;
    //creates new array
    int [] a2 = new int[a.length];
    //loops through a
    for (int i = 0; i< a.length; i++){
        //gets a temporary value from a[i]
        int temp = a[i];
        //assigns a[i] to temporary variable
        a[count] = temp;
        a[i] = 0;
                  /* raises count integer by one, so the following indice which is zero, is replaced

                  by  the following non=zero integer*/
        count++;
    }
    return a2;
}

int[]向左挤压（int[]a）{
整数计数=0；
//创建新数组
int[]a2=新的int[a.长度]；
//循环通过一个
for（int i=0；i

我知道这不是非常有效的解决方案

O^2

，但它可以满足您的要求

private static int[] sequeezeLeft(final int[] a) {
    for (int i = 0; i < a.length; i++) {
        if (a[i] != 0) {
            for (int j = 0; j < a.length; j++) {
                if (a[j] == 0) {
                    a[j] = a[i];
                    a[i] = 0;
                }
            }
        }
    }
    return a;
}

---

我知道这不是非常有效的解决方案，但它可以满足您的要求

private static int[] sequeezeLeft(final int[] a) {
    for (int i = 0; i < a.length; i++) {
        if (a[i] != 0) {
            for (int j = 0; j < a.length; j++) {
                if (a[j] == 0) {
                    a[j] = a[i];
                    a[i] = 0;
                }
            }
        }
    }
    return a;
}

---

我知道这不是非常有效的解决方案，但它可以满足您的要求

private static int[] sequeezeLeft(final int[] a) {
    for (int i = 0; i < a.length; i++) {
        if (a[i] != 0) {
            for (int j = 0; j < a.length; j++) {
                if (a[j] == 0) {
                    a[j] = a[i];
                    a[i] = 0;
                }
            }
        }
    }
    return a;
}

---

我知道这不是非常有效的解决方案，但它可以满足您的要求

private static int[] sequeezeLeft(final int[] a) {
    for (int i = 0; i < a.length; i++) {
        if (a[i] != 0) {
            for (int j = 0; j < a.length; j++) {
                if (a[j] == 0) {
                    a[j] = a[i];
                    a[i] = 0;
                }
            }
        }
    }
    return a;
}

---

或者如果你有点懒，那么用这个怎么样

    Integer[] ints = new Integer[] { 0, 5, 2, 0, 1, 5, 6 };
    List<Integer> list = Arrays.asList(ints);
    Collections.sort(list);
    Collections.reverse(list);
    System.err.println(list); // prints [6, 5, 5, 2, 1, 0, 0]

Integer[]ints=新的整数[]{0,5,2,0,1,5,6}；
List=Arrays.asList（ints）；
集合。排序（列表）；
收款。反向（列表）；
System.err.println（列表）；//打印[6,5,5,2,1,0,0]

---

不过，对性能不太确定..

或者如果您有点懒，那么使用这个怎么样

    Integer[] ints = new Integer[] { 0, 5, 2, 0, 1, 5, 6 };
    List<Integer> list = Arrays.asList(ints);
    Collections.sort(list);
    Collections.reverse(list);
    System.err.println(list); // prints [6, 5, 5, 2, 1, 0, 0]

Integer[]ints=新的整数[]{0,5,2,0,1,5,6}；
List=Arrays.asList（ints）；
集合。排序（列表）；
收款。反向（列表）；
System.err.println（列表）；//打印[6,5,5,2,1,0,0]

---

不过，对性能不太确定..

或者如果您有点懒，那么使用这个怎么样

    Integer[] ints = new Integer[] { 0, 5, 2, 0, 1, 5, 6 };
    List<Integer> list = Arrays.asList(ints);
    Collections.sort(list);
    Collections.reverse(list);
    System.err.println(list); // prints [6, 5, 5, 2, 1, 0, 0]

Integer[]ints=新的整数[]{0,5,2,0,1,5,6}；
List=Arrays.asList（ints）；
集合。排序（列表）；
收款。反向（列表）；
System.err.println（列表）；//打印[6,5,5,2,1,0,0]

---

不过，对性能不太确定..

或者如果您有点懒，那么使用这个怎么样

    Integer[] ints = new Integer[] { 0, 5, 2, 0, 1, 5, 6 };
    List<Integer> list = Arrays.asList(ints);
    Collections.sort(list);
    Collections.reverse(list);
    System.err.println(list); // prints [6, 5, 5, 2, 1, 0, 0]

Integer[]ints=新的整数[]{0,5,2,0,1,5,6}；
List=Arrays.asList（ints）；
集合。排序（列表）；
收款。反向（列表）；
System.err.println（列表）；//打印[6,5,5,2,1,0,0]

---

不确定性能，但..

与输入

1,0,2,0,4,0,5,0,6,0

一样，第二个解决方案将失败，因为输出将为：

024560000

对于o（n）：

私有静态int[]非零元素（int arr[]{
整数计数=0；
如果（arr.length==0）
返回arr；
对于（int i=0；icount；）{
arr[count++]=0；
}
返回arr；
}

与输入一样，

1,0,2,0,4,0,5,0,6,0

第二个解决方案将失败，因为输出为：

024560000

对于o（n）：

私有静态int[]非零元素（int arr[]{
整数计数=0；
如果（arr.length==0）
返回arr；
对于（int i=0；icount；）{
arr[count++]=0；
}
返回arr；
}

与输入一样，

1,0,2,0,4,0,5,0,6,0

第二个解决方案将失败，因为输出为：

024560000

对于o（n）：

私有静态int[]非零元素（int arr[]{
整数计数=0；
如果（arr.length==0）
返回arr；
对于（int i=0；icount；）{
arr[count++]=0；
}
返回arr；
}

与输入一样，

1,0,2,0,4,0,5,0,6,0

第二个解决方案将失败，因为输出为：

024560000

对于o（n）：

私有静态int[]非零元素（int arr[]{
整数计数=0；
如果（arr.length==0）
返回arr；
对于（int i=0；icount；）{
arr[count++]=0；
}
返回arr；
}

那么：

Arrays.sort(ints, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2)
    {
        if (o1 == 0) return 1;
        if (o2 != 0 && o1 > o2) return 1;
        if (o2 != 0 && o1 == o2) return 0;
        return -1;
    }
});

Arrays.sort（ints，新的Comparator（）{
@凌驾
公共整数比较（整数o1，整数o2）
{
如果（o1==0）返回1；
如果（o2！=0&&o1>o2）返回1；
如果（o2！=0&&o1==o2）返回0；
返回-1；
}
});

那么：

Arrays.sort(ints, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2)
    {
        if (o1 == 0) return 1;
        if (o2 != 0 && o1 > o2) return 1;
        if (o2 != 0 && o1 == o2) return 0;
        return -1;
    }
});

Arrays.sort（ints，新的Comparator（）{
@凌驾
公共整数比较（整数o1，整数o2）
{
如果（o1==0）返回1；
如果（o2！=0&&o1>o2）返回1；
如果（o2！=0&&o1==o2）返回0；
返回-1；
}
});

那么：

Arrays.sort(ints, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2)
    {
        if (o1 == 0) return 1;
        if (o2 != 0 && o1 > o2) return 1;
        if (o2 != 0 && o1 == o2) return 0;
        return -1;
    }
});

Arrays.sort（ints，新的Comparator（）{
@凌驾
公共整数比较（整数o1，整数o2）
{
如果（o1==0）返回1；
如果（o2！=0&&o1>o2）返回1；
如果（o2！=0&&o1==o2）返回0；
返回-1；
}
});

那么：

Arrays.sort(ints, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2)
    {
        if (o1 == 0) return 1;
        if (o2 != 0 && o1 > o2) return 1;
        if (o2 != 0 && o1 == o2) return 0;
        return -1;
    }
});

Arrays.sort（ints，新的Comparator（）{
@凌驾
公共整数比较（整数o1，整数o2）
{
如果（o1==0）返回1；
如果（o2！=0&&o1>o2）返回1；
如果（o2！=0&&o1==o2）返回0；
返回-1；
}
});

静态空挤压左（int[]数组）{
int-arrayIndex=0；
如果（array.length！=0）{//请检查数组的长度是否为零
for（int i=0；i