如何在java中从数组中删除null

我已经编写了一个方法来从程序中需要的数组中删除空值。 然而，该方法似乎不起作用，空值不会消失。这是到目前为止我的代码

public void removeNull(String[] a)
{
       for(int i=0; i<a.length; i++)
    {
        if(a[i] == null)
        {
            fillArray(a, i);
        }
    }
}

public void fillArray(String[] a, int i)
{
    String[] a2 = new String[a.length-1];

    for(int j=0; j<a2.length; j++)
    {
            if(j<i)
            {
                a2[j]=a[j];
            }
        else if(j>i)
        {
            a2[j]=a[j+1];
        }
    }

    a=a2;
}

public void removeNull（字符串[]a）
{
对于（inti=0；i，您不能在方法中更改对变量的引用，并期望它反映在调用方法中

您将不得不返回新数组

public String[] removeNull(String[] a)
{
    for(int i=0; i<a.length; i++)
    {
        if(a[i] == null)
        {
            a = fillArray(a, i);
        }
    }

    return a;
}

public String[] fillArray(String[] a, int i)
{
    String[] a2 = new String[a.length-1];

    for(int j=0; j<a2.length; j++)
    {
            if(j<i)
            {
                a2[j]=a[j];
            }
        else if(j>i)
        {
            a2[j]=a[j+1];
        }
    }

    return a2;
}

public String[]removeNull（String[]a）
{
对于（int i=0；i我可以在代码中看到两个错误：


您的方法
fillArray
不包括案例
i==j
您的赋值
a=a2；
没有您认为可能具有的效果。在Java中，参数是按值传递的，并且您的赋值不会更改第一个方法中
a
的值。请尝试在
fillArray
中将实例返回到
a2
，并在
removeNull>中将此值赋值给
a

有几件事：

你不想成为
String[]a2=新字符串[a.length-1]；`
String[]a2=新字符串[a.length]；

让它
length-1
会不会让它太短

在代码中需要一个
i==j
的案例。这就是为什么空值没有得到更新

你想用第二个函数解决什么问题？考虑到我认为你的问题很复杂

试试这个（我没有测试）：

除非性能确实存在问题，否则我主张采用简单的方法：

public String[] removeNull(String[] a) {
   ArrayList<String> removedNull = new ArrayList<String>();
   for (String str : a)
      if (str != null)
         removedNull.add(str);
   return removedNull.toArray(new String[0]);
}

public String[]removeNull（String[]a）{
ArrayList removedNull=新的ArrayList（）；
for（字符串str:a）
如果（str！=null）
removedNull.add（str）；
返回removedNull.toArray（新字符串[0]）；
}
删除数组中的值时，大小会发生变化，因此无法保留相同的数组（可以在末尾推送空值）

靠近具有自动调整大小的数组的结构是ArrayList。一个选项是：

String[] inputs;
List<String> items = new ArrayList<String>(inputs.length);
for(String input : inputs) {
   if (input != null) {
      items.add(input);
   }
}
String[] outputs = items.toArray(new String[items.size()]);

String[] strings;
int writeIndex = 0;
int max = strings.length;
for(int readIndex = 0; readIndex < max; readIndex++) {
   String read = strings[readIndex];
   if (read != null) {
      strings[writeIndex++] = read;
   }
}
String[] outputs = new String[writeIndex];
System.arraycopy(strings, 0, ouputs, 0, writeIndex);

String[]输入；
列表项=新的ArrayList（inputs.length）；
for（字符串输入：输入）{
如果（输入！=null）{
项目。添加（输入）；
}
}
字符串[]输出=items.toArray（新字符串[items.size（）]）；


性能可能比直接使用阵列稍差，但由于阵列具有固定大小，因此需要使用两个阵列循环：


一个用于计算非空值的数量
构建数组后，使用相同的循环复制值

这可能也不会有理想的性能，而且要使其正确运行实际上要复杂得多


另一种方法是移动末尾的空值，然后创建一个不包含空值的较短数组。其思想是：

String[] inputs;
List<String> items = new ArrayList<String>(inputs.length);
for(String input : inputs) {
   if (input != null) {
      items.add(input);
   }
}
String[] outputs = items.toArray(new String[items.size()]);

String[] strings;
int writeIndex = 0;
int max = strings.length;
for(int readIndex = 0; readIndex < max; readIndex++) {
   String read = strings[readIndex];
   if (read != null) {
      strings[writeIndex++] = read;
   }
}
String[] outputs = new String[writeIndex];
System.arraycopy(strings, 0, ouputs, 0, writeIndex);

String[]字符串；
int writeIndex=0；
int max=strings.length；
对于（int readIndex=0；readIndex
这样，您可以在一个周期内删除空值，但它不会调整数组的大小：

public static void removeNull(String[] a) {
    int nullCount = 0;
    for (int i = 0; i < a.length; i++) {
        if (a[i] == null) {
            nullCount++;
        } else {
            a[i-nullCount] = a[i];
        }
    }
}

publicstaticvoidremovenull（字符串[]a）{
int nullCount=0；
for（int i=0；i

这将创建新阵列，但包括两个周期：

public static String[] removeNull(String[] a) {
    int nullCount = 0;
    for (int i = 0; i < a.length; i++) {
        if (a[i] == null) nullCount++;
    }
    String[] b = new String[a.length-nullCount];
    int j = 0;
    for (int i = 0; i < a.length; i++) {
        if (a[i] != null) b[j++] = a[i];
    }
    return b;
}

公共静态字符串[]removeNull（字符串[]a）{
int nullCount=0；
for（int i=0；i

您可以考虑使用
System.arraycopy
优化该代码。我希望该代码能够正常工作。
您有两个选择：

创建长度与输入相同的新数组，然后为其分配NOTNULL值，并将减法添加到NOTNULL元素的计数中

答案中的示例

如果只需要使用sutch阵列，可以为其创建适配器

public class NullProofIterable<T> implements Iterable<T>{

private final T[] array;

public NullProofIterable(T[] array){
    this.array = array;
}

@Override
public Iterator<T> iterator() {
    return new NullProofIterator<T>(this.array);
}


private static class NullProofIterator<T> implements Iterator<T> {

    private final T[] array;
    private final int index = 0;

    private NullProofIterator(T[] array) {
        this.array = array;
    }

    @Override
    public boolean hasNext() {

        return this.index < this.array.length;
    }

    @Override
    public T next() {
        return this.array[this.index];
    }

    @Override
    public void remove() {
        throw new RuntimeException("Remove not allowed in this iterator");
    }

}

}

public类NullProofIterable实现了Iterable{
私有final T[]数组；
公共可防空（T[]数组）{
this.array=数组；
}
@凌驾
公共迭代器迭代器（）{
返回新的NullProof迭代器（this.array）；
}
私有静态类NullProof迭代器实现迭代器{
私有final T[]数组；
私有最终整数指数=0；
私有NullProof迭代器（T[]数组）{
this.array=数组；
}
@凌驾
公共布尔hasNext（）{
返回this.index

那么在源代码中，您唯一需要做的就是：

for(String str : new NullProofIterable<String>(strArray)) {
    //Perform action on not null string         
}

for（String str:new nullprofectiteable（strArray））{
//对非空字符串执行操作
}

第二个选项是！=null条件的奇特用法，但当方法需要返回一些数据时，它可能会很有用。
好吧，以前有更多的人这么说……但我还想强调这个解决方案：

您可以使用某种类型的集合，如ArrayList或List，并仅添加NOTNULL元素。最后，您必须返回集合形成的新字符串[]

下面是一个可以检查正确性的示例：

import java.util.ArrayList;

public class NullRemove {

    public static String[] removeNull(String[] a) {
        ArrayList<String> aux = new ArrayList<String>();
        for (String elem : a) {
            if (elem != null) {
                aux.add(elem);
            }
        }
        return (String[]) aux.toArray(new String[aux.size()]);
    }
    public static void main(String[] args) {
        String[] init = new String[]{"aaa", null, "bbb", "ccc", null, "ddd", 
            "eee", "fff", null};

        String[] result = NullRemove.removeNull(init);

        System.out.println("Start Check result");

        for (String elem : result) {
            if (elem == null) System.out.println("NULL element");
        }

        System.out.println("End Check result");
    }
}

import java.util.ArrayList；
公共类NullRemove{
公共静态字符串[]removeNull（字符串[]a）{
ArrayList aux=新的ArrayList（）；
用于（字符串元素：a）{
if（elem！=null）{
附加条款（要素）；
}
}
返回（字符串[]）