Java数组顺序

我有以下数组：

int[]mi_数组={9,4,0,0,4,0,3,0,1,8,0}

我想对左边的0和右边的0以外的数字进行排序，但我发现该函数是按其中一个数字进行排序的

输出必须是

{9,4,4,3,1,8,0,0,0,0}

公共类数组{
公共静态void main（字符串[]args）{
int[]mi_数组={9,4,4,3,1,8,0,0,0,0}；
int x=0；
int y=mi_数组。长度-1；
对于（int i=0；i您可以使用
filter
和
IntStream.concat
将数组中非0的部分与非0的部分合并

final int[] mi_array = { 9, 4, 0, 0, 4, 0, 3, 0, 1, 8, 0 };
final int[] result = IntStream.concat(Arrays.stream(mi_array).filter(i -> i != 0), 
    Arrays.stream(mi_array).filter(i -> i == 0)).toArray();
System.out.println(Arrays.toString(result));


您也可以这样做：

final int[] mi_array = { 9, 4, 0, 0, 4, 0, 3, 0, 1, 8, 0 };
final int[] result = new int[mi_array.length];
final AtomicInteger idx = new AtomicInteger();
Arrays.stream(mi_array).filter(i -> i != 0).forEach(val -> result[idx.getAndIncrement()] = val);
System.out.println(Arrays.toString(result));

这里您的主要问题是您覆盖了尚未覆盖的数字

   if (mi_array[i] != 0) {
       mi_array[x] = mi_array[i];
       x++;
   }

在这段代码中，
x
永远不能超过
i
；它从0开始，就像我一样，每个循环最多增加1（每个循环我增加1）。所以，这里没有问题；在“最坏”的情况下，这是
mi_数组[i]=mi_数组[i]；
，它什么都不做

但是

这是一个更大的问题。给定输入
{9,4,0,0,4,0,3,0,1,8,0}；
，当
i
为2时，则
mi_数组[i]
为0，因此此代码运行。
y
仍然为10，因此这将运行：
mi_数组[10]=0；
。第二个0出现在
i
为3时，并运行：
mi_数组[9]=0；
。此时，索引9处的
8
已删除它。它无法恢复

解决方案
愚蠢的解决方案是制作数组的副本；编辑副本，参考原始数组（您根本不会更改）。您实际上不需要副本；此代码会将每个数字写回，所以只需制作一个相同大小的新数组并写入其中即可

稍微优雅一点的解决方案根本不写0。相反，它只写非零（因为代码不能覆盖任何内容，如前所示），然后在最后用零覆盖其余部分。现在您不需要副本。
O（n）
，双指针方法：

public static void shiftZeroesRight(int[] array) {    
    int notZeroPos;
    for (int i = 0; i < array.length; i++) {
        if (array[i] != 0)
            continue;

        notZeroPos = i + 1;
        while (notZeroPos < array.length && array[notZeroPos] == 0)
            ++notZeroPos;
    
        if (notZeroPos >= array.length)
            break;
    
        array[i] = array[notZeroPos];
        array[notZeroPos] = 0;
    }    
}

publicstaticvoidshiftzerosright（int[]数组）{
int notZeroPos；
for（int i=0；i=array.length）
打破
数组[i]=数组[notZeroPos]；
数组[notZeroPos]=0；
}    
}
试试这个

int[] mi_array = {9, 4, 0, 0, 4, 0, 3, 0, 1, 8, 0};
for (int i = 0, j = i + 1, s = mi_array.length; j < s;)
    if (mi_array[i] == 0) {
        mi_array[i] = mi_array[j];
        mi_array[j] = 0;
        ++j;
    } else if (++i >= j)
        j = i + 1;
System.out.println(Arrays.toString(mi_array));
// -> [9, 4, 4, 3, 1, 8, 0, 0, 0, 0, 0]

int[]mi_数组={9,4,0,0,4,0,3,0,1,8,0}；
对于（int i=0，j=i+1，s=mi_array.length；j=j）
j=i+1；
System.out.println（Arrays.toString（mi_数组））；
// -> [9, 4, 4, 3, 1, 8, 0, 0, 0, 0, 0]
实际上，非零应该放在左边，我表示自己错了，顺序不重要
public static void shiftZeroesRight(int[] array) {    
    int notZeroPos;
    for (int i = 0; i < array.length; i++) {
        if (array[i] != 0)
            continue;

        notZeroPos = i + 1;
        while (notZeroPos < array.length && array[notZeroPos] == 0)
            ++notZeroPos;
    
        if (notZeroPos >= array.length)
            break;
    
        array[i] = array[notZeroPos];
        array[notZeroPos] = 0;
    }    
}

int[] mi_array = {9, 4, 0, 0, 4, 0, 3, 0, 1, 8, 0};
for (int i = 0, j = i + 1, s = mi_array.length; j < s;)
    if (mi_array[i] == 0) {
        mi_array[i] = mi_array[j];
        mi_array[j] = 0;
        ++j;
    } else if (++i >= j)
        j = i + 1;
System.out.println(Arrays.toString(mi_array));
// -> [9, 4, 4, 3, 1, 8, 0, 0, 0, 0, 0]