java collections读书笔记（3） vector(2)

打印vector：

可以调用tostring方法。

删除所有元素：

public void clear()
public void removeAllElements()

从内部源代码可知，clear就是调用了removeAllElements而已。

但是注意，这时候，vector的容量是不变的。

删除某个元素：

public Object remove(int index)
public void removeElementAt(int index) ：从源代码来看，只是把index位置后面的元素往前移动一位，调用的是System.arraycopy,然后最后一位指定为null。

这两个函数，源代码意思差不多，怎么写的差异这么大呢？

  public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        E oldValue = elementData(index);

        int numMoved = elementCount - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--elementCount] = null; // Let gc do its work

        return oldValue;
    }

 public synchronized void removeElementAt(int index) {
        modCount++;
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        int j = elementCount - index - 1;
        if (j > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        elementCount--;
        elementData[elementCount] = null; /* to let gc do its work */
    }

删除某个对象,但是不知道其位置：

public boolean remove(Object element)
public boolean removeElement(Object element)

remove内部调用了removeElement；

有多个对象，至删除第一个。

Integer my=new Integer(1000);
    v.add(my);
    v.add(my);
    
    
    System.out.println(v.toString());
    System.out.println(v);
    v.remove(my);
    System.out.println(v);
    v.remove(my);
    System.out.println(v);
   

如果想删除所有，则用，removeall

Integer my=new Integer(1000);
    v.add(my);
    v.add(my);
    
    
    System.out.println(v.toString());
    System.out.println(v);
    Vector dd=new Vector();
    dd.add(my);
    v.removeAll(dd);
    System.out.println(v);
    v.remove(my);
    System.out.println(v);
   

retainAll和removeall相反，只保留那些东西，哈。

替换元素：

public Object set(int index, Object element)
public void setElementAt(Object obj, int index)

vector容量：

size（）：标识vector内现有元素的多少；

vector的不变性：

  如何使vector里的值不变:

Vector v = new Vector();
// fill vector
List l = Collections.unmodifiableList(v);

 

对vector里的数据的操作：

1）获取数据：

   public Object get(int index)
public Object elementAt(int index)

 这里需要注意类型的抓换：

Vector v = new Vector();
v.add("Hello");
String s = (String)v.get(0);

public Object firstElement()
public Object lastElement()

获得元素的第一个和最后一个值。

vector的枚举实现：

Enumeration e = v.elements();
while (e.hasMoreElements()) {
process(e.nextElement());
}

 

vector继承自AbstractList，有3个方法没有override：

public Iterator iterator()
public ListIterator listIterator()
public ListIterator listIterator(int index)

 

多维度vector：

MyType o = (MyType)((Vector)vector.elementAt(3)).elementAt(2);

如何查找元素：

contains：这个实际上是调用了indexof判断是否存在。这里可以对空元素进行判断：

public synchronized int indexOf(Object o, int index) {
        if (o == null) {
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

 

lastindexof，从尾部判断第一个存在的位置：

 public synchronized int lastIndexOf(Object o, int index) {
        if (index >= elementCount)
            throw new IndexOutOfBoundsException(index + " >= "+ elementCount);

        if (o == null) {
            for (int i = index; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

public boolean containsAll(Collection c)判断是否尤其子类：

克隆vector：

Vector v1 = . . .;
Vector v2 = (Vector)v1.clone();
Collections.sort(v2);

 public synchronized Object clone() {
        try {
            @SuppressWarnings("unchecked")
                Vector<E> v = (Vector<E>) super.clone();
            v.elementData = Arrays.copyOf(elementData, elementCount);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
    }

Vector v = . . .;
String array[] = new String[v.size()];
v.copyInto(array);

 public synchronized void copyInto(Object[] anArray) {
        System.arraycopy(elementData, 0, anArray, 0, elementCount);
    }

 

vector类中的常量和变量：

protected int capacityIncrement
protected int elementCount
protected Object[] elementData

element是以数组的形式存到elementData里的。

elementCount标识当前元素的数量。