Как удалить все нулевые элементы из ArrayList или String Array?

Я пытаюсь с такой петлей

// ArrayList tourists

for (Tourist t : tourists) {
    if (t != null) {     
        t.setId(idForm); 
    }   
}

Но это не приятно. Кто-нибудь может предложить мне лучшее решение?

Некоторые полезные ориентиры для принятия лучшего решения:

Цикл while, цикл For и тест производительности итератора

Пытаться:

tourists.removeAll(Collections.singleton(null));

Прочитайте API Java . Код будет выбрасывать java.lang.UnsupportedOperationExceptionдля неизменяемых списков (например, созданных с помощью Arrays.asList); см. этот ответ для более подробной информации.

По состоянию на 2015 год это лучший способ (Java 8):

tourists.removeIf(Objects::isNull);

Примечание. Этот код генерирует java.lang.UnsupportedOperationExceptionсписки фиксированного размера (например, созданные с помощью Arrays.asList), включая неизменяемые списки.

list.removeAll(Collections.singleton(null));

Будет выброшено исключение UnsupportedException, если вы используете его в Arrays.asList, потому что оно дает вам неизменяемую копию, поэтому ее нельзя изменить. Смотрите ниже код. Он создает изменяемую копию и не будет выдавать никаких исключений.

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()]);
}

Не эффективно, но коротко

while(tourists.remove(null));

Если вы предпочитаете неизменяемые объекты данных или просто не хотите быть разрушительными для списка ввода, вы можете использовать предикаты Guava.

ImmutableList.copyOf(Iterables.filter(tourists, Predicates.notNull()))

 for (Iterator<Tourist> itr = tourists.iterator(); itr.hasNext();) {
      if (itr.next() == null) { itr.remove(); }
 }

Перед Java 8 вы должны использовать:

tourists.removeAll(Collections.singleton(null));

Использование после Java 8:

tourists.removeIf(Objects::isNull);

Причина здесь в сложности времени. Проблема с массивами состоит в том, что операция удаления может занять O (n) времени для завершения. На самом деле в Java это копия массива оставшихся элементов, перемещаемых для замены пустого места. Многие другие решения, предлагаемые здесь, вызовут эту проблему. С технической точки зрения первый O (n * m), где m равно 1, потому что это одиночный ноль: поэтому O (n)

Вы должны удалить все синглтоны, внутренне это выполняет batchRemove (), который имеет позицию чтения и позицию записи. И повторяет список. Когда он достигает нуля, он просто повторяет позицию чтения на 1. Когда они одинаковы, он проходит, когда они отличаются, он продолжает двигаться, копируя значения. Тогда в конце это урезает к размеру.

Это эффективно делает это внутренне:

public static <E> void removeNulls(ArrayList<E> list) {
    int size = list.size();
    int read = 0;
    int write = 0;
    for (; read < size; read++) {
        E element = list.get(read);
        if (element == null) continue;
        if (read != write) list.set(write, element);
        write++;
    }
    if (write != size) {
        list.subList(write, size).clear();
    }
}

То, что вы можете явно видеть, является операцией O (n).

Единственное, что может быть быстрее, - это если вы перебираете список с обоих концов, и когда вы находите ноль, вы устанавливаете его значение равным значению, которое вы нашли в конце, и уменьшаете его. Итерировали, пока два значения не совпали. Вы бы испортили порядок, но значительно сократили бы количество установленных вами значений по сравнению с теми, которые вы оставили в покое. Это хороший способ узнать, но он не сильно поможет, поскольку .set () в основном бесплатен, но эта форма удаления является полезным инструментом для вашего пояса.

for (Iterator<Tourist> itr = tourists.iterator(); itr.hasNext();) {
      if (itr.next() == null) { itr.remove(); }
 }

Хотя это кажется достаточно разумным, .remove () внутри итератора вызывает:

ArrayList.this.remove(lastRet);

Что снова является операцией O (n) при удалении. Он выполняет System.arraycopy (), что опять-таки не то, что вам нужно, если вы заботитесь о скорости. Это делает это п ^ 2.

Есть также:

while(tourists.remove(null));

Который есть O (m * n ^ 2). Здесь мы не только перебираем список. Мы повторяем весь список, каждый раз, когда мы совпадаем с нулем. Затем мы делаем n / 2 (средние) операции, чтобы выполнить System.arraycopy () для удаления. Вы можете буквально отсортировать всю коллекцию между элементами со значениями и элементами с нулевыми значениями и обрезать окончание за меньшее время. На самом деле, это верно для всех сломанных. По крайней мере теоретически, фактическая system.arraycopy на самом деле не является операцией N на практике. В теории теория и практика - это одно и то же; на практике это не так.

Существует простой способ удаления всех nullзначений из. collectionВам нужно передать коллекцию, содержащую ноль, в качестве параметра removeAll()метода

List s1=new ArrayList();
s1.add(null);

yourCollection.removeAll(s1);

ObjectsКласс имеет , nonNull Predicateкоторый может быть использован с filter.

Например:

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

Используя Java 8, вы можете сделать это, используя stream()иfilter()

tourists = tourists.stream().filter(t -> t != null).collect(Collectors.toList())

или

tourists = tourists.stream().filter(Objects::nonNull).collect(Collectors.toList())

Для получения дополнительной информации: Java 8 - Streams

Это простой способ удалить значения по умолчанию из массива

     tourists.removeAll(Arrays.asList(null));  

в противном случае строковое значение "null" удалить из массива

       tourists.removeAll(Arrays.asList("null"));  

Я поиграл с этим и обнаружил, что trimToSize (), кажется, работает. Я работаю на платформе Android, поэтому она может отличаться.

Мы можем использовать итератор для того же самого, чтобы удалить все нулевые значения.

Iterator<Tourist> itr= tourists.iterator();
while(itr.hasNext()){
    if(itr.next() == null){
        itr.remove();
    }
}

Я использовал интерфейс потока вместе с операцией сбора потока и вспомогательным методом для создания нового списка.

tourists.stream().filter(this::isNotNull).collect(Collectors.toList());

private <T> boolean isNotNull(final T item) {
    return  item != null;
}

В основном я использую это:

list.removeAll(Collections.singleton(null));

Но после того, как я выучил Java 8, я переключился на это:

List.removeIf(Objects::isNull);

Используя Java 8, это может быть выполнено различными способами, используя потоки, параллельные потоки и removeIfметод:

List<String> stringList = new ArrayList<>(Arrays.asList(null, "A", "B", null, "C", null));
List<String> listWithoutNulls1 = stringList.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList()); //[A,B,C]
List<String> listWithoutNulls2 = stringList.parallelStream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList()); //[A,B,C]
stringList.removeIf(Objects::isNull); //[A,B,C]

Параллельный поток будет использовать доступные процессоры и ускорит процесс для списков разумного размера. Перед использованием потоков рекомендуется всегда проводить сравнительный анализ.

Аналогичен ответу @Lithium, но не выдает ошибку «Список может не содержать тип null»:

   list.removeAll(Collections.<T>singleton(null));

List<String> colors = new ArrayList<>(
Arrays.asList("RED", null, "BLUE", null, "GREEN"));
// using removeIf() + Objects.isNull()
colors.removeIf(Objects::isNull);