Qual é a diferença entre ArrayList.clear () e ArrayList.removeAll ()?

Supondo que arraylistseja definido como ArrayList<String> arraylist, é arraylist.removeAll(arraylist)equivalente a arraylist.clear()?

Em caso afirmativo, posso assumir que o clear()método é mais eficiente para esvaziar a lista de matrizes?

Existem advertências no uso em arraylist.removeAll(arraylist)vez de arraylist.clear()?

O código fonte para clear():

public void clear() {
    modCount++;

    // Let gc do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

O código-fonte para removeAll()(conforme definido em AbstractCollection):

public boolean removeAll(Collection<?> c) {
    boolean modified = false;
    Iterator<?> e = iterator();
    while (e.hasNext()) {
        if (c.contains(e.next())) {
            e.remove();
            modified = true;
        }
    }
    return modified;
}

clear() é muito mais rápido, pois não precisa lidar com todas essas chamadas de método extras.

E, como aponta Atrey, c.contains(..)aumenta a complexidade do tempo removeAllpara O (n ² ) em oposição ao clearO (n).

A complexidade temporal de ArrayList.clear()é O(n)e de removeAllé O(n^2).

Então, sim, ArrayList.clearé muito mais rápido.

O clear()método remove todos os elementos de um único ArrayList. É uma operação rápida, pois apenas define os elementos da matriz null.

O removeAll(Collection)método, que é herdado AbstractCollection, remove todos os elementos que estão na coleção de argumentos da coleção em que você chama o método. É uma operação relativamente lenta, pois precisa pesquisar em uma das coleções envolvidas.

A menos que haja uma otimização específica que verifique se o argumento passado removeAll()é a própria coleção (e duvido muito que essa otimização esteja lá), será significativamente mais lento que um simples .clear().

Além disso (e pelo menos igualmente importante): arraylist.removeAll(arraylist)é apenas um código obtuso e confuso. É uma maneira muito atrasada de dizer "limpe esta coleção". Que vantagem teria sobre o muito compreensível arraylist.clear() ?

Eles servem a propósitos diferentes. clear()limpa uma instância da classe, removeAll()remove todos os objetos fornecidos e retorna o estado da operação.

clear() percorrerá a matriz subjacente e definirá cada entrada como nula;

removeAll(collection)passará pelo ArrayList verificando a coleção e remove(Object), se existir.

Eu imagino que clear()é muito mais rápido do que removeAll, porque não está comparando, etc.

A limpeza é mais rápida porque não faz loop sobre os elementos a serem excluídos. Este método pode assumir que TODOS os elementos podem ser excluídos.

Remove allnão significa necessariamente excluir todos os elementos da lista, apenas aqueles fornecidos como parâmetros DEVEM ser excluídos. Portanto, é necessário mais esforço para manter aqueles que não devem ser excluídos.

ESCLARECIMENTO

Por 'loop', quero dizer que não é necessário verificar se o elemento deve ser mantido ou não. Pode definir a referência nullsem pesquisar nas listas de elementos fornecidas a serem excluídas.

ClearÉ mais rápido que deleteall.

clear () será muito mais eficiente. Simplesmente removerá todos os itens. O uso de removeAll (arraylist) exigirá muito mais trabalho, pois verificará todos os itens do arraylist para ver se ele existe no arraylist antes de removê-lo.

Matriz => depois que o espaço é alocado para uma variável Matriz no tempo de execução, o espaço alocado não pode ser estendido ou removido.

ArrayList => Este não é o caso no arraylist. ArrayList pode aumentar e diminuir no tempo de execução. O espaço alocado pode ser minimizado ou maximizado no tempo de execução.