java数据结构

1:集合
Collection(单列集合)

List(有序,可重复)
        ArrayList
            底层数据结构是数组,查询快,增删慢
            线程不安全,效率高
        Vector
            底层数据结构是数组,查询快,增删慢
            线程安全,效率低
        LinkedList
            底层数据结构是链表,查询慢,增删快
            线程不安全,效率高
    Set(无序,唯一)
        HashSet
            底层数据结构是哈希表。
            哈希表依赖两个方法：hashCode()和equals()
            执行顺序：
                首先判断hashCode()值是否相同
                    是：继续执行equals(),看其返回值
                        是true:说明元素重复，不添加
                        是false:就直接添加到集合
                    否：就直接添加到集合
            最终：
                自动生成hashCode()和equals()即可
                 LinkedHashSet
                底层数据结构由链表和哈希表组成。
                由链表保证元素有序。
                由哈希表保证元素唯一。
        TreeSet
            底层数据结构是红黑树。(是一种自平衡的二叉树)
            如何保证元素唯一性呢?
                根据比较的返回值是否是0来决定
            如何保证元素的排序呢?
                两种方式
                    自然排序(元素具备比较性)
                        让元素所属的类实现Comparable接口
                    比较器排序(集合具备比较性)
                        让集合接收一个Comparator的实现类对象
Map(双列集合)
    A:Map集合的数据结构仅仅针对键有效，与值无关。
    B:存储的是键值对形式的元素，键唯一，值可重复。
    HashMap
        底层数据结构是哈希表。线程不安全，效率高
            哈希表依赖两个方法：hashCode()和equals()
            执行顺序：
                首先判断hashCode()值是否相同
                    是：继续执行equals(),看其返回值
                        是true:说明元素重复，不添加
                        是false:就直接添加到集合
                    否：就直接添加到集合
            最终：
                自动生成hashCode()和equals()即可
        LinkedHashMap
            底层数据结构由链表和哈希表组成。
                由链表保证元素有序。
                由哈希表保证元素唯一。
    Hashtable
        底层数据结构是哈希表。线程安全，效率低
            哈希表依赖两个方法：hashCode()和equals()
            执行顺序：
                首先判断hashCode()值是否相同
                    是：继续执行equals(),看其返回值
                        是true:说明元素重复，不添加
                        是false:就直接添加到集合
                    否：就直接添加到集合
            最终：
                自动生成hashCode()和equals()即可
    TreeMap
        底层数据结构是红黑树。(是一种自平衡的二叉树)
            如何保证元素唯一性呢?
                根据比较的返回值是否是0来决定
            如何保证元素的排序呢?
                两种方式
                    自然排序(元素具备比较性)
                        让元素所属的类实现Comparable接口
                    比较器排序(集合具备比较性)
                        让集合接收一个Comparator的实现类对象

2.关于集合选取原则

是否是键值对象形式:
    是：Map
        键是否需要排序:
            是：TreeMap
            否：HashMap
        不知道，就使用HashMap。
        
    否：Collection
        元素是否唯一:
            是：Set
                元素是否需要排序:
                    是：TreeSet
                    否：HashSet
                不知道，就使用HashSet
                
            否：List
                要安全吗:
                    是：Vector
                    否：ArrayList或者LinkedList
                        增删多：LinkedList
                        查询多：ArrayList
                    不知道，就使用ArrayList
        不知道，就使用ArrayList

3:集合的常见方法及遍历方式
Collection:
add()
remove()
contains()
iterator()
size()

    遍历：
        增强for
        迭代器
        
    |--List
        get()
        
        遍历：
            普通for
    |--Set

Map:
    put()
    remove()
    containskey(),containsValue()
    keySet()
    get()
    value()
    entrySet()
    size()
    
    遍历：
        根据键找值
        根据键值对对象分别找键和值

初始化：

	List a = new ArrayList<>();
	List b = new LinkedList<>();
	ArrayList<String> c = new ArrayList<>();
	LinkedList<String> d = new LinkedList<>();
	List<String> e = new Vector<>();
	Vector<String> f = new Vector<>();
	Set a1 = new HashSet();
	Set b1 = new LinkedHashSet<>();
	Set c1 = new TreeSet<>();
	HashSet d1 = new HashSet<>();
	LinkedHashSet e1 = new LinkedHashSet<>();
	TreeSet f1 = new TreeSet<>();
	
	Map a2 = new HashMap<>();
	Map b2 = new LinkedHashMap<>();
	Map c2 = new Hashtable<>();
	Map d2 = new TreeMap<>();

  public static void main(String[] args) {
        //Map是Java.util包中的另一个接口，它和Collection接口没有关系，是相互独立的，但是都属于集合类的一部分。Map包含了key-value对。Map不能包含重复的key，但是可以包含相同的value。
        //Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。
        Map map0 = new HashMap();
        //数组方式存储key/value，线程非安全，允许null作为key和value，key不可以重复，value允许重复，不保证元素迭代顺序是按照插入时的顺序，key的hash值是先计算key的hashcode值，然后再进行计算，每次容量扩容会重新计算所以key的hash值，会消耗资源，要求key必须重写equals和hashcode方法
        //默认初始容量16，加载因子0.75，扩容为旧容量乘2，查找元素快，如果key一样则比较value，如果value不一样，则按照链表结构存储value，就是一个key后面有多个value；
        Map map3 = new Hashtable();
        //Hashtable与HashMap类似，是HashMap的线程安全版，它支持线程的同步，即任一时刻只有一个线程能写Hashtable，因此也导致了Hashtale在写入时会比较慢，它继承自Dictionary类，不同的是它不允许记录的键或者值为null，同时效率较低。
        Map map2 = new LinkedHashMap();
        //LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的，在遍历的时候会比HashMap慢，有HashMap的全部特性, 非线程安全。
        Map map1 = new TreeMap();
        //基于红黑二叉树的NavigableMap的实现，非线程安全，不允许null，key不可以重复，value允许重复，存入TreeMap的元素应当实现Comparable接口或者实现Comparator接口，会按照排序后的顺序迭代元素，两个相比较的key不得抛出classCastException。主要用于存入元素的时候对元素进行自动排序，迭代输出的时候就按排序顺序输出




        //List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据的移动，所有插入删除数据速度慢。
        List list0 = new ArrayList();
        //ArrayList是基于数组的，在初始化ArrayList时，会构建空数组（Object[] elementData={}）。线程非安全, ArrayList是一个有序的，它是按照添加的先后顺序排列，当然，他也提供了sort方法，如果需要对ArrayList进行排序，只需要调用这个方法，提供Comparator比较器即可
        //list0.add(object);
        //list0.add(index, elment);
        //list0.size()
        //list0.get(index)
        //list0.remove(object)
        //list0.remove(index)
        //list0.toArray()
        //list0.toString()
        //list0.set(index, element)
        //list0.sort(comparator)

        //list remve元素问题：List每remove掉一个元素以后，后面的元素都会向前移动，此时如果执行i=i+1，则刚刚移过来的元素没有被读取。
        //解决方法： 1.倒过来遍历list 2.使用iterator.remove()
        /*for (Iterator iterator= list0.iterator(); iterator.hasNext();){
            Object obj = iterator.next();
            System.out.println(obj);
            list0.remove(obj)
        }*/

        List list1 = new LinkedList();
        //LinkedList是基于链表的，它是一个双向链表，每个节点维护了一个prev和next指针。非线程安全, 同时对于这个链表，维护了first和last指针，first指向第一个元素，last指向最后一个元素。LinkedList是一个有序的链表，按照插入的先后顺序排序，不提供sort方法对内部元素排序。
        //list1.get(index)...


        //Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。
        Set set0 = new HashSet();
        //HashSet是基于HashMap来实现的，操作很简单，更像是对HashMap做了一次“封装”，而且只使用了HashMap的key来实现各种特性，而HashMap的value始终都是PRESENT。
        //HashSet不允许重复（HashMap的key不允许重复，如果出现重复就覆盖），允许null值，非线程安全。  HashMap 实例的默认初始容量是 16，加载因子是 0.75
        Set set1 = new TreeSet();
        //基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator进行排序，具体取决于使用的构造方法,非线程安全。

    }

Vector和ArrayList

1，vector是线程同步的，所以它也是线程安全的，而arraylist是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用arraylist效率比较高。

2，如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%，而arraylist增长率为目前数组长度的50%。如果在集合中使用数据量比较大的数据，用vector有一定的优势。

3，如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，如果频繁的访问数据，这个时候使用vector和arraylist都可以。而如果移动一个指定位置会导致后面的元素都发生移动，这个时候就应该考虑到使用linklist,因为它移动一个指定位置的数据时其它元素不移动。

ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要涉及到数组元素移动等内存操作，所以索引数据快，插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快。
arraylist和linkedlist

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。
HashMap与TreeMap

1、 HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。

2、在Map 中插入、删除和定位元素，HashMap是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。

两个map中的元素一样，但顺序不一样，导致hashCode()不一样。

同样做测试：
　　　　在HashMap中，同样的值的map,顺序不同，equals时，false;
　　　　而在treeMap中，同样的值的map,顺序不同,equals时，true，说明，treeMap在equals()时是整理了顺序了的。
HashTable与HashMap

1、同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。

2、HashMap允许存在一个为null的key，多个为null的value 。

3、hashtable的key和value都不允许为null。