13 集合，ArrayList集合使用方法以及底层原理等信息。

集合

为什么要用集合框架

对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。数组无法满 足。 就使用集合容器进行存储。集合容器因为内部的数据结构不同，有多种具体容器。 不断的向上抽取，就形成了集合框架。 框架的顶层是Collection接口，定义了集合框架中共性的方法

什么是集合框架用于存储对象的容器。

只要是对象类型就可以存进集合框架中。集合的长度是可变的。 集合中不可以存储基本数据类型。

话不多说先手写一个List

package List01;

import java.util.Arrays;

/**
 *@desc 创建自定义集合
 *
 * @author  wangxihao
 * @email wangxh0108@163.com
**/

public class WxhListNew {
    private Object[] newList = new Object[10];
    private int size=0;

    //增加数据
    public void add(Object o){
        if(size >= newList.length){
            //扩容数组增加之前的二分之一
            newList = Arrays.copyOf(newList,newList.length+newList.length/2);
        }

        newList[size] = o;
        size++;
    }
    //返回长度
    public int size(){
        return size;
    }

    //获取指定索引数据
    public Object get(int index){
        if(index > size || index < 0){
            return -1;
        }

        return newList[index];
    }

    //更改数据
    public void set(int index,Object o){
        if(index > size || index < 0){
            return ;
        }
        newList[index] = o;

    }

    //删除数据
    public void remove(int index){
        if(index > size || index < 0){
            return ;
        }
        for (int i = index; i < size ; i++) {
            newList[i] = newList[i+1];
        }
        size--;
        newList = Arrays.copyOf(newList,size);
    }
}

来一个调用：

package List01;


public class ListTest {
    public static void main(String[] args){
        WxhListNew listNew = new WxhListNew();
        listNew.add("哈哈1");
//        System.out.println(listNew.get(0));
        for (int i = 0; i < 5; i++) {
            listNew.add(i);
        }
        listNew.remove(3);//第三个数 删除2
        for (int i = 0; i < listNew.size(); i++) {
            System.out.println(listNew.get(i));
        }
        System.out.println("集合长度下标"+listNew.size());
//        new WxhListNew()
    }
}

ArrayList类

ArrayList要跟Array数组相关。ArrayList的底层就是数组。
特点：
查找快，插入删除慢（因为会引起其他元素位置改变）
自动扩容（我们只管存取即可 如果长度不够 底层会自动的扩容）
可以存储所有对象（对象类型 或者说是Object的子类 ）
可以存储null
存储的数据是有序的 ( 取出的顺序就是存储的顺序 )
数据可以重复

ArrayList的常用方法

方法名	用途
size()	数组中数据的个数并不是长度
add(E e)	追加
get(index)	根据下标获取值
isEmpty()	判断ArrayList中是否有数据
indexOf()	获取aa在ArrayList中首次出现的索引，有返回，没有-1
lastIndexOf(数据)	返回数据最后一次出现的索引
contains	判断数据在ArrayList中是否存在
remove(index)/remove(obj)	根据下标删除，或者直接删除数据
toArray()	将List转换成数组
clear()	清空List列表
set(索引,“数据”)	将指定索引的数据修改

使用ArrayList

package List01;


import java.util.ArrayList;

public class Listtext {
    public static void main(String[] args){

        ArrayList list = new ArrayList();
        for (int i = 1; i < 4; i++) {
            //增加数据
            list.add(i);
        }
        //得到数据
        System.out.println(list.get(0));

        //移除数据
        list.remove(2);
        System.out.println(list);

        list.add("haha");
        //更改数据
        list.set(0,"你叫");

        System.out.println(list);
        list.remove(list.indexOf(2));
        //输出直接for循环输出
        for (Object i:list){
            System.out.println(i);
        }
        ArrayList<Integer> strings = new ArrayList<>();
        strings.add(1);
    }
}

底层原理

对于ArrayList而言，它实现List接口、底层使用数组保存所有元素。其操作基本上是对数组的操作。ArrayList有三种方式来初始化，构造方法源码如下：

//默认数组长度10
 private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;

它的默认方法

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }


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


    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;
    }


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

   
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

 
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

  
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

    // Positional Access Operations

    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

 
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

  
    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

   
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

  
    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++;
    }

 
    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;
    }

   
    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;
    }

Vector

 Vector vector = new Vector();
        vector.add("dsc");
        vector.add("sdcsd");
        for (Object h : vector){
            System.out.println(h);
        }

LinkedList

LinkedList大差不差 大家可以多看看源码，还是有帮助的。LinkedList的底层是链表构成，ArrayList是数组构成。我们暂时不了解那么深。

LinkedList linkedList = new LinkedList();
        linkedList.add("lk1");
        linkedList.add("lk2");
        linkedList.add("lk3");
        for (Object i : linkedList){
            System.out.println(i);
        }
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println(arr.length);