java 集合--Collection子接口LINK （总结于尚硅谷java）

Collection子接

1.Collection中子接口的整体描述

|----Collection接口：单列集合，用来存储一个一个的对象
   |----List接口：存储有序的、可重复的数据。  -->“动态”数组,替换原有的数组
      |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
      |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
      |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

2.List接口方法

List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法

• void add(int index, Object ele):在index位置插入ele元素
• boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
• Object get(int index):获取指定index位置的元素
• int indexOf(Object obj):返回obj在集合中首次出现的位置
• int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
• Object remove(int index):移除指定index位置的元素，并返回此元素
• Object set(int index, Object ele):设置指定index位置的元素为ele
• List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex
  位置的子集合

        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);
        System.out.println(list);
	   //[123, 456, AA, Person{name='Tom', age=12}, 456]

//void add(int index, Object ele):在index位置插入ele元素
	    list.add(1,"BB");
        System.out.println(list); 
        //[123, BB, 456, AA, Person{name='Tom', age=12}, 456]

//boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
	    System.out.println(list.size());//6
        List list1 = Arrays.asList(1, 2, 3);//往里添加了3个元素
        list.addAll(list1);
//        list.add(list1);  这里表示只添加了一个元素 123为一个
        System.out.println(list.size());//9

//Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));

//int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1.
        int index = list.indexOf(4567);
        System.out.println(index);

//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
        System.out.println(list.lastIndexOf(456));

//Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj); //返回123
        System.out.println(list);//输出删除123的所有的元素

@Test
public void testListRemove() {
    List list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    updateList(list);
    System.out.println(list);
}
private static void updateList(List list) {
    list.remove(2);  //remove是指定删除index 所以真实得是删除3 而不是2
}

//Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"CC");
        System.out.println(list);

//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);
        System.out.println(list);

循环ArryList的方式：

 //方式一：Iterator迭代器方式
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("***************");

        //方式二：foreach循环
        for(Object obj : list){
            System.out.println(obj);
        }

        System.out.println("***************");

        //方式三：普通for循环
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }

3.List实现类子接口ArrayList

本质上，ArrayList是对象引用的一个”变长”数组

ArrayList的源码分析

//1.在jdk7的时候：
	//底层创建了长度是10的Object[]数组elementData
	ArrayList list = new ArrayList(); 
	list.add(123); //elementData[0] = new Integer(123);
	...
	list.add(123);
    //果此次的添加导致底层elementData数组10个容量不够，则扩容。默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

//2.在jdk8后
	//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
	ArrayList list = new ArrayList(); 
	list.add(123); //第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
	...
	list.add(123);
	//若容量不够 则和7一样

总结：

1. 开发中建议使用带参的构造器：ArrayList list = new ArrayList(int capacity)
2. jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

4.List实现类子接口LinkedList

双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。Node除了保存数据，还定义了两个变量：
 prev变量记录前一个元素的位置
 next变量记录下一个元素的位置

新增的方法：

• void addFirst(Object obj)
• void addLast(Object obj)
• Object getFirst()
• Object getLast()
• Object removeFirst()
• Object removeLast()

双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。Node除了保存数据，还定义了两个变量：
 prev变量记录前一个元素的位置
 next变量记录下一个元素的位置

LinkedList的源码分析

//内部声明了Node类型的first和last属性，默认值为null
LinkedList list = new LinkedList();
//将123封装到Node中，创建了Node对象。
list.add(123);

//      其中，Node定义为：体现了LinkedList的双向链表的说法
//     private static class Node<E> {
//             E item;
//             Node<E> next;
//             Node<E> prev;
//
//             Node(Node<E> prev, E element, Node<E> next) {
//             this.item = element;
//             this.next = next;
//             this.prev = prev;
//             }

5.List实现类子接口Vector

1. Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。(过时的不使用)

Vector的源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
      在扩容方面，默认扩容为原来的数组长度的2倍。

注意点：

ArrayList、LinkedList、vector的异同？理解？底层实现原理和扩容机制
1.ArrayList、LinkedList 2个都是不安全的，但是执行效率要比vector高

2.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。

3.ArrayList类似于单例模式的饿汉式 先在底层创建element数组 10个，而LinkedList类似单例模式的懒汉式，在执行add的时候才去创建element数组（用的时候才去做）

4.vector和ArrayList底层原理一样 扩容倍数不同

5.Arraylist和LinkedList扩容都是原理的1.5倍 vector为原来的2倍