栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

ArrayList和HashMap的My笔记

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

ArrayList和HashMap的My笔记

1.1ArrayList

接口实现ArreyList集合实现了RandomAccess(随机访问)接口不适合使用迭代器来进行遍历,

重写了序列化方法,transient Object[] elementDate(存储数据的节点) 节省了50%的序列化空间

近似1.5倍扩容  时间复杂度为o1

 

 

 

初始长度为10会进行1次扩容

 

System.arreyCopy();进行浅拷贝扩容模式

System.arraycopy()方法详解 system.arraycopy(详解)

 JAVA基础----java泛型中E,T,?的区别(泛型详解)

一、深度复制和浅度复制的区别

         Java数组的复制操作可以分为深度复制和浅度复制,简单来说深度复制,可以将对象的值和对象的内容复制;浅复制是指对对象引用的复制。(浅拷贝扩容一个框用原来数据内存地址指向框,深拷贝重新创建一个数据并将数据拷贝到新数组当中)

1.1使用java为我们提供的工具类进行生产ArrayList

这样不行(否)

1.1第一种

使用Arrays.saList();进行创建list集合

自己创建了一个私有的ArrayList底层是继承了AbstractList,没有重写add方法,而父类AbstractList的add方法会直接抛出异常

抛出异常改为:UnsupportedOperationException

 

在什么情况下使用Arrays.saList();呢?

元素个数固定使用

在 不可做删除 不可做增加,可以做修改和查询的情况下使用

王校长总结:

 

1.2第二种

 

数组里面元素是对象所以需要赋值为null值,赋为null值之后对象为不可达对象会被GC回收掉,防止内存的泄露问题

1.2 Clear()

多实用clear方法进行清除操作完成空间的复用,每次clear()只会将数据内容清空掉,不会清空list原有的扩容长度

 

 

认为利用了addAll();里面的边缘性返回值,导致了非异常-异常

如果list为null那么‘’;

就会抛出异常(在生产环境不能抛出异常这样)

问题在于:返回值有歧义

 

1.3ArrayList序列化问题

集合当中元素存放在被transient修饰的Object[]当中,元素不会被序列化

 

HashMap

put方法的hash计算

hashCode右移16位异或自身

 

1.1 comparableClassFor()

ParameterizedType代表类似ArrayList  包裹类型判断

 

 

奇妙算法2n次方的向上

 

1.2 get()方法

右移16位异或自身

getNode();方法 判断当中加上Hash计较,是为了加快运算效率,hash是int类型的

 

//Get方法
public V get(Object key) {
    HashMap.Node e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
//get方法
final HashMap.Node getNode(int hash, Object key) {
    HashMap.Node[] tab; HashMap.Node first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&//判断传入key是否在HashMap当中
            (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))//数组链表头节点是对应的key,则直接将Value返回
            return first;
        if ((e = first.next) != null) {//如果链表头不为对应数据则进行非空判断
            if (first instanceof HashMap.TreeNode)//判断类型是否为树
                return ((HashMap.TreeNode)first).getTreeNode(hash, key);
            do {        //为链表,do while循环取出链表当中的数据
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    //如果没有返回null值
    return null;
}

1.3 put();

//put元素核心方法putVal();详解

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node[] tab; Node p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)//如果数组为空进行设置初始容量
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)//计算出put元素的hash值与或节点数量判断存储节点是否为null进行存储
        tab[i] = newNode(hash, key, value, null);
    else {
        Node e; K k;
        if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof HashMap.TreeNode)//判断书否是树结构
            e = ((HashMap.TreeNode)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {//遍历链表节点进行节点的存储
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);//长度大于8时进行树化处理
                    break;
                }
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))//数据在链表当中存在直接返回null
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key//key重复进行覆盖操作
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold) //先添加后扩容操作
        resize();
    afterNodeInsertion(evict);
    return null;
}

 

1.4 resize();扩容方法

扩容为底层数组的长度

final HashMap.Node[] resize() {
    HashMap.Node[] oldTab = table;//old  16 长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;//16
    int oldThr = threshold;//12
    int newCap, newThr = 0;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {//超过2的30次方直接不管了
            
            threshold = Integer.MAX_VALUE;//2147483647
            return oldTab;
        }
        
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold//thr也进行扩容二倍
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                (int)ft : Integer.MAX_VALUE);
    }

    //======================上述创建临时节点进行扩容=================================

    //将临时节点换成新的存储节点进行扩容
    threshold = newThr;//真正的开始给threhod进行了newThr的赋值
    @SuppressWarnings({"rawtypes","unchecked"})
    HashMap.Node[] newTab = (HashMap.Node[])new HashMap.Node[newCap];
    table = newTab;//真正的开始给table  进行newTab的赋值


    //=========================开始节点的迁移========================================
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            HashMap.Node e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)//说明节点为空直接存储
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof HashMap.TreeNode)
                
                    ((HashMap.TreeNode)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    HashMap.Node loHead = null,//old 链表的 头节点
                            loTail = null;  //old 链表的尾节点
                    HashMap.Node hiHead = null,// new 链表的 投节点
                            hiTail = null;  //new 链表的尾节点
                    HashMap.Node next;


                    //创建链表
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {// 位置不变
                            if (loTail == null)
                                loHead = e; //头插
                            else
                                loTail.next = e;//尾插法
                            loTail = e;
                        }
                        else {//如果不等于0.变化位置,将该元素重新方到新的table当中
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);


                    //真正添加
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead; //这是真的将数据放入newTab里面了
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead; //这是真的将数据放入newTab里面了
                    }
                }
            }
        }
    }
    return newTab;
}

//sparkStream大数据处理

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/972318.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号