Question

以下是删除空值的两种方法，哪种方法最好？

public static String[] clean(final String[] v) {
    List<String> list = new ArrayList<String>(Arrays.asList(v));
    list.removeAll(Collections.singleton(null));
    return list.toArray(new String[list.size()]);
}

public static String[] clean(final String[] v) {
    List<String> list = new ArrayList<String>(v.length);
     for (String aString : v)
        {
            if (aString != null)
            {
                list.add(aString);
            }
        }
    return list.toArray(new String[list.size()]);
}

Answer 1

为了从单个字符串中删除空值，我会使用像这样的正则表达式

private static Pattern pattern = Pattern.compile("(?i)[(\\[{]?null[)\\]}]?");

    public static String removeNullString(String value) {
        if (StringUtils.isEmpty(value)) {
            return StringUtils.EMPTY;
        }

        Matcher matcher = pattern.matcher(value);
        return matcher.replaceAll(StringUtils.EMPTY);
    }

它掩盖了所有＆＃34; null＆＃34;和字符串中的空字符。

用于从Java 7中的字符串数组中删除空值，

String[] firstArray = {"test1", "", "test2", "test4", "", null};

    List<String> list = new ArrayList<String>();

    for(String s : firstArray) {
       if(s != null && s.length() > 0) {
          list.add(s);
       }
    }

    firstArray = list.toArray(new String[list.size()]);

用于从Java 8中的字符串数组中删除空值，

String[] firstArray = {"test1", "", "test2", "test4", "", null};

firstArray = Arrays.stream(firstArray)
                     .filter(s -> (s != null && s.length() > 0))
                     .toArray(String[]::new);

Answer 2

性能方面，通常最好将最小化调用放在当前代码块（即方法）的范围之外。此外，由于与大多数其他指令相比，内存分配相对较慢，因此避免对象创建通常是目标。在性能方面我能想到的最好（我选择使它足够灵活，可以采用任何类型的阵列）：

public <T> T[] removeNulls(Class<T> type, final T[] original){

    // first, shift all non-null instances to the head, all nulls to the end.
    int nonNullCount=0;
    T tempT = null;

    for(int i=0; i < original.length; i++){
        if(original[i] != null){
            nonNullCount++;
        }else if(i != original.length - 1){
            // Swap the next non-null value with this null value
            int j = i + 1;
            // In case there are multiple null values in a row
            // scan ahead until we find the next non-null value
            while(j < original.length && (tempT = original[j]) == null){
                j++;
            }
            original[nonNullCount] = tempT;
            if(tempT != null){
                nonNullCount++;
            }
            if(j < original.length){
                original[j] = null;
            }

            i = j - 1;
        }
    }

    // The case where there are no nulls in the array
    if(nonNullCount == original.length){
        return original;
    }

    final T[] noNulls = (T[]) Array.newInstance(type,nonNullCount);
    System.arraycopy(original,0,noNulls,0,nonNullCount);
    return  noNulls;
}

但我不确定为什么当性能不太可能成为问题时，你会希望3或4行的这种复杂性做同样的事情。您需要使用HUGE数组才能看到我的代码和干净的示例之间的任何好处（如果有的话）。

Answer 3

在Java 8中，您应该可以执行以下操作：

List<String> list = new ArrayList<String>(Arrays.asList(v));
list.removeIf(Objects::isNull);
return list.toArray(new String[list.size()]);

Answer 4

如果你想在同一个空间里做，我会建议以下解决方案。但是最终阵列也将具有相同的大小。我的意思是它不会缩小尺寸，但所有元素都会以相同的顺序聚合。

   public static void removeNullFromArray(String[] args) {
      int location = 0;
      for(int i=0;  i<args.length; i++){
         String arg = args[i];
         if(arg!=null){
            if(location<i){
               args[location] = arg;
               args[i] = null;
            }
            location++;
         }
      }
   }

Answer 5

使用流和lambda的Java 8代码。从数组中过滤出非null并转换为列表。

Arrays.stream(arr).filter(Objects::nonNull).collect(Collectors.toList());

从字符串数组

5 个答案: