【数据结构】 HashMap 源码解析 面试题总结 jdk

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量339 收藏
点赞数
分类专栏： 数据结构 文章标签： hashmap java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42372033/article/details/107485442
版权

HashMap

文章目录

1. 结构特点:

  1. 存取无序

  2. 键和值都可以是null,但是所有键中只能有一个null (key不重复)

  3. 键位置是唯一的

  4. 数据结构

    jdk1.8前:数组+链表

    jdk1.8后:数组＋链表＋红黑树

  5. 阈值(链表长度)>8且数组长度大于64,将链表转化为红黑树(以此获得更高效的查询)

    如果链表长度大于8但是数组长度小于64,底层会将数组长度加倍,以此获得新的map,解决hash冲突

2. HashMap使用细节

ADD操作

@Test
    public void test(){
        HashMap <String,Integer> hm = new HashMap<>();
        hm.put("张三",23);
        hm.put("李四",23);
        hm.put("王五",23);
        hm.put("葛二蛋",23);
        System.out.println(hm.get("王五"));
    }

  1. HashMap <String,Integer> hm = new HashMap<>();

    jdk1.8之前: 在执行构造方法时,创建一个长度为16的Entry[] table

    jdk1.8之后: 在构造方法初不创建数组,而是在第一次put被调用时创建一个长度为16的Node[] table.

    // node节点信息,其中的next是为hash碰撞时,形成链表或者红黑树
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
}

  2. /[假定我们运行hm.put("张三",23);]这句

    • 根据键值"张三",获得hash值,结合当前的数组长度,进而计算出hash对应的索引

    • 若对应索引没有值,将创建一个新的Node节点插入这里

    • 如果对应索引有值,且hash值相等,且key值相同,覆盖旧的value

    • 如果该索引有值在里面,就会创建新的节点插入链表最后方,(如果此时的链表已经转变为红黑树,将会把这个节点插入红黑树中的响应位置)

    • 如果此时的阈值(链表长度)>8且数组长度大于64,将链表转化为红黑树

  3. 在不断的添加数据过程中,如果哈希表的填充值达到一个临界值(默认为0.75),就会进行扩容操作.默认的扩容方式是扩容为原来容量的2倍,并将原来的内容全部散列到新的数组中.

3. HashMap的成员变量

  1. 序列化版本号:

    private static final long serialVersionUID = 362498820763181265L;

  2. 集合的初始化容量

    //默认容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

    同时我们也可以通过某些构造方法进行指定初始容量,但是指定的初始容量一旦不是2的幂则向上去最小的整数幂

    public HashMap(int initialCapacity);		//指定初始容量和默认加载因子
public HashMap(int initialCapacity, float loadFactor);	//指定初始容量,以及加载因子

    问:为什么必须是2的n次幂

    因为我们寻找索引的方式是取余操作,而对于计算机来说,取余操作太过复杂,更快的是位运算,而当列表长度为2的n次幂的时候,我们就可以用位运算中的与运算来代替取余操作,(列表长度 - 1) & hash

    例如:我们的hash值为31,而我们的列表长度为16

    hash:31  			==>0001 1111
长度为16 (列表长度-1) 	==>0000 1111
此时与运算之后可以得到 0000 1111(15),刚好就是31%16的的数,

    例如反之

    如上右图:如果不是2的n次幂,如果直接使用取余操作,则会耗费大量算力,如果直接使用位运算,则会大概率造成哈希碰撞.造成链或者树过长,也会浪费未使用的空间,且浪费查询时的性能.所以,我们最好使用2的n次幂来作为初始容量,(其实,hashMap中直接为我们向上找到最小n次幂了)

  3. 默认负载因子

    static final float DEFAULT_LOAD_FACTOR = 0.75f;		// 默认为0.75

  4. 集合最大容量

    // 2的30次幂
static final int MAXIMUM_CAPACITY = 1 << 30;

  5. 链表与树的相互转变的边界值

    static final int TREEIFY_THRESHOLD = 8;			//当阈值到8时,如果节点为链表,会;变为红黑树
static final int UNTREEIFY_THRESHOLD = 6;		// 当阈值为6时,如果节点为红黑树,会变为链表

    因为树节点的大小大约是普通节点的两倍,所以我们只在箱子包含足够的节点时才使用树节点(参见TREEIFY_ THRESHOLD〕。当它们变得太小〔由于删除或调整大小〕时,就会被转换回普通的桶。在使用分布良好的用户hashcode时,很少使用树箱。理想情况下,在随机哈希码下,箱子中节点的频率服从泊松分布,节点数为8时,概率很小.所以说很少会用到红黑树.

泊松分布

  1. 如果table的长度小于64,当链表的大小大于8时,table会采用扩容的方式,而非链表转化红黑树

    static final int MIN_TREEIFY_CAPACITY = 64

  2. table用于初始化数组,且长度为2的n次幂

    transient Node<K,V>[] table;

  3. entrySet用于存放缓存数据

    transient Set<Map.Entry<K,V>> entrySet;

  4. size用于存放元素个数(键值对个数)

    transient int size;

  5. modeCount:哈希表的修改次数

    transient int modCount;

  6. 哈希表调整大小的边界值

    int threshold;

  7. 哈希表的加载因子

    final float loadFactor;

    加载因子表示hashMap的疏密程度,计算方式是size/capacity,也就是,存储的元素数/数组的长度.

    默认值为0.75,如果过低,可能会造成空间的浪费,同时扩容几率增高,消耗性能;如果过高,可能会造成元素过多,链表转化为红黑树的概率增大.同时也会消耗性能.

    扩容消耗性能,建议初始化时,指定capacity

4. hashMap的构造方法
	public HashMap();
    public HashMap(int initialCapacity);
    public HashMap(int initialCapacity, float loadFactor);
    public HashMap(Map<? extends K, ? extends V> m);
5. HashMap的部分核心方法

  1. put方法

    public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
    /**
     *
     * @param hash 计算的Hash值
     * @param key
     * @param value
     * @param onlyIfAbsent 是否在key字面量冲突的时候,保留原来的信息.默认为false,即替换信息
     * @param evict 表是否在创建模式，如果为false，则表是在创建模式。
     * @return
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;

        if ((tab = table) == null || (n = tab.length) == 0)
            //哈希表为空, 使用resize方法对哈希表进行初始化,并获得长度
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & has吧h]) == null)
            // 该可以对应的索引位置没有数据, 新建一个节点添加至索引处
            tab[i] = newNode(hash, key, value, null);
        else {
            // 此时为hash冲突情况
            HashMap.Node<K,V> e; K k;
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                // 此时为key的字面量重复情况, 将p标记到指针e上
                e = p;
            else if (p instanceof HashMap.TreeNode)
                // key的字面量没有重复,判断这个索引是否已经是红黑树,如果是的话就直接按照红黑树的插入方式获得插入地址,标记在指针e上
                e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    // 遍历链表的情况,查找是否有key的字面量重复的情况
                    if ((e = p.next) == null) {
                        // 如果到达链表最后端还没有key字面量冲突,直接添加新节点到最后,同时,e被置空
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 如果长度达到指定链表转化为红黑树的长度,进行数据结构转变
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        // 如果找到字面量冲突,直接停止,此时e已经指向了目标地址
                        break;
                    p = e;
                }
            }
            // 此时找到的e,是没有被添加的情况.可以在目标地址上进行添加信息
            if (e != null) { // existing mapping for 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;
    }

  2. resize

    // 用于哈希表扩容
final Node<K,V>[] resize() {
    // 声明变量区
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    
    if (oldCap > 0) {
        
        if (oldCap >= MAXIMUM_CAPACITY) {
            // 原哈希表的长度大于等于哈希表最大的长度,将边界值设置为最大Integer.MAX_VALUE
            threshold = Integer.MAX_VALUE;
            // 已经达到哈希表大小上限,未执行扩容
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 将新哈希表长度和边界值,设置为原来的2倍,等待执行扩容
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        // 只执行了构造方法,指定了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;
    @SuppressWarnings({"rawtypes","unchecked"})
    // 重新创建新的数组
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    // 当原来数组中有数据的时候,将这些数据放入到新的数组中
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            //获得数组中的每一个节点
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                // 将引用置空,防止后续的强引用导致虽然被remote,但是没有被回收
                oldTab[j] = null;
                if (e.next == null)
                    // 单个元素时
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    // 红黑树节点情况
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    // 链表节点情况
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        // 将索引为x的每一个数据提取出来,分别创建出两条链表
                        // 分别存储在索引为x,和x+oldCap的地方; //详情可见位运算
                        next = e.next;
                        //如果最高位没有余数,那么这里就是放在索引为x的位置
                        if ((e.hash & oldCap) == 0) {
                        // 具体解释看下方有讲解
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

    关于链表的转存问题

    链表转存

   假设 
  
e.hash为00000000 00000000 00000000 00010101
   newCap为32,oldCap为16

   此时则有
  
旧索引应该是:e.hash & (oldCap - 1)
   新索引应该是:e.hash & (newCap - 1)
  
接下来就是计算式(忽略了前16位)
   e.hash			0000 0000 0001 0101
  
newCap-1    	0000 0000 0001 1111
   oldCap-1    	0000 0000 0000 1111
  
旧索引应该是		0000 0000 0000 0101
   新索引应该是		0000 0000 0001 0101

   其中索引之间的关系只在新加的位置上,而如果不同的话就是将旧索引加上oldCap就可以得到新的索引位置.
  
   结论:所以说,旧表上的索引为[x]元素只可能分布在,新表中索引为[x],或者[x+oldCap]的位置,所以只需要考虑这两个位置

  1. remove方法

    @Override
public boolean remove(Object key, Object value) {
    // 内部调用
    return removeNode(hash(key), key, value, true, true) != null;
}
/**
* @param hash 
* @param key the key
* @param value the value to match if matchValue, else ignored
* @param matchValue if true only remove if value is equal
* @param movable if false do not move other nodes while removing
* @return the node, or null if none
*/
final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
    // 声明变量区
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        // 表格非空 && 表格长度合理 && 通过hash寻找的index处有数据
        
        Node<K,V> node = null, e; K k; V v;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            // hash相等 && (引用相同||判定相等)
            // 就是这个元素,直接带走(取得引用,标记在node上)
            node = p;
        else if ((e = p.next) != null) {	// 如果是链表或者红黑树
            if (p instanceof TreeNode)	//如果是红黑树
                //通过红黑树的方法获得这个元素的引用
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                // 链表
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        // 一直遍历,知道找到这个节点,标记在node上.直接break;
                        node = e;
                        break;
                    }
                    // 注意这句话,这个p将会是node的前导指针
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            // 如果找到了这个node
            
            if (node instanceof TreeNode)	//如果这个节点是树节点
                // 通过红黑树的方法去拿掉它
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                // 如果这个节点独占一个index
                tab[index] = node.next;
            else	// 这个节点再列表上
                p.next = node.next;
            
            // 增加修改次数(标记,防止异步操作)
            ++modCount;
            // 元素数--
            --size;
            //
            afterNodeRemoval(node);
            // 获得了这个节点
            return node;
        }
    }
    return null;
}

  2. get方法

    	// 用key获得值
	public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            // 数组符合条件且hash对应的索引上有值
            
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                //如果第一个就是,直接带走
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    //如果 碰上红黑树的情况,使用红黑树的方法进行获得节点 或者没找到 返回null
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    // 这里就是链表了,循环找到这个节点
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        // 当数组不符合条件,或者索引处没有值(第一个if), 又或者前面的几个寻找没有找到.这里来兜底,保证返回null
        return null;
    }
6. HashMap的遍历
HashMap<String,String> hm = new HashMap();
hm.put("zs","张三");
// ... ... 添加数据

  1. key,values的遍历

        for (String key:hm.keySet()){
        System.out.println(key);
    }
    for (String value:hm.values()){
        System.out.println(value);
    }

  2. 迭代器遍历

    	Iterator<Map.Entry<String,String>> iterator = hm.entrySet().iterator();
    while(iterator.hasNext()){
        Map.Entry<String, String> entry = iterator.next();
        System.out.println(entry.getKey()+"=======\t"+entry.getValue());
    }

  3. 使用get遍历(迭代两次,效率低)

        for (String key:hm.keySet()){
        System.out.println(key+"===="+hm.get(key));
    }

  4. 使用Map中的默认接口(jdk 1.8 后)

    	hm.forEach((key,value)->{
    	System.out.println(key+"---"+value);
	});

面试题

  1. 哈希表底层采用什么算法计算出hash值,还有哪些方式可以计算出hash值

    底层采用key的hashCode方法,然后对其进行按位异或(^),无符号右移(>>>)得出hash值

    static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

    ​ 其他还可以采用平方取中法取关键字的平方，然后根据可使用空间的大小，选取平方数是中间几位为哈希地址,取余数,伪随机数法,但是位运算的效率高

  2. 如果两个对象的hashCode相等时会怎么样?

    此时会产生哈希碰撞,在插入的时候比较key的值是否相同,如果相同再决定时候覆盖信息,如果不同的话进行插入操作,放在该索引值下的链表的最后或者红黑树的相应位置

  3. 什么是哈希碰撞,何时产生hash碰撞,如何解决哈希碰撞

    q1: 有可能两个不同的原始值在经过哈希运算后得到同样的结果，这样就是哈希碰撞

    q2: 两个插入信息的key值对应计算出的hash值相同就会产生哈希碰撞

    q3: 在哈希表中,jdk1.8前使用:数组+链表解决哈希冲突,jdk1.8后使用:数组＋链表＋红黑树

  4. 如果两个键的hashcode相同,如何进行存储

    使用equals判断key的内容是否相同

    如果相同则直接使用新的value覆盖原有的

    如果不相同,则直接插入新的数据节点

飞起来_大石
关注
专栏目录
Java 面试之数据结构
博学de叫兽
08-28 5万+
常见数据结构 HashMap、Hashtable、 ConcurrentHashMap HashMap 底层实现：HashMap底层整体结构是一个数组，数组中的每个元素又是一个链表。每次添加一个对象（put）时会产生一个链表对象（Object类型），Map中的每个Entry就是数组中的一个元素（Map.Entry就是一个&amp;amp;amp;amp;amp;amp;amp;amp;lt;Key,Value&amp;amp;amp;amp;amp;amp;amp;amp;g
HashMap的源码解读以及面试题
G探险者的博客
07-16 176
先看几道HashMap的面试题： 1、请简述HashMap的底层存储数据结构？ 2、HashMap的key的hash值是如何计算的？为什么这样实现？ 3、HashMap的默认容量是多少？加载因子是什么？容量如何变化？容量不够怎么办？ 4、HashMap调用put方法底层数据的存放过程？ 5、HashMap链表节点过深时为什么选择使用红黑树？ 6、什么是红黑树，谈谈你对红黑树的理解？ 7、什么是hash碰撞，发生hash碰撞怎么办？ 8、JDK1.7和JDK1.8的HashMap有什么不同？
JDK1.8中hashmap的面试题，这一个文章都帮你解决了
weekendzhu的小屋
05-11 2421
1. hashmap的面试题 (google搜索hashmap关键字取前三页的结果) 摘自 https://blog.csdn.net/u012512634/article/details/72735183 https://cloud.tencent.com/developer/article/1508095 https://www.jianshu.com/p/bf703c34072b https://cloud.tencent.com/developer/article/1508095 https://w
HashMap底层源码解析上（超详细图解+面试题）
wenwenaier的博客
11-22 4571
* Because TreeNodes are about twice the size of regular nodes, we * use them only when bins contain enough nodes to warrant use * (see TREEIFY_THRESHOLD). And when they become too small (due to * removal or resizing) they are converted
史上最详细的 JDK 1.8 HashMap 源码解析
热门推荐
程序员囧辉
01-07 11万+
可能是史上最详细的 HashMap 源码解析。
HashMap源码解读(面试题剖析)
莫安逸无风雪
06-16 819
HashMap源码深度剖析，对几个有意思的方法进行了分析，如初始化容量如果转换为2的n次幂，扩容过程，存储和获取对象方法，以及面试题的总结
JDK 1.8 HashMap解析
非学无以广才，非志无以成学
07-11 3630
Map在Java里边是一个接口，常见的实现类有HashMap、LinkedHashMap、TreeMap、hashTable和ConcurrentHashMap在Java中，哈希表的结构是数组+链表的方式 HashMap底层数据结构是数组+链表/红黑树 LinkedHashMap底层数据结构是数组+链表/红黑树+双向链表 TreeMap底层数据结构是红黑树 HashTable底层数据结构是数组+链表 而ConcurrentHashMap底层数据结构也是数组+链表/红黑树思考：源码基本属性： table 数组
超详细 JDK7、8HashMap扩容流程 源码解析、读后总结一套给你搞定!!!
Code皮皮虾的博客
03-23 872
文章目录前言JDK7 HashMap扩容JDK8 HashMap扩容 前言 JDK7 和JDK8 的扩容方法都基于 resize()方法，但底层实现却有所不同 JDK7 HashMap扩容 void addEntry(int hash, K key, V value, int bucketIndex) { if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table
MyBatis 源码解析 面试题总结
Zyw907155124的博客
03-31 1085
MyBatis1、工作原理2、MyBatis的缓存3、缓存扩展4、设计模式5、SqlSessionFactory的理解6、SqlSession的理解7、对MyBatis的理解8、分页的理解9、插件原理10、不同Mapper中的id是否可以相同？11、架构设计的理解12、传统JDBC开发13的不足13、数据源模块的设计14、事务模块的设计15、Mapper接口的设计理解16、Reflector模块的理解17、类型转换模块18、spring/SpringBoot整合MyBatis
HashMap知识点总结（附源码分析链接）
qq_45369827的博客
03-17 1535
HashMap面试题总结（防备面试官连环提问） HashMap基础 讲下对HashMap的认识 HashMap的初始化默认参数 HashMap的扩容机制 HashMap为什么在JDK1.8为添加了红黑树的数据结构 链表升级成红黑树的条件 红黑树退化成链表的条件 为什么Hashmap的长度必须是2的n次幂 HashMap获取的Hash值的方法（HashMap可以存key为null的主键吗） 为什么在获取hash值时要把key 的 HashCode 和它的低16位做异或 HaspMap的初始化时数组长度和加
吊打面试官系列：HashMap详细介绍(源码解析)和使用示例
m0_68850571的博客
04-24 167
概要 这一章，我们对HashMap进行学习。 我们先对HashMap有个整体认识，然后再学习它的源码，最后再通过实例来学会使用HashMap。内容包括： 第1部分 HashMap介绍 第2部分 HashMap数据结构 第3部分 HashMap源码解析(基于JDK1.6.0_45) 第3.1部分 HashMap的“拉链法”相关内容 第3.2部分 HashMap的构造函数 第3.3部分 HashMap的主要对外接口 第3.4部分 HashMap实现的Cloneable接口 第3.5部分 HashMap实现的
大数据开发面试题总结-超详细
JohnnyChu的博客
11-18 1万+
1、文件上传： 总结： 客户端上传请求--->namenode检查，返回响应--->客户端真正的文件上传请求，包括文件名，文件大小--->namenode返回上传节点--->客户端准备上传，进行块的逻辑切分--->客户端构建pipline流--->开始上传，先上传到缓存中，再上传到磁盘--->上传完成，关闭pipline流--->上...
Java-网络
2301_81543552的博客
09-14 792
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
最新发布
m0_74972727的博客
09-15 825
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 759
如果在新建Android项目时报错：Read timed out或者connect timed out。
上传文件到钉盘流程详解
jspyth的博客
09-14 811
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值