集合的知识点总结以及底层方法个人理解（一）

集合的讲解，集合更像是数组的集中升级化。面对集合和数组的数组区别。因此引出一个问题：已经有数组用来存储数据，为什么还要引出集合的数据结构。

1、数组虽然可以用来存储基本数据类型和引用数据类型，但是数组的长度一旦被固定就无法被更改，就无法进行进一步的数据处理（增删改查），效率低下，只适用于比较简单的数据处理。
2、毕竟编程更多的适用于实际开发，因此为了改善数组的弊端，引进了集合框架

集合的功能

1、集合同样和数组一样是用来存储数据的，但是集合结合了数据结构的内容知识进行扩充不同于数组的内容方法成员和功能。
2、集合不是一个集合或者单纯的一个类，而是一组接口和实现类。
3、集合可以动态的保存多个对象，方便进行操作，大大加快了编程的效率。
不仅于此集合框架更分为两大类Collection和Map两种集合

Collection集合

Collection集合方法是作为实现类的基础，在这里我们简单的总结一下

其中实例方法比较多，我们可以通过查询API帮助文档进行查询方法的具体内容。我们不再进行具体的概述
Collection集合实现了Iterable接口的内容，这里引出iterator()方法，
其中iterato是迭代器，类似于for循环进行遍历输出，同样是遍历输出，为了提高编程效率对传统的for循环进行改进，引出了for循环加强版。一下是代码示例
iterator迭代器遍历输出

Iterator iterator = list.iterator();
        while(iterator.hasNext())
        {
            Object obj1 = iterator.next();
            System.out.println(obj1);
        }

for循环加强版遍历输出

for(Object o:list)
        {
            System.out.println(o);
        }

补充：for循环加强版更大的优势在于，没有循环限制条件和输出对象不仅仅是数字或者单一的基本数据类型，可以直接将集合中的对象进行实例化进行输出或者直接输出引用数据类型。
其中list是Arraylist初始实例化的实例类对象；以上是如何进行遍历输出的两种方法，当然如果用传统的for循环同样也可以进行输出。仅限于Arraylist实现类对象。这里只是简单的一个举例来引进集合。

list集合接口

List接口实现了Collection接口的方法和内容，而list作为一种接口在集合中必定有其实现类。
其实现类有三个：ArrayList类、LinkedList类、Vector类
虽然有不同的实现类，但是其实现类具有相同的属性方法和实现功能。其中Arraylist和Vector具有相同的特点，进一步它们的差异更是微乎其微。

ArrayList实现类

Arraylist的底层数据结构是一个数组，但是不同于普通的数组。在List中所有的接口实现类，都实现了扩容机制，更具体的说在Arraylist的底层中是数据结构中的线性表。完善了数组不能扩容的弊端

package Com.lab.Collections01;

import java.util.ArrayList;

public class ArrayList0101 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList ();
//进行无参的构造器，其实质是进行构造一个默认值是10的空线性表
        ArrayList list1 = new ArrayList(8);
//进行有参的构造其器，其实质依然是进行构造一个默认值是输入值大小的内存
        for(int i = 1;i<=10;i++)
        {
            list.add(i);
        }
        for(int i =11;i<=15;i++)
        {
            list.add(i);
        }
        list.add(100);
        list.add(200);
/**在底层就是创建了一个空的数组，需要数组自己进行扩容机制
 * 执行list下面的elemNtDate数组下面，如果第一次添加，
 * 赋进去一个最小的容量大小
 * 首先我们可以知道默认值是分配10个内存空间，扩容机制根据参数的不同
 * 无参的默认是10，第一次扩容机制就是扩容1.5倍，后续如果依然不够继续1.5倍扩容
 * 有参依然是进行1.5倍内存扩容机制*/
    }
}

底层数据结构：线性表
由于方法较多 ，可以根据需求进行查找使用，常见的方法有：增加，删除，修改，查询。其中ArrayList实现类的底层是个线性表，固然有其优势和弊端。
优点：修改和查找元素的功能效率相对比较高。
缺点：由于底层是个线性表，所以增加和删除的效率是比较低的，更是由于线性表的原因，在后续的多线程的情况下，访问效率比较高，但访问是不安全的。补充：不同步的

Vector实现类

Vector的底层数据结构同样是个数组，和ArrayList不同的是Vector类的在多线程访问时是同步的，但访问安全性比较高，同样在多线程的情况下访问效率是比较低的。和ArrayList相同的是由于底层都是个数组所以优势和弊端是相同的，更多的是在多线程的情况下访问是否安全以及访问的效率高不高的问题。补充：同步的
再者就是Vector实现类的底层扩容机制是不同于Arraylist实现类的：
扩容机制：
1、进行无参构造的话，是构造一个空的向量，使其内部的数据数组的大小为10，其标准容量增量为0。（不同于Arraylist的是Vector里面有个标准容量增量）
2、进行有参构造的话，可以自行指定初始容量和容量增量的空向量。
在进行容量扩容时，和Arraylis类似无参的默认先分配10个空间内存，接着进行1.5倍的扩充内存机制

LinkedList实现类

LinkedList底层是一个链表，在多线程情况下是访问是不安全的，因此建议是在单线程的情况下使用。再者就是底层是个双链表，不需要进行内存的扩容机制。
同样作为底层数据结构的双链表的优点和弊端
优点：增加和插入以及删除的操作。在
缺点：在进行修改和查找的时候效率是比较低的。
正是因为底层数据结构的原因导致该集合实现了相对应的数据结构的缺点和弊端。
LinkedList构造器的简单总结：
无参和有参的构造器：链表本身就是完善线性表的内存扩容机制的数据结构。

public LinkedList();
//构造一个空列表。 
public LinkedList(Collection<? extends E> c);
//构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

底层代码的简单实现和个人理解

package Com.lab.Collections01;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

public class LinkList_1 {
    public static void main(String[] args) {
//        模拟一个简单的双向链表

        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node rubbish = new Node("郑州大学学校");
//       将对象以链表的形式连接在一起
        jack.next = tom;
        tom.next = rubbish;
//      这仅仅只是一个单向链表
        rubbish.pre = tom;
        tom.pre = jack;
//        保证第一个和最后一个的数据之固定的
/**
 * first和last是Java中的关键词，保证双向链表的数组数据是固定的，
 * 其中的关系已经固定的
 * */
        Node first = jack;
        Node last = rubbish;
        System.out.println("以first形式进行输出");
/**
 * 以first的形式进行输出数据*/
        while (true) {
            if (first == null) {
                break;
            }
            System.out.println(first);
            first = first.next;
        }
        System.out.println("以last形式进行输出");
/**
 * 以last的形式进行输出数据*/
        while (true) {
            if (last == null) {
                break;
            }
            System.out.println(last);
            last = last.pre;
        }
        System.out.println("添加数据后进行输出");
        Node city01 = new Node("河南省郑州市");
        city01.next = rubbish;
        city01.pre = tom;
        rubbish.pre = city01;
        tom.next = city01;
/**注意每次添加数据之后，需要进行重新改变一下指向
 * */
        first = jack;
        last = rubbish;
        while (true) {
            if (last == null) {
                break;
            }
            System.out.println(last);
            last = last.pre;
        }
/**了解底层源码*/
        LinkedList list = new LinkedList();
//        LinkedList list01 = new LinkedList();
        list.add(1);
        list.add(2);
        list.add("456");
        list.add("郑州市");
        list.add("adasdasda");
        list.remove();
//        list.set(4,999);
        /**
         * 从第一个位置建立一个数据就是插入数据
         * */
/**remove方法默认无参删除第一个节点*/
        System.out.println(list);
        Object obj = list.get(1);
        System.out.println(obj);
/**迭代器*/
        Iterator iterator = list.iterator();
        while(iterator.hasNext())
        {
            Object next = iterator.next();
            System.out.println(next);
        }
/**增强版for循环*/
        for(Object o:list)
        {
            System.out.println(o);
        }
    }
/**
 * Arraylist和Linkedlist的比较
 * 前者：可变参数；增删效率较低，改查效率比较高
 * 后者：双向链表；增删效率较高，改查效率较低*/
/**
 * 该查用的多用Arraylist，但是线程不安全
 * 增删用的多就是使用LinkedList,
 * 在线程没有并发的情况下是安全的*/
}
//定义一个Node类，Node表示双向的的一个节点
class Node {
    public Object item;
    //    存放数据的地方
    public Node next;
    public Node pre;

    public Node(Object name) {
        this.item = name;
    }
    @Override
    public String toString() {
        return "数据名字是： " + item;
    }
}

总结：以上是Collection下面的List接口以及各个集合实现类的个人总结，感谢参考！！！