一、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移到下一篇吧。

最新文章

  1. Python从破门而入到夺门而出
  2. 烂泥：学习ubuntu远程桌面（二）：远程桌面会话管理
  3. javascript模板插件amaze.js
  4. iOS中nil、Nil、NULL、NSNull详解(转)
  5. IOS 开发qq登陆界面
  6. Javascript之严格模式详解
  7. 【转】Android 使用Scroller实现绚丽的ListView左右滑动删除Item效果
  8. 如何写一个jquery插件
  9. 4、Android UI测试
  10. java新知识系列 一
  11. docker /var/lib/docker/aufs/mnt 目录满了，全是垃圾数据
  12. 微信小程序--地图组件与api-模拟器上返回的scale 与真机上不同--bindregionchange触发图标一直闪现问题
  13. fdisk语法
  14. windows server远程连接提示“终端服务器超出了最大允许连接”
  15. Effective Java 第三版——70. 对可恢复条件使用检查异常，对编程错误使用运行时异常
  16. mysql字符集问题，及排序规则
  17. 迷你MVVM框架 avalonjs 学习教程10、样式操作
  18. OOAD之面向对象设计原则
  19. 超全面的JavaWeb笔记day05&lt;xml&amp;dtd&amp;jaxp&gt;
  20. sql prompt 不能用

热门文章

  1. Can not find connection pool config file
  2. 我想学前端动画-CSS之transition
  3. 从gopath到go mod的一次尝试
  4. 从 SPIR-V 到 ISPC：将 GPU 计算转化为 CPU 计算
  5. Python面试简介及并行并发
  6. 单例模式（一）static、final和单例模式
  7. Python3图片处理头像
  8. 批量删除Maven本地仓库中未下载完成的jar包（不完整的jar包）
  9. HDU1251 统计难题（字典树|map
  10. codeforces 842C Ilya And The Tree （01背包+dfs）