java集合源码详解

一 ArrayList

特点

1.底层实现基于动态数组,数组特点根据下表查找元素速度所以查找速度较快.继承自接口  Collection ->List->ArrayList

 2.扩充机制 初始化时数组是空数组,调用add()第一次存放元素时长度默认为10,满了扩容机制 原来数组 + 原来数组的一半 使用数组copy()方法

　　　　2.1 构造一个初始容量为空列表。(不给指定大小时为空)

　　　　

　　　　2.2使用add()方法,将指定的元素追加到列表的末尾。

　　　　

 　　　　2.3 将数组长度设置为10

　　　　

　　　　2.4判断长度是否大于当前数组 调用grow()方法扩容

　　　　

 　　　　2.5  newCapacity = oldCapacity + (oldCapacity >> 1);  oldCapacity >> 1其实就是oldCapacity 除以2,返回一个copyOf的数组

 　　　　

 3.线程不安全 ,效率高

二  vector

　　1.采用动态数组,初始化时默认长度10

　　

　　2.由于是默认初始化 没有给定capacityIncrement 所以为 0  所以新数组长度为 oldCapacity + oldCapacity 也就是增长为原来2倍,如果给定增长值capacityIncrement 

　　后,扩充为:原来大小+增量也就是newCapacity= oldCapacity + capacityIncrement

　　

 三  LinkList

 　　1.适合插入,删除操作,性能高

　　 

　　 2.有序的元素,元素可以重复

　　 3.原理 

　　　　3.1插入时只需让88元素记住前后俩元素, 删除88元素只需让88前面元素(6)记住该元素后面(35)元素 时间复杂度 O（1）< O（logn）< O（n）< O（n^2）

　　

　　　　3.2对于某一元素，如何找到它的下一个元素的存放位置呢？对每个数据元素ai，除了存储其本身的信息之外，

还需存储一个指示其直接后继存放位置的指针。在每个结点中再设一个指向前驱的指针域

　　　　

　　　　

　　　　prior 前面节点指针域 next后一个节点指针域

　　　　

　　　　

 　　　　(图片来源<<数据结构 java语言描述>>)

　　　　　3.3 add() 时在尾部追加元素 ...等等

　　　　

四set接口 HashSet

　　1.元素输出时不允许元素重复,允许元素为null (因为string 重写了hashCode,equals方法所以可以去重)

　　

 　　2.无序的

　　 3.实现源码

　　　　3.1 使用默认无参初始化时 其实使用的是HashMap实现的

　　　    构造一个新的空集;支持的stt>HashMaps/tt>实例具有默认的初始容量(16)和负载因子(0.75)。

　　　　

 　　　　3.2 向HashSet添加元素时 使用HashMap的put()方法,把值作为HashMap的key (key肯定不可以重复的,唯一的)

　　　　

　　　　所以详细实现源码下面介绍HashMap时再说

　　　　4. HashSet的子类LinkedHashSet 底层使用双向链表

　　　　　　4.特点 4.1.按照添加顺序输出 ; 元素不重复

　　　　　　　　　4.2使用无参构造的初始化容量(16)和负载因子(0.75)构造一个新的空链接哈希集。

　　　　　　　　　　

　　　　　　　　　　4.3调用父类HashSet 构造 初始化的对象是LinkedHashMap() 关系又跑到map上去了

　　　　　　　　　　

 　　　　　　　　　  4.4LinkedHashMap()调用他爹(HashMap)的构造 

　　　　　　　　　　

　　　　　　　　　　4.5 调用LinkedHashMap() 构造时 设置了hash顺序

　　　　　　　　　　accessOrder //这个链接哈希映射的迭代方法:true表示访问顺序，false表示插入顺序。

　　　　　　　　　　

五TreeSet

　　

 　　1.可以排序(元素按照自然排序进行排列 根据KEY值排序)且不允许元素重复

　　  

　　　　为什么会自动排序呢?

　　　　　1.1 默认无参构造时 初始化的是一个TreeMap对象

　　　　　　

 　　　　   2.2 调用add()方法时调用的是Map接口提供的put()方法 而treeMap 实现了map接口的put(); 所以底层存储就是treeMap  红黑树

方法 源码如下 　　　

public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

 　　 2.不允许元素为null

　     

 　　3.排序想按照对象的某个值排序,某个类实现接口 Comparator 重写 compare()方法

private static void treeSet(){              //TreeSet

      Catss cat1=new Catss(2,"猫1",1);
      Catss cat2=new Catss(1,"猫2",2);
      Catss cat3=new Catss(3,"猫3",3);
      Catss cat4=new Catss(1,"猫4",4);
      Catss cat5=new Catss(1,"猫4",4);
      //TreeSet存储数据要使用比较器
      TreeSet<Catss> t=new TreeSet<>(new CatComparator());
      t.add(cat1);
      t.add(cat2);
      t.add(cat3);
      t.add(cat4);
      t.add(cat5);
       for (Object f:t){
           System.out.println(f+"输出顺序是按照年龄排序递增(年龄有一样的将会覆盖一个,只输出一个)");//输出顺序是按照年龄排序递增(年龄有一样的将会覆盖一个,只输出一个)
       }
  }

class CatComparator implements Comparator<Catss> {
    @Override
    public int compare(Catss o1, Catss o2) {
        return o1.getAge()-o2.getAge();//根据年龄排序
    }

}

六Map-HashMap

 　　特点:1.无序的键值对存储一组对象2.key必须保证唯一,Value可以重复3.key 和value可以为null4.线程不安全

　　　　  5.默认加载因子0.75,默认数组大小16 6.实现基于哈希表 (数组+链表+红黑树)

　　　　

　　       源码:1.加载因子0.75f

 　　　  

 　　　　 2.实现map接口的put()方法 hashMap重写put

　　　　 　　2.1为了一次存取便能得到所查记录，在记录的存储位置和它的关键字之间建立一个确定的对应关系H，

以H(key)作为关键字为key的记录在表中的位置，称这个对应关系H为哈希（Hash）函数。按这个思想建立的表为哈希表。

　　　　　　 2.2解决Hash冲突

　　　　　　　根据设定的哈希函数H(key)和所选中的处理冲突的方法，将一组关键字映射到一个有限的、

地址连续的地址集（区间）上，并以关键字在地址集中的“象”作为相应记录在表中的存储位置，如此构造所得

的查找表称之为“哈希表”，这一映射过程也称为“散列”，所以哈希表也称散列表。--<<数据结构 java语言描述>>

　　　　　　 2.3子类LinkHashMap,按照添加顺序输出特点参考上面LinkedHashSet

七Hashtable

　

 　　特点 1.线程安全调用put()时synchronized修饰

　　　　　

　　　　　2.默认构造大小11扩充因子0.75

　　　　　

　　　　   3.无序的,K和V 都不能为null ,允许元素重复

 　　　　  

 　　　　　

八TreeMap

 　　　特点:1.可以排序(自然排序123),元素可以重复,K值不能重复　　

public static void treeMapTest(){
        TreeMap<String, String> treeMap = new TreeMap<>();
        treeMap.put("1","A");
        treeMap.put("4","A");
        treeMap.put("2","B");
        treeMap.put("3","C");
        treeMap.forEach((k,v)->System.out.println("K值:"+k+"----->value值:"+v));
    }

    //K值:1----->value值:A
    //K值:2----->value值:B
    //K值:3----->value值:C
    //K值:4----->value值:A

 　　　　　2.排序想按照对象的某个值排序,某个类实现接口 Comparator 重写 compare()方法; 上面TreeSet 一样

 -----------------------------------完--------------------------------------------------

 map集合的遍历

public class Map09 {
    public static void main(String[] args){
        hashMap();
    }
    private static void hashMap(){
        Map<Integer,String> map=new HashMap<>();//Map<key,value>
        map.put(1,"key必须保证唯一");
        map.put(2,"无序的");
        map.put(3,"put方法");
        map.put(null,null);
        System.out.println(map.size());
        System.out.println("得到key=2的值:"+map.get(2));
        //第一种遍历 lambda表达式遍历forEach();非常简便
        System.out.println("---------lambda表达式遍历forEach()-----------------------");
        map.forEach((i, s) -> System.out.println("key="+i+"     value:"+s));
        //第二种遍历  entrySet()方法
        System.out.println("---------entrySet()方法使用foreach遍历-----------------------");
        Set<Map.Entry<Integer,String>> entry=map.entrySet();
        for (Map.Entry e:entry){
            System.out.println(e.getKey()+"->"+e.getValue());
        }
        System.out.println("---------entrySet()方法使用Iterator遍历-----------------------");
        Set entries = map.entrySet();
        Iterator iterator = entries.iterator();
        while(iterator.hasNext()){
            Map.Entry entrys = (Map.Entry) iterator.next();
            Object key = entrys.getKey();
            String value = map.get(key);
            System.out.println(key+"        "+value+"-----");
        }
        System.out.println("----------keySet()方法---------------------");
        //第三种 遍历键 keySet()方法
        Set<Integer> key=map.keySet();
        for (Integer i:key){
            String va=map.get(i);
            System.out.println(i+"->"+va);
        }
        //第四种遍历值map.values()
        System.out.println("----------values()方法---------------------");
        Collection<String> vs=map.values();
        for (String str:vs){
            System.out.println(str);
        }

    }
}