集合(一)Collection、List、ArrayList和Vector

一、Collection

集合存放在java.util包中，可以看作是集成好的数据结构，供你调用，十分方便，集合经常拿来和数组对比，其实我觉得没啥可比性，不过还是简单来看看它们的区别：

1.数组长度固定，而集合长度不固定。

2.集合只能存储对象，但数组不仅能存储基本类型还有对象数组。

3.集合存储的是对象的引用，对象本身不连续(待证实)，而数组元素与元素内存连续。

4.一个数组只能存相同的数据类型，集合能存不同的数据类型。(补充例子)

先来张图，话说好像是第一次上图。。。

图1来源： http://www.cnblogs.com/taiwan/p/6954135.html 

图2出处：http://www.cnblogs.com/skywang12345/p/io_07.html

 

这两个图展示了基本集合的关系，暂时也考虑按这个顺序来复习。Collection和Map是两个根接口，互不影响。

二、List

上篇也说到了List其实是一个接口，并且实现父接口Collection，实现它的类有ArrayList、Vector和LinkedList。

但基本上的使用方法都是：List l=new ArrayList(); List l=new Vector(); 

Collection和List的方法包括(均为JDK1.7的基本功能、例如Collection接口1.8版本新增4个功能 注：removeIf spliterator stream parallelStream，List接口新增3个功能 注：spliterator replaceAll sort)：

abstract boolean         add(E object)
abstract boolean         addAll(Collection<? extends E> collection)
abstract void            clear()
abstract boolean         contains(Object object)
abstract boolean         containsAll(Collection<?> collection)
abstract boolean         equals(Object object) 
abstract int             hashCode()           //equal和hashCode两个方法Object也有，Collection和List都是覆盖过的。
abstract boolean         isEmpty()            //注：Vector也有覆盖，但ArrayList和LinkedList没有。
abstract Iterator<E>     iterator()
abstract boolean         remove(Object object)
abstract boolean         removeAll(Collection<?> collection)
abstract boolean         retainAll(Collection<?> collection)
abstract int             size()
abstract <T> T[]         toArray(T[] array)
abstract Object[]        toArray()

 ————————————————上面是Collection，下面是List————————————————

abstract void                add(int location, E object)
abstract boolean             addAll(int location, Collection<? extends E> collection)
abstract E                   get(int location)
abstract int                 indexOf(Object object)
abstract int                 lastIndexOf(Object object)
abstract ListIterator<E>     listIterator(int location)
abstract ListIterator<E>     listIterator()
abstract E                   remove(int location)
abstract E                   set(int location, E object)
abstract List<E>             subList(int start, int end)

 而对于实现List接口的主要三个数据结构分别是ArrayList、Vector、LinkedList，其中ArrayList和Vector是很类似的，都类似于可变长的对象数组，但是ArrayList不是线程安全的，而Vector是线程安全的，这个到学习线程部分再详说吧，暂时先理解为适合单线程和多线程。LinkedList则是链表(线程不安全，其实集合类中Vector、Stack、Hashtable和Enumeration是线程安全的，其余都是线程不安全的)，适合增删操作较多时，那两个比较适合遍历操作，面向的任务不同。

1.对于ArrayList来说，新增的方法如下：

Object               clone()
void                 ensureCapacity(int minimumCapacity)
void                 trimToSize()
void                 removeRange(int fromIndex, int toIndex)

ArrayList是一个类，实现List接口，成员域有两个，分别为：
private int size; // 实际元素个数
transient Object[] elementData;  //数组存放内容
构造函数有3个，无参构造函数，capacity=10，size=0(但其实其中过程较为复杂，ArrayList是在添加第一个元素时才实现了初始容量为10的构造，
可以参考https://blog.csdn.net/jdsjlzx/article/details/52675726和https://blog.csdn.net/m0_37884977/article/details/80514809)；
以initialCapacity 参数的构造函数，capacity=initialCapacity size=0；以Collection为参数的构造函数，size=capacity=原Collection的size；

    package list;
    
    import java.lang.reflect.Field;
    import java.util.ArrayList;
    
    public class Capacity {
    
        public static void main(String[] args) {
//          ArrayList <Integer> al=new ArrayList<Integer>();
//            ArrayList <Integer> al=new ArrayList<Integer>(4);
            ArrayList <Integer> bl=new ArrayList<Integer>();
            for(int i=0;i<9;i++)
            {
                bl.add(i);
            }
            ArrayList <Integer> al=new ArrayList<Integer>(bl);
            System.out.println(al.size());
            System.out.println(getArrayListCapacity(al));
            al.add(1);
            System.out.println(al.size());
            System.out.println(getArrayListCapacity(al));
            for(int i=0;i<9;i++)
            {
                al.add(i);
            }
            System.out.println(al.size());
            System.out.println(getArrayListCapacity(al));
            al.add(11);
            System.out.println(al.size());
            System.out.println(getArrayListCapacity(al));
            for(int i=0;i<5;i++)
            {
                al.add(i);
            }
            System.out.println(al.size());
            System.out.println(getArrayListCapacity(al));
    
        }
        public static int getArrayListCapacity(ArrayList<?> arrayList) {
            Class<ArrayList> arrayListClass = ArrayList.class;
            try {
                Field field = arrayListClass.getDeclaredField("elementData");
                field.setAccessible(true);
                Object[] objects = (Object[])field.get(arrayList);
               return objects.length;
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
                return -1;
            } catch (IllegalAccessException e) {
                e.printStackTrace();
                return -1;
            }
        }
    
    }

当容量不够时，ArrayList自动扩容到1.5倍的下取整10-15-22-33；4-6-9-13-19；这个样子

 关于ArrayList的操作直接上代码：

            
　　　　　　　/*ensureCapacity和trimToSize方法*/
　　　　　　　al.ensureCapacity(38);  //42 if parameter<1.5oldCapacity newCapacity=1.5Capacity else newCapacity=parameter
            System.out.println(getArrayListCapacity(al));
            al.ensureCapacity(43);  // 63
            System.out.println(getArrayListCapacity(al));
            al.trimToSize();    //使capacity=size
            System.out.println(al.size());
            System.out.println(getArrayListCapacity(al));

package list;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;
//ArrayList Function
public class collection {
public static void main(String []args)
{
    ArrayList <Integer> a=new ArrayList<Integer>();
    ArrayList <Integer> b=new ArrayList<Integer>();
    ArrayList <Integer> c=new ArrayList<Integer>();
    /*四种Add操作*/
    for(int i=0;i<10;i++)
    {
        c.add(i);
    }
    a.add(8);
    a.addAll(c);
    b.addAll(0, c);
    b.add(5,55);   //插入在index前面一位
    
    /*contains操作*/
    System.out.println(b.contains(0));         //true
    System.out.println(b.contains(null));     //false
//    Object p=new Object();
//    System.out.println(p.equals(null));  永远false
    
    /*Iterator*/
    Iterator <Integer> it=b.iterator();
    while(it.hasNext())
    {
        System.out.print(it.next()+" ");
    }
    System.out.println();
    
    /*retainAll*/
    b.retainAll(a); //只要b中元素不在a中(即a中没有)，就删掉。
    
    /*ListIterator<E> listIterator(int index)
     *   从下标index开始为第一个,而且可以向前previous()和hasPrevious()*/
    ListIterator <Integer> it1=b.listIterator(0);
    while(it1.hasNext())
    {
        System.out.print(it1.next()+" ");
    }
    System.out.println();

    /*subList 形成一个视图*两者联动一个变，另一个也变/
    List<Integer> d=b.subList(2, 7);
    d.set(0, 888);
    
    /*ForEach*/
    for(int j:d)
    {
        System.out.print(j+" ");
    }
    System.out.println();
    for(int j:b)
    {
        System.out.print(j+" ");
    }
    System.out.println();
    d.remove(3);
    for(int j:d)
    {
        System.out.print(j+" ");
    }
    System.out.println();
    for(int j:b)
    {
        System.out.print(j+" ");
    }
    System.out.println();

    d.set(3,333);
    for(int j:d)
    {
        System.out.print(j+" ");
    }
    System.out.println();
    for(int j:b)
    {
        System.out.print(j+" ");
    }
    System.out.println();

/**/ } }

结果：

true
false
0 1 2 3 4 55 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
888 3 4 5 6
0 1 888 3 4 5 6 7 8 9    //d变b也变
888 3 4 6
0 1 888 3 4 6 7 8 9
888 333 4 6
0 1 888 333 4 6 7 8 9  //b变d也变

其他操作：

深层拷贝和浅层拷贝：深层拷贝是指完全复制，不指向同一元素；浅层拷贝指向同一元素

而ArrayList的clone()方法是一种浅层拷贝方法?(不知如何验证，所以也不确定)

package list;

import java.util.ArrayList;

public class arraylist {

    public static void main(String[] args) {
//        ArrayList <Integer> a=new ArrayList<Integer>(); //互不影响
        ArrayList <String> a=new ArrayList<String>();
        for(int i=0;i<9;i++)
        {
            a.add(String.valueOf(i)+"aa");
        }
        ArrayList <String> b=(ArrayList<String>) a.clone(); //cast
        for(String j:a)
        {
            System.out.print(j+" ");
        }
        System.out.println();
        for(String j:b)
        {
            System.out.print(j+" ");
        }
        System.out.println();
        a.remove(0);
        for(String j:a)
        {
            System.out.print(j+" ");
        }
        System.out.println();
        for(String j:b)
        {
            System.out.print(j+" ");
        }
        System.out.println();
        b.remove(1);
        for(String j:a)
        {
            System.out.print(j+" ");
        }
        System.out.println();
        for(String j:b)
        {
            System.out.print(j+" ");
        }
        System.out.println();
    }

}

总是互相不关联，看起来像是深度复制啊？还是实验设计有问题？

2.Vector

Vector有3个成员域：

int elementCount; // 实际元素个数
Object[] elementData;  //动态数组存放内容
int capacityIncrement  //

四个构造函数：

 默认构造函数：Vector(); capacity=10,increment=0

单参数构造函数：Vector(int initCapacity); capacity=initCapacity,increment=0

双参数构造函数：Vector(int initCapacity,int capacityIncrement); capacity=initCapacity,increment=capacityIncrement

Collection构造函数：Vector(Collection c)

向量的大小大于其容量时，容量自动增加的量。如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时，增加的大小都是capacityIncrement。如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍。若是ensureCapacity(int minCapacity)方法，首先判断capacityIncrement是否大于0，若大于0新容量newCapacity=oldCapacity+capacityIncrement。否则newCapacity=oldCapacity*2。之后选择newCapacity和minCapacity较大的那一个当作新的容量。ensureCapacirt(int minCapacity)核心代码:

 private void grow(int minCapacity) {
        int oldCapacity = elementData.length;   //旧容量
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);   //capacity>0直接加，小于等于0翻倍
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;              //之后判断是否大于参数，选较大的
        if (newCapacity - MAX_ARRAY_SIZE > 0)//
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    } 

  public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            modCount++;//
            ensureCapacityHelper(minCapacity);
        }

 private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
原文：https://blog.csdn.net/zhangveni/article/details/51000873 

 Vector中的API:

synchronized boolean        add(E object)                                    //尾部增加元素@@@@
             void           add(int location, E object)                      //下标location之前插入元素@@@@
synchronized boolean        addAll(Collection<? extends E> collection)       //@@@@
synchronized boolean        addAll(int location, Collection<? extends E> collection) //@@@@
synchronized void           addElement(E object)                     //除返回值不同，其他和add一样
synchronized int            capacity()                           
             void           clear()                              //@@@@
synchronized Object         clone()                                ####
             boolean        contains(Object object)             //@@@@
synchronized boolean        containsAll(Collection<?> collection) //@@@@
synchronized void           copyInto(Object[] elements)             //***********//
synchronized E              elementAt(int location)          
             Enumeration<E> elements()                             //***********//
synchronized void           ensureCapacity(int minimumCapacity)     ##### 
synchronized boolean        equals(Object object)    //@@@@
synchronized E              firstElement() 
             E              get(int location)  //@@@@
synchronized int            hashCode()         //@@@@
synchronized int            indexOf(Object object, int location)  //***********//
             int            indexOf(Object object)                  //@@@@
synchronized void           insertElementAt(E object, int location) 
synchronized boolean        isEmpty()                               //@@@@
synchronized E              lastElement()
synchronized int            lastIndexOf(Object object, int location)
synchronized int            lastIndexOf(Object object)  @@@@
synchronized E              remove(int location)    @@@@
             boolean        remove(Object object)   @@@@
synchronized boolean        removeAll(Collection<?> collection) @@@@
synchronized void           removeAllElements()                
synchronized boolean        removeElement(Object object)
synchronized void           removeElementAt(int location)
synchronized boolean        retainAll(Collection<?> collection) @@@@
synchronized E              set(int location, E object)         @@@@
synchronized void           setElementAt(E object, int location)
synchronized void           setSize(int length)                //************//
synchronized int            size()                             @@@@
synchronized List<E>        subList(int start, int end)        @@@@
synchronized <T> T[]        toArray(T[] contents)              @@@@
synchronized Object[]       toArray()                          @@@@
synchronized String         toString()                        //******
synchronized void           trimToSize()                       ####

 add和addElement几乎一致，还有set和setElementAt、insertElementAt和add双参数、get和ElementAt、remove和removeElement [2]以及removeAllElement和clear。这几乎都是因为从List继承一些方法，然后本身又会自带一些，有些返回值不同，但实现的功能没有大差。上述列表中，带@是继承自List和Collection的方法，带#是和Arraylist一样方法(ensureCapacity其实也不一样)。剩下的好像只有Element那些重复的和为数不多的方法了。

因此主要实现上述带有标志 * 的及其相关的方法为示例：

package vector;

import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class vector {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Vector <String> vs=new Vector<String>();
        String [] st=new String[20];
        String [] st2=new String[20];
        /*add*/
        for(int i=0;i<10;i++)
        {
            vs.add(String.valueOf(i));
        }
        /*capacity*/
        System.out.println(vs.capacity());
        vs.add(5, "5");
        vs.addElement("am ");
        System.out.println(vs.capacity());
        /*iterator*/
        Iterator<String> it=vs.iterator();
        while(it.hasNext())
        {
        
            System.out.print(it.next()+" ");
        }
        System.out.println();
        /*indexOf lastIndexOf*/
        System.out.print(vs.indexOf("5")+" ");        //第一个出现该元素的下标
        System.out.print(vs.lastIndexOf("5")+" ");    //最后一个出现该元素的下标
        System.out.print(vs.lastIndexOf("10")+" ");   //没有的元素返回-1
        System.out.print(vs.indexOf("8",9)+" ");      //返回的元素必须大于等于第二个参数
        System.out.print(vs.lastIndexOf("5",5)+" ");  //返回的参数小于等于第二个参数，否则返回-1
        System.out.println();
        /*setsize*/
        vs.setSize(20);                              //若小于当前size，删除后面元素，若大于添加null
        /*enum*/
        Enumeration<String> en=vs.elements();
        while(en.hasMoreElements())
        {
        
            System.out.print(en.nextElement()+' ');
        }
        System.out.println();

        /*copyInto*/
        vs.copyInto(st);
        for(String a:st)
        {
            System.out.print(a+" ");
        }
        System.out.println();
        /*toString*/
        System.out.println(vs.toString()); 
    }
}

20
0 1 2 3 4 5 5 6 7 8 9 am
5 6 -1 9 5
0 1 2 3 4 5 5 6 7 8 9 am null null null null null null null null
0 1 2 3 4 5 5 6 7 8 9 am null null null null null null null null
[0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, am , null, null, null, null, null, null, null, null]

太多了LinkedList移到下一篇吧。