图解LinkedHashMap原理

1 前言

LinkedHashMap继承于HashMap,如果对HashMap原理还不清楚的同学,请先看上一篇:图解HashMap原理

2 LinkedHashMap使用与实现

先来一张LinkedHashMap的结构图,不要虚,看完文章再来看这个图,就秒懂了,先混个面熟
在这里插入图片描述
2.1 应用场景
HashMap是无序的,当我们希望有顺序地去存储key-value时,就需要使用LinkedHashMap了。

   Map<String, String> hashMap = new HashMap<String, String>();hashMap.put("name1", "josan1");hashMap.put("name2", "josan2");hashMap.put("name3", "josan3");Set<Entry<String, String>> set = hashMap.entrySet();Iterator<Entry<String, String>> iterator = set.iterator();while(iterator.hasNext()) {Entry entry = iterator.next();String key = (String) entry.getKey();String value = (String) entry.getValue();System.out.println("key:" + key + ",value:" + value);}

在这里插入图片描述
我们是按照xxx1、xxx2、xxx3的顺序插入的,但是输出结果并不是按照顺序的。

同样的数据,我们再试试LinkedHashMap

 Map<String, String> linkedHashMap = new LinkedHashMap<>();linkedHashMap.put("name1", "josan1");linkedHashMap.put("name2", "josan2");linkedHashMap.put("name3", "josan3");Set<Entry<String, String>> set = linkedHashMap.entrySet();Iterator<Entry<String, String>> iterator = set.iterator();while(iterator.hasNext()) {Entry entry = iterator.next();String key = (String) entry.getKey();String value = (String) entry.getValue();System.out.println("key:" + key + ",value:" + value);}

在这里插入图片描述
结果可知,LinkedHashMap是有序的,且默认为插入顺序。

2.2 简单使用
跟HashMap一样,它也是提供了key-value的存储方式,并提供了put和get方法来进行数据存取。

 LinkedHashMap<String, String> linkedHashMap = new LinkedHashMap<>();linkedHashMap.put("name", "josan");String name = linkedHashMap.get("name");

2.3 定义
LinkedHashMap继承了HashMap,所以它们有很多相似的地方。

public class LinkedHashMap<K,V>extends HashMap<K,V>implements Map<K,V>
{

2.4 构造方法
在这里插入图片描述
LinkedHashMap提供了多个构造方法,我们先看空参的构造方法。

 public LinkedHashMap() {// 调用HashMap的构造方法,其实就是初始化Entry[] tablesuper();// 这里是指是否基于访问排序,默认为falseaccessOrder = false;}

首先使用super调用了父类HashMap的构造方法,其实就是根据初始容量、负载因子去初始化Entry[] table,详细的看上一篇HashMap解析。

然后把accessOrder设置为false,这就跟存储的顺序有关了,LinkedHashMap存储数据是有序的,而且分为两种:插入顺序和访问顺序。

这里accessOrder设置为false,表示不是访问顺序而是插入顺序存储的,这也是默认值,表示LinkedHashMap中存储的顺序是按照调用put方法插入的顺序进行排序的。LinkedHashMap也提供了可以设置accessOrder的构造方法,我们来看看这种模式下,它的顺序有什么特点?

          // 第三个参数用于指定accessOrder值Map<String, String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true);linkedHashMap.put("name1", "josan1");linkedHashMap.put("name2", "josan2");linkedHashMap.put("name3", "josan3");System.out.println("开始时顺序:");Set<Entry<String, String>> set = linkedHashMap.entrySet();Iterator<Entry<String, String>> iterator = set.iterator();while(iterator.hasNext()) {Entry entry = iterator.next();String key = (String) entry.getKey();String value = (String) entry.getValue();System.out.println("key:" + key + ",value:" + value);}System.out.println("通过get方法,导致key为name1对应的Entry到表尾");linkedHashMap.get("name1");Set<Entry<String, String>> set2 = linkedHashMap.entrySet();Iterator<Entry<String, String>> iterator2 = set2.iterator();while(iterator2.hasNext()) {Entry entry = iterator2.next();String key = (String) entry.getKey();String value = (String) entry.getValue();System.out.println("key:" + key + ",value:" + value);}

在这里插入图片描述
因为调用了get(“name1”)导致了name1对应的Entry移动到了最后,这里只要知道LinkedHashMap有插入顺序和访问顺序两种就可以,后面会详细讲原理。

还记得,上一篇HashMap解析中提到,在HashMap的构造函数中,调用了init方法,而在HashMap中init方法是空实现,但LinkedHashMap重写了该方法,所以在LinkedHashMap的构造方法里,调用了自身的init方法,init的重写实现如下:

 /*** Called by superclass constructors and pseudoconstructors (clone,* readObject) before any entries are inserted into the map.  Initializes* the chain.*/@Overridevoid init() {// 创建了一个hash=-1,key、value、next都为null的Entryheader = new Entry<>(-1, null, null, null);// 让创建的Entry的before和after都指向自身,注意after不是之前提到的next// 其实就是创建了一个只有头部节点的双向链表header.before = header.after = header;}

这好像跟我们上一篇HashMap提到的Entry有些不一样,HashMap中静态内部类Entry是这样定义的:

  static class Entry<K,V> implements Map.Entry<K,V> {final K key;V value;Entry<K,V> next;int hash;

没有before和after属性啊!原来,LinkedHashMap有自己的静态内部类Entry,它继承了HashMap.Entry,定义如下:

 /*** LinkedHashMap entry.*/private static class Entry<K,V> extends HashMap.Entry<K,V> {// These fields comprise the doubly linked list used for iteration.Entry<K,V> before, after;Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {super(hash, key, value, next);}

所以LinkedHashMap构造函数,主要就是调用HashMap构造函数初始化了一个Entry[] table,然后调用自身的init初始化了一个只有头结点的双向链表。完成了如下操作:
在这里插入图片描述
2.5 put方法
LinkedHashMap没有重写put方法,所以还是调用HashMap得到put方法,如下:

  public V put(K key, V value) {// 对key为null的处理if (key == null)return putForNullKey(value);// 计算hashint hash = hash(key);// 得到在table中的indexint i = indexFor(hash, table.length);// 遍历table[index],是否key已经存在,存在则替换,并返回旧值for (Entry<K,V> e = table[i]; e != null; e = e.next) {Object k;if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {V oldValue = e.value;e.value = value;e.recordAccess(this);return oldValue;}}modCount++;// 如果key之前在table中不存在,则调用addEntry,LinkedHashMap重写了该方法addEntry(hash, key, value, i);return null;}

我们看看LinkedHashMap的addEntry方法:

  void addEntry(int hash, K key, V value, int bucketIndex) {// 调用父类的addEntry,增加一个Entry到HashMap中super.addEntry(hash, key, value, bucketIndex);// removeEldestEntry方法默认返回false,不用考虑Entry<K,V> eldest = header.after;if (removeEldestEntry(eldest)) {removeEntryForKey(eldest.key);}}

这里调用了父类HashMap的addEntry方法,如下:

 void addEntry(int hash, K key, V value, int bucketIndex) {// 扩容相关if ((size >= threshold) && (null != table[bucketIndex])) {resize(2 * table.length);hash = (null != key) ? hash(key) : 0;bucketIndex = indexFor(hash, table.length);}// LinkedHashMap进行了重写createEntry(hash, key, value, bucketIndex);}

前面是扩容相关的代码,在上一篇HashMap解析中已经讲过了。这里主要看createEntry方法,LinkedHashMap进行了重写。

 void createEntry(int hash, K key, V value, int bucketIndex) {HashMap.Entry<K,V> old = table[bucketIndex];// e就是新创建了Entry,会加入到table[bucketIndex]的表头Entry<K,V> e = new Entry<>(hash, key, value, old);table[bucketIndex] = e;// 把新创建的Entry,加入到双向链表中e.addBefore(header);size++;}

我们来看看LinkedHashMap.Entry的addBefore方法:

  private void addBefore(Entry<K,V> existingEntry) {after  = existingEntry;before = existingEntry.before;before.after = this;after.before = this;}

从这里就可以看出,当put元素时,不但要把它加入到HashMap中去,还要加入到双向链表中,所以可以看出LinkedHashMap就是HashMap+双向链表,下面用图来表示逐步往LinkedHashMap中添加数据的过程,红色部分是双向链表,黑色部分是HashMap结构,header是一个Entry类型的双向链表表头,本身不存储数据。

首先是只加入一个元素Entry1,假设index为0:
在这里插入图片描述
当再加入一个元素Entry2,假设index为15:
在这里插入图片描述
当再加入一个元素Entry3, 假设index也是0:
在这里插入图片描述
以上,就是LinkedHashMap的put的所有过程了,总体来看,跟HashMap的put类似,只不过多了把新增的Entry加入到双向列表中。
2.6 扩容
在HashMap的put方法中,如果发现前元素个数超过了扩容阀值时,会调用resize方法,如下:

 void resize(int newCapacity) {Entry[] oldTable = table;int oldCapacity = oldTable.length;if (oldCapacity == MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return;}Entry[] newTable = new Entry[newCapacity];boolean oldAltHashing = useAltHashing;useAltHashing |= sun.misc.VM.isBooted() &&(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);boolean rehash = oldAltHashing ^ useAltHashing;// 把旧table的数据迁移到新tabletransfer(newTable, rehash);table = newTable;threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);}

LinkedHashMap重写了transfer方法,数据的迁移,它的实现如下:

void transfer(HashMap.Entry[] newTable, boolean rehash) {// 扩容后的容量是之前的2倍int newCapacity = newTable.length;// 遍历双向链表,把所有双向链表中的Entry,重新就算hash,并加入到新的table中for (Entry<K,V> e = header.after; e != header; e = e.after) {if (rehash)e.hash = (e.key == null) ? 0 : hash(e.key);int index = indexFor(e.hash, newCapacity);e.next = newTable[index];newTable[index] = e;}}

可以看出,LinkedHashMap扩容时,数据的再散列和HashMap是不一样的。

HashMap是先遍历旧table,再遍历旧table中每个元素的单向链表,取得Entry以后,重新计算hash值,然后存放到新table的对应位置。

LinkedHashMap是遍历的双向链表,取得每一个Entry,然后重新计算hash值,然后存放到新table的对应位置。

从遍历的效率来说,遍历双向链表的效率要高于遍历table,因为遍历双向链表是N次(N为元素个数);而遍历table是N+table的空余个数(N为元素个数)。
2.7 双向链表的重排序
前面分析的,主要是当前LinkedHashMap中不存在当前key时,新增Entry的情况。当key如果已经存在时,则进行更新Entry的value。就是HashMap的put方法中的如下代码:

 for (Entry<K,V> e = table[i]; e != null; e = e.next) {Object k;if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {V oldValue = e.value;e.value = value;// 重排序e.recordAccess(this);return oldValue;}}

主要看e.recordAccess(this),这个方法跟访问顺序有关,而HashMap是无序的,所以在HashMap.Entry的recordAccess方法是空实现,但是LinkedHashMap是有序的,LinkedHashMap.Entry对recordAccess方法进行了重写。

 void recordAccess(HashMap<K,V> m) {LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;// 如果LinkedHashMap的accessOrder为true,则进行重排序// 比如前面提到LruCache中使用到的LinkedHashMap的accessOrder属性就为trueif (lm.accessOrder) {lm.modCount++;// 把更新的Entry从双向链表中移除remove();// 再把更新的Entry加入到双向链表的表尾addBefore(lm.header);}}

在LinkedHashMap中,只有accessOrder为true,即是访问顺序模式,才会put时对更新的Entry进行重新排序,而如果是插入顺序模式时,不会重新排序,这里的排序跟在HashMap中存储没有关系,只是指在双向链表中的顺序。

举个栗子:开始时,HashMap中有Entry1、Entry2、Entry3,并设置LinkedHashMap为访问顺序,则更新Entry1时,会先把Entry1从双向链表中删除,然后再把Entry1加入到双向链表的表尾,而Entry1在HashMap结构中的存储位置没有变化,对比图如下所示:

在这里插入图片描述
2.8 get方法
LinkedHashMap有对get方法进行了重写,如下:

 public V get(Object key) {// 调用genEntry得到EntryEntry<K,V> e = (Entry<K,V>)getEntry(key);if (e == null)return null;// 如果LinkedHashMap是访问顺序的,则get时,也需要重新排序e.recordAccess(this);return e.value;}

先是调用了getEntry方法,通过key得到Entry,而LinkedHashMap并没有重写getEntry方法,所以调用的是HashMap的getEntry方法,在上一篇文章中我们分析过HashMap的getEntry方法:首先通过key算出hash值,然后根据hash值算出在table中存储的index,然后遍历table[index]的单向链表去对比key,如果找到了就返回Entry。

后面调用了LinkedHashMap.Entry的recordAccess方法,上面分析过put过程中这个方法,其实就是在访问顺序的LinkedHashMap进行了get操作以后,重新排序,把get的Entry移动到双向链表的表尾。

2.9 遍历方式取数据
我们先来看看HashMap使用遍历方式取数据的过程:
在这里插入图片描述
很明显,这样取出来的Entry顺序肯定跟插入顺序不同了,既然LinkedHashMap是有序的,那么它是怎么实现的呢?
先看看LinkedHashMap取遍历方式获取数据的代码:

 Map<String, String> linkedHashMap = new LinkedHashMap<>();linkedHashMap.put("name1", "josan1");linkedHashMap.put("name2", "josan2");linkedHashMap.put("name3", "josan3");// LinkedHashMap没有重写该方法,调用的HashMap中的entrySet方法Set<Entry<String, String>> set = linkedHashMap.entrySet();Iterator<Entry<String, String>> iterator = set.iterator();while(iterator.hasNext()) {Entry entry = iterator.next();String key = (String) entry.getKey();String value = (String) entry.getValue();System.out.println("key:" + key + ",value:" + value);}

LinkedHashMap没有重写entrySet方法,我们先来看HashMap中的entrySet,如下:

public Set<Map.Entry<K,V>> entrySet() {return entrySet0();}private Set<Map.Entry<K,V>> entrySet0() {Set<Map.Entry<K,V>> es = entrySet;return es != null ? es : (entrySet = new EntrySet());}private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {public Iterator<Map.Entry<K,V>> iterator() {return newEntryIterator();}// 无关代码......}

可以看到,HashMap的entrySet方法,其实就是返回了一个EntrySet对象。

我们得到EntrySet会调用它的iterator方法去得到迭代器Iterator,从上面的代码也可以看到,iterator方法中直接调用了newEntryIterator方法并返回,而LinkedHashMap重写了该方法

  Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator();}

这里直接返回了EntryIterator对象,这个和上一篇HashMap中的newEntryIterator方法中一模一样,都是返回了EntryIterator对象,其实他们返回的是各自的内部类。我们来看看LinkedHashMap中EntryIterator的定义:

private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {public Map.Entry<K,V> next() { return nextEntry();}}

该类是继承LinkedHashIterator,并重写了next方法;而HashMap中是继承HashIterator。
我们再来看看LinkedHashIterator的定义:

 private abstract class LinkedHashIterator<T> implements Iterator<T> {// 默认下一个返回的Entry为双向链表表头的下一个元素Entry<K,V> nextEntry    = header.after;Entry<K,V> lastReturned = null;public boolean hasNext() {return nextEntry != header;}Entry<K,V> nextEntry() {if (modCount != expectedModCount)throw new ConcurrentModificationException();if (nextEntry == header)throw new NoSuchElementException();Entry<K,V> e = lastReturned = nextEntry;nextEntry = e.after;return e;}// 不相关代码......}

我们先不看整个类的实现,只要知道在LinkedHashMap中,Iterator<Entry<String, String>> iterator = set.iterator(),这段代码会返回一个继承LinkedHashIterator的Iterator,它有着跟HashIterator不一样的遍历规则。

接着,我们会用while(iterator.hasNext())去循环判断是否有下一个元素,LinkedHashMap中的EntryIterator没有重写该方法,所以还是调用LinkedHashIterator中的hasNext方法,如下:

  public boolean hasNext() {// 下一个应该返回的Entry是否就是双向链表的头结点// 有两种情况:1.LinkedHashMap中没有元素;2.遍历完双向链表回到头部return nextEntry != header;}

nextEntry表示下一个应该返回的Entry,默认值是header.after,即双向链表表头的下一个元素。而上面介绍到,LinkedHashMap在初始化时,会调用init方法去初始化一个before和after都指向自身的Entry,但是put过程会把新增加的Entry加入到双向链表的表尾,所以只要LinkedHashMap中有元素,第一次调用hasNext肯定不会为false。

然后我们会调用next方法去取出Entry,LinkedHashMap中的EntryIterator重写了该方法,如下:

 public Map.Entry<K,V> next() { return nextEntry(); 
}

而它自身又没有重写nextEntry方法,所以还是调用的LinkedHashIterator中的nextEntry方法:

 Entry<K,V> nextEntry() {// 保存应该返回的EntryEntry<K,V> e = lastReturned = nextEntry;//把当前应该返回的Entry的after作为下一个应该返回的EntrynextEntry = e.after;// 返回当前应该返回的Entryreturn e;}

这里其实遍历的是双向链表,所以不会存在HashMap中需要寻找下一条单向链表的情况,从头结点Entry header的下一个节点开始,只要把当前返回的Entry的after作为下一个应该返回的节点即可。直到到达双向链表的尾部时,after为双向链表的表头节点Entry header,这时候hasNext就会返回false,表示没有下一个元素了。LinkedHashMap的遍历取值如下图所示:
在这里插入图片描述
易知,遍历出来的结果为Entry1、Entry2…Entry6。
可得,LinkedHashMap是有序的,且是通过双向链表来保证顺序的。

2.10 remove方法
LinkedHashMap没有提供remove方法,所以调用的是HashMap的remove方法,实现如下:

 public V remove(Object key) {Entry<K,V> e = removeEntryForKey(key);return (e == null ? null : e.value);}final Entry<K,V> removeEntryForKey(Object key) {int hash = (key == null) ? 0 : hash(key);int i = indexFor(hash, table.length);Entry<K,V> prev = table[i];Entry<K,V> e = prev;while (e != null) {Entry<K,V> next = e.next;Object k;if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k)))) {modCount++;size--;if (prev == e)table[i] = next;elseprev.next = next;// LinkedHashMap.Entry重写了该方法e.recordRemoval(this);return e;}prev = e;e = next;}return e;}
在上一篇HashMap中就分析了remove过程,其实就是断开其他对象对自己的引用。比如被删除Entry是在单向链表的表头,则让它的next放到表头,这样它就没有被引用了;如果不是在表头,它是被别的Entry的next引用着,这时候就让上一个Entry的next指向它自己的next,这样,它也就没被引用了。在HashMap.Entry中recordRemoval方法是空实现,但是LinkedHashMap.Entry对其进行了重写,如下:void recordRemoval(HashMap<K,V> m) {remove();}private void remove() {before.after = after;after.before = before;}

易知,这是要把双向链表中的Entry删除,也就是要断开当前要被删除的Entry被其他对象通过after和before的方式引用。

所以,LinkedHashMap的remove操作。首先把它从table中删除,即断开table或者其他对象通过next对其引用,然后也要把它从双向链表中删除,断开其他对应通过after和before对其引用。

3 HashMap与LinkedHashMap的结构对比

再来看看HashMap和LinkedHashMap的结构图,是不是秒懂了。LinkedHashMap其实就是可以看成HashMap的基础上,多了一个双向链表来维持顺序。
在这里插入图片描述
在这里插入图片描述

4 LinkedHashMap在Android中的应用

在Android中使用图片时,一般会用LruCacha做图片的内存缓存,它里面就是使用LinkedHashMap来实现存储的。

public class LruCache<K, V> {private final LinkedHashMap<K, V> map;public LruCache(int maxSize) {if (maxSize <= 0) {throw new IllegalArgumentException("maxSize <= 0");}this.maxSize = maxSize;// 注意第三个参数,是accessOrder,这里为true,后面会讲到this.map = new LinkedHashMap<K, V>(0, 0.75f, true);}

前面提到了,accessOrder为true,表示LinkedHashMap为访问顺序,当对已存在LinkedHashMap中的Entry进行get和put操作时,会把Entry移动到双向链表的表尾(其实是先删除,再插入)。
我们拿LruCache的put方法举例:

 public final V put(K key, V value) {if (key == null || value == null) {throw new NullPointerException("key == null || value == null");}V previous;// 对map进行操作之前,先进行同步操作synchronized (this) {putCount++;size += safeSizeOf(key, value);previous = map.put(key, value);if (previous != null) {size -= safeSizeOf(key, previous);}}if (previous != null) {entryRemoved(false, key, previous, value);}// 整理内存,看是否需要移除LinkedHashMap中的元素trimToSize(maxSize);return previous;}

之前提到了,HashMap是线程不安全的,LinkedHashMap同样是线程不安全的。所以在对调用LinkedHashMap的put方法时,先使用synchronized 进行了同步操作。

我们最关心的是倒数第一行代码,其中maxSize为我们给LruCache设置的最大缓存大小。我们看看该方法:

  /*** Remove the eldest entries until the total of remaining entries is at or* below the requested size.** @param maxSize the maximum size of the cache before returning. May be -1*            to evict even 0-sized elements.*/public void trimToSize(int maxSize) {// while死循环,直到满足当前缓存大小小于或等于最大可缓存大小while (true) {K key;V value;// 线程不安全,需要同步synchronized (this) {if (size < 0 || (map.isEmpty() && size != 0)) {throw new IllegalStateException(getClass().getName()+ ".sizeOf() is reporting inconsistent results!");}// 如果当前缓存的大小,已经小于等于最大可缓存大小,则直接返回// 不需要再移除LinkedHashMap中的数据if (size <= maxSize || map.isEmpty()) {break;}// 得到的就是双向链表表头header的下一个EntryMap.Entry<K, V> toEvict = map.entrySet().iterator().next();key = toEvict.getKey();value = toEvict.getValue();// 移除当前取出的Entrymap.remove(key);// 从新计算当前的缓存大小size -= safeSizeOf(key, value);evictionCount++;}entryRemoved(true, key, value, null);}}

从注释上就可以看出,该方法就是不断移除LinkedHashMap中双向链表表头的元素,直到当前缓存大小小于或等于最大可缓存的大小。

由前面的重排序我们知道,对LinkedHashMap的put和get操作,都会让被操作的Entry移动到双向链表的表尾,而移除是从map.entrySet().iterator().next()开始的,也就是双向链表的表头的header的after开始的,这也就符合了LRU算法的需求。

下图表示了LinkedHashMap中删除、添加、get/put已存在的Entry操作。
红色表示初始状态
紫色表示缓存图片大小超过了最大可缓存大小时,才能够表头移除Entry1
蓝色表示对已存在的Entry3进行了get/put操作,把它移动到双向链表表尾
绿色表示新增一个Entry7,插入到双向链表的表尾(暂时不考虑在HashMap中的位置)
在这里插入图片描述

5 总结

LinkedHashMap是继承于HashMap,是基于HashMap和双向链表来实现的。
HashMap无序;LinkedHashMap有序,可分为插入顺序和访问顺序两种。如果是访问顺序,那put和get操作已存在的Entry时,都会把Entry移动到双向链表的表尾(其实是先删除再插入)。
LinkedHashMap存取数据,还是跟HashMap一样使用的Entry[]的方式,双向链表只是为了保证顺序。
LinkedHashMap是线程不安全的。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/249629.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

2019 GUDT RC 2 Problem C(题解)

原题 题目大意 这道题的背景是农夫和牛爬山,给出山的高度L,农夫会从山底以rF的速度爬山,中途不会休息,牛会从山底以rB的速度爬山,可以在休息站休息并吃草,在第i个休息站休息ti时间,牛可以吃t*ci的草,第i个休息站的高度为xi.农夫和牛同时出发,要求牛在不被农夫追上的同时吃最多的…

Express + Element-ui 实现图片/文件上传

使用第三方插件 formidable 处理表单数据/文件 Express 4 以前&#xff0c;我们通常使用 req.files 来对请求中的文件进行处理&#xff0c;但在 Express 4 中这种用法已经被抛弃&#xff0c;默认情况下 req.files 在 req 对象上不再可用。官方推荐我们使用第三方中间件。 在这里…

10-04 矩形覆盖(斐波那契数列的应用)

题目描述&#xff1a; 我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形&#xff0c;总共有多少种方法&#xff1f; 解题思路与代码&#xff1a; 1&#xff09; 排列组合&#xff1a; class Solution { public:int rectC…

Spring 源码分析 spring-core

先来看下 spring-core 的包结构 总共有6个模块&#xff0c;分别是 asm、cglib、core、lang、objenesis、util asm包&#xff1a; 用来操作字节码&#xff0c;动态生成类或者增强既有类的功能。主要包含以下这些类。详细功能。 https://www.ibm.com/developerworks/cn/java/j…

大数据项目中的QA需要迎接新的挑战

大数据项目中的QA需要迎接新的挑战根据IDC全球半年度大数据和分析支出指南的最新预测&#xff0c;到2022年全球大数据和业务分析解决方案的收入将达到2600亿美元。在大数据和业务分析解决方案上投资增长最快的行业包括银行&#xff08;复合年增长率13.3%&#xff09;、医疗、保…

spring源码分析之spring-core总结篇

1.spring-core概览 spring-core是spring框架的基石&#xff0c;它为spring框架提供了基础的支持。 spring-core从源码上看&#xff0c;分为6个package&#xff0c;分别是asm&#xff0c;cglib&#xff0c;core&#xff0c;lang&#xff0c;objenesis和util。 1.1 asm 关于as…

五分钟搞懂后缀数组!

为什么学后缀数组 后缀数组是一个比较强大的处理字符串的算法&#xff0c;是有关字符串的基础算法&#xff0c;所以必须掌握。 学会后缀自动机(SAM)就不用学后缀数组(SA)了&#xff1f;不&#xff0c;虽然SAM看起来更为强大和全面&#xff0c;但是有些SAM解决不了的问题能被SA解…

spring-core

spring最核心的组件是BeanFactory&#xff0c;看了源码才发现&#xff0c;BeanFactory并非定义在spring-core中&#xff0c;那spring-core都有啥东东&#xff1f; spring-core主要提供以下服务&#xff0c;为BeanFactory的定义提供基础服务。 1, ConversionService Conversi…

nginx配置静态文件过期时间

1. 编辑虚拟主机配置文件/usr/local/nginx/conf/vhosts/huangzhenping.conf 说明&#xff1a;采用location方式 12345678910location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)${access_log off;expires 1d;}location ~ \.(js|css){access_log off;expires 1d;}2. 检查配置文件&#x…

Spring Beans 初始化流程分析

测试用例 依然使用这个官网上的用例&#xff0c;来进行调试&#xff1b; Person.java package org.shangyang.spring.container;/**- - author shangyang**/public class Person {String name;Person spouse;public String getName() {return name;}public void setName(Stri…

VSCode中怎么改变文件夹的图标

昨天更新了VSCode后我的文件夹图标莫名其妙的没有了&#xff0c;变成了下图这样 看着真的让我难受的头皮发麻&#xff0c;本来打代码就头发少&#xff0c;难道非要让我变成秃头&#xff0c;不可能不可能&#xff0c;所以我找了找怎么解决 来&#xff0c;各位看官上眼 如图所示 …

springxml解析

1.XML验证模式的认识 首先XML的验证模式有两种&#xff1a;DTD和XSD。 DTD文档类型定义&#xff0c;是XML约束模式语言。它是为了保证XML文档格式正确有效的方法。通过XML文档和DTD文档的比较来判断XML是否符合规范。(现在我很少见&#xff0c;不知道是不是淘汰了) 举个例子&…

github中的watch、star、fork的作用

在每个 github 项目的右上角&#xff0c;都有三个按钮,分别是 watch、star、fork&#xff0c;但是有些刚开始使用 github 的同学&#xff0c;可能对这三个按钮的使用却不怎么了解&#xff0c;包括一开始使用 github 的我也是如此&#xff0c;这篇博客&#xff0c;结合自己的理解…

spring 源码-context

1 spring-context 模块概要 该模块主要实现在spring-beans 模块的扩展&#xff0c;主要对aop支持及el表达式的实现 分析示例 public static void main(String[] args){ClassPathXmlApplicationContext context new ClassPathXmlApplicationContext("spring-aop.xml"…

标示符和关键字的总结--希望别再犯错

&#xff08;一&#xff09;Java关键字的表 一共50个关键字&#xff0c;如下表 其中绝大部分关键词是Java语法发布之初就约定好的&#xff0c;少部分关键词是随Java语言发展后加入的。 strictfp JDK1.2 加入 assert JDK1.4 加入 enum JDK5.0 加入 还有少数单词&#xff0c;目前…

历届试题 打印十字图

问题描述 小明为某机构设计了一个十字型的徽标&#xff08;并非红十字会啊&#xff09;&#xff0c;如下所示&#xff1a; ..$$$$$$$$$$$$$....$...........$..$$$.$$$$$$$$$.$$$$...$.......$...$$.$$$.$$$$$.$$$.$$.$...$...$...$.$$.$.$$$.$.$$$.$.$$.$.$...$...$.$.$$.$.$.…

Spring BeanDefinition

BeanDefinition&#xff0c;顾名思义&#xff0c;是一个对象(Bean)在Spring中描述&#xff0c;其核心类图&#xff1a; 从类图我们详细了解BeanDefinition。 BeanDefinition接口继承自BeanMetadataElement和AttributeAccessor两个接口。 BeanMetadataElement&#xff1a;bean…

乐尚网络:小程序商城零售行业10大新赋能

微信小程序上线以来&#xff0c;各行各业积极入场小程序&#xff0c;着手打造属于自己的小程序生态。小程序形态多样&#xff0c;适合你的小程序才是最好的&#xff1b;在众多形态中&#xff0c;小程序商城可以说是零售行业的主体形态了&#xff0c;因为通过平台直接实现交易是…

深度学习中的正则化

正则化方法有如下几种&#xff1a; 一、参数范数惩罚 其中L2、L1参数正则化介绍与关系如下 1、L2 参数正则化 直观解释如下&#xff1a; 2、L1 参数正则化 二、获取更多数据&#xff08;扩样本&#xff09; 避免过拟合的基本方法之一是从数据源获得更多数据&#xff0c;当训练数…