java 集合 Arraylist<Character> list怎么移除字符？ list.remove('的')不管用

Posted 2023-03-31

参考技术A list.remove('的')是可以的，但是只能移除一个，最低索引的那个。
如果想要移除所有的'的'。
建议使用Iterator循环，并使用Iterator的remove方法移除：
for(Iterator<Character>
iterator
=
list.iterator();iterator.hasNext();)

char
c
=
iterator.next();
if
(c
==
'的')

iterator.remove();


移除list中包含另一个Set集合中的所有元素：
public
boolean
removeAll(Collection<?>
c)
试试这个方法。
此时删除的是list中所有的和Set的相同部分。
所以
要删除所以的
'的'也可以用这种方法，
new一个容器c2，里面就放一个'的'然后对list调用removeAll(c2)

Java集合源码分析—ArrayList

ArrayList源码分析

ArrayList结构

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList继承自AbstractList，实现了List、RandomAccess、cloneable、Serializable接口，支持随机访问、克隆和序列化。和Vector不同，ArrayList不是线程安全的容器，所以，建议在单线程中使用它，而在多线程中使用Vector或CopyOnWriteArrayList，或者用synchronizedList将其包装。

源码分析

属性

// 序列号
private static final long serialVersionUID = 8683452581122892189L;

// ArrayList的默认初始容量
private static final int DEFAULT_CAPACITY = 10;

// 当实例化是指定容量为0时，返回该数组
private static final Object[] EMPTY_ELEMENTDATA = ;

// 空数组，实例化时没有指定容量，返回该数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = ;

// 当前数据存放的地方
transient Object[] elementData; // non-private to simplify nested class access

// ArrayList中存储的数据量
private int size;

// 集合数组被修改次数标识
protected transient int modCount = 0;

构造

// 创建一个指定初始容量大小的ArrayList
public ArrayList(int initialCapacity) 
    if (initialCapacity > 0) 
        this.elementData = new Object[initialCapacity];
     else if (initialCapacity == 0) 
        this.elementData = EMPTY_ELEMENTDATA;
     else 
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    


// 没有指定初始容量时，返回一个指定的空数组
// 当第一次add时，会扩容为10
public ArrayList() 
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;


// 用collection创建一个ArrayList
public ArrayList(Collection<? extends E> c) 
    // 把集合转化为Object[]数组
    elementData = c.toArray();
    // 直接将数组长度赋值给size
    if ((size = elementData.length) != 0) 
        // 如果不是Object[]数组，利用copyOf构造一个Object[]数组
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
     else 
        // 如果size为0，就用空数组替换
        this.elementData = EMPTY_ELEMENTDATA;
    

方法

add(E e)

public boolean add(E e) 
    // 确保内部容量足够
    ensureCapacityInternal(size + 1);  
    // 将数据放在size上，将size++
    elementData[size++] = e;
    return true;

private void ensureCapacityInternal(int minCapacity) 
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));

private static int calculateCapacity(Object[] elementData, int minCapacity) 
    // 第一次添加数据，便取10
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) 
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    
    return minCapacity;

private void ensureExplicitCapacity(int minCapacity) 
    modCount++;

    // 当元素个数大于数组容量，就需要扩容
    if (minCapacity - elementData.length > 0)
        // 扩容
        grow(minCapacity);

private void grow(int minCapacity) 
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 扩容1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 第一次扩容 0 - 10 < 0,所以取10
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 拷贝到新数组
    elementData = Arrays.copyOf(elementData, newCapacity);

void add(int index,E element)

public void add(int index, E element) 
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;


//检查下标是否越界
private void rangeCheckForAdd(int index) 
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

remove(int index)

public E remove(int index) 
    rangeCheck(index);

    modCount++;
    
    // 保存将要移除的旧值
    E oldValue = elementData(index);

    // 要移动的数组长度
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;

remove(Object o)

public boolean remove(Object o) 
    if (o == null) 
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) 
                fastRemove(index);
                return true;
            
     else 
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) 
                fastRemove(index);
                return true;
            
    
    return false;

private void fastRemove(int index) 
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work

trimToSize()

// 将数组大小调整到ArrayList存储元素的大小
public void trimToSize() 
    modCount++;
    if (size < elementData.length) 
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    

clear()

public void clear() 
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;

indexOf(Object o)

public int indexOf(Object o) 
    if (o == null) 
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
     else 
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    
    return -1;

contains(Object o)

public boolean contains(Object o) 
    return indexOf(o) >= 0;