java复制代码static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;计算得到哈希值
    final K key;
    V value;
    Node<K,V> next;
}

interface Entry<K, V> {
        K getKey();
        V getValue();
        V setValue(V value);

java复制代码public HashMap(int initialCapacity, float loadFactor) {
    //校验 小于0报错
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    //capacity大于最大值取最大值
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    //负载因子不能小于等于0
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    //tableSizeFor方法
    this.threshold = tableSizeFor(initialCapacity);
}

---------------------------------------------------------
//传入一个初始容量，默认负载因子0.75
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
---------------------------------------------------------
//无参数，负载因子默认0.75
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
---------------------------------------------------------
//传入一个map的对象
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}

java复制代码public V put(K key, V value) {
   //返回putVal方法，给key进行了一次rehash
   return putVal(hash(key), key, value, false, true);
}
----------------------------------------------------------
static final int hash(Object key) {
   //让key对应的hash值的高16位也参与运算
  int h;
  return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
----------------------------------------------------------
final V putVal(int hash, K key, V value, boolean  onlyIfAbsent,boolean evict) 
{
   //tab：引用当前HashMap的散列表
   //p：表示当前散列表的元素
   //n：表示散列表数组的长度
   //i：表示路由寻址的结果
   Node<K,V>[] tab; Node<K,V> p; int n, i;
----------------------------------------------------------   	//延迟初始化逻辑，当第一次调用putVal的时候，才去初始化HashMap对象的散列表大小
   if ((tab = table) == null || (n = tab.length) == 0)
       n = (tab = resize()).length;
----------------------------------------------------------
   //寻找找到桶位，且刚好为null，则把k-v封装成node对象放进去
   if ((p = tab[i = (n - 1) & hash]) == null)
       tab[i] = newNode(hash, key, value, null);
----------------------------------------------------------
   else {
     //e：不为null时，找到一个与当前要插入的key-val一致的key对象
     //k：临时的一个key
       Node<K,V> e; K k;
       //表示桶位中的该元素，与你当前插入的元素key一致，后续会有替换操作
       if (p.hash == hash &&
           ((k = p.key) == key || (key != null && key.equals(k))))
           e = p;
----------------------------------------------------------
       //树化
       else if (p instanceof TreeNode)
           e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
---------------------------------------------------------- 
       else {
           //链表的情况，而且链表的头元素与我们要插入的key不一致
           for (int binCount = 0; ; ++binCount) {
               
               //条件成立，即说明迭代到最后一个链表了，也没找到与你要插入的key一致的node对象
               //说明要加入到链表的最后
               if ((e = p.next) == null) {
                   p.next = newNode(hash, key, value, null);
                   //说明当前链表长度达到树化标准
                   if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                       treeifyBin(tab, hash);
                   break;
               }
               //说明找到的元素key一样，进行替换，break跳出循环即可
               if (e.hash == hash &&
                   ((k = e.key) == key || (key != null && key.equals(k))))
                   break;
               p = e;
           }
       }
----------------------------------------------------------
   //e不等于null，说明找到了一个与你插入元素完全一致的，进行替换 
   if (e != null) { // existing mapping for key
           V oldValue = e.value;
           if (!onlyIfAbsent || oldValue == null)
               e.value = value;
           afterNodeAccess(e);
           return oldValue;
       }
   }
----------------------------------------------------------
   //modCount：表示散列表结构被修改次数，替换元素不算次数
   ++modCount;
   //插入新元素，size自增，如果自增大于扩容阈值，则触发扩容
   if (++size > threshold)
       resize();
   afterNodeInsertion(evict);
   return null;
}

java复制代码//为了解决哈希冲突，影响哈希效率，所以会有扩容机制
----------------------------------------------------------
final Node<K,V>[] resize() {
    //oldTab：引用扩容前的哈希表
    //oldCap：表示扩容前table的数组长度
    //oldThr：表示扩容之前阈值
    //newCap，newThr：扩容后的数组长度大小，以及扩容后下次的阈值
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
----------------------------------------------------------
    //条件成立，说明hashmap散列表已经初始化过了，这是一次正常扩容
    if (oldCap > 0) {
        //扩容之前的table数组大小，已经达到了最大阈值后，则不扩容
        //且设置扩容条件为int最大值
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
----------------------------------------------------------
    //oldCAP左移一位，实现数值翻倍，且赋值给newcap，newcap小于数值最大值限制 且扩容之前阈值>=16
    //这种情况下，则下一次扩容阈值等于当前阈值翻倍
    else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
----------------------------------------------------------    //oldCap == 0，说明hashmap散列表为null
   //1.new HashMap(inttCap，loadFactor);
   //2.new HashMap(inttCap);
   //3.new HashMap(map); map有数据
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;//一定是2的次方数
----------------------------------------------------------
    //oldCap==0，oldThr==0
    //new HashMap();
    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;
    //说明，hashmap本次扩容之前，table不为null
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;//当前node节点
            //说明当前桶位中有数据，但是具体是链表还是红黑树，还是单个数据，不确定
            if ((e = oldTab[j]) != null) {
                //方便jvm GC时回收
                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 {
                        next = e.next;
                        //hash--……1 1111
                        //hash--……0 1111
                        //0b 10000
                        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;
}

java复制代码public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(key)) == null ? null : e.value;
}
----------------------------------------------------------
final Node<K,V> getNode(Object key) {
    Node<K,V>[] tab; //tab：引用当前hashmap的散列表
    Node<K,V> first, e;//first：桶位中的头元素，e：临时node元素
    int n, hash; //n：table数组长度
    K k;
 ---------------------------------------------------------
     if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & (hash = hash(key))]) != null) {
         //定位出来的桶位元素，就是我们要get的元素
        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)
                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);
        }
    }
    return null;
}

java复制代码public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}
----------------------------------------------------------
final Node<K,V> removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable) {
    //tab：引用当前HashMap的散列表
    //p：表示当前散列表的元素
    //n：表示散列表数组的长度
    //index：表示路由寻址的结果
        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) {
  //说明路由的桶位是有数据的，需要进行查找操作，且删除  
----------------------------------------------------------   //node:查找到的结果， e：当前node的下一个元素
            Node<K,V> node = null, e; K k; V v;
            //当前桶位中的元素即为要删除的元素
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                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 = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
----------------------------------------------------------    //判断node不为空的情况，说明按照key找到了要删除的数据        
            if (node != null && (!matchValue || (v = node.value) == value ||(value != null&&value.equals(v)))) {
            //结果是红黑树
            if (node instanceof TreeNode)               ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            //结果为单个元素    
            else if (node == p)
               tab[index] = node.next;
           //结果为链表     
            else
               p.next = node.next;
                ++modCount;//修改次数自增
                --size;//长度减少
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

java复制代码@Override
public boolean replace(K key, V oldValue, V newValue) {
    Node<K,V> e; V v;
    if ((e = getNode(key)) != null &&
        ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
        e.value = newValue;
        afterNodeAccess(e);
        return true;
    }
    return false;
}
----------------------------------------------------------
@Override
public V replace(K key, V value) {
    Node<K,V> e;
    if ((e = getNode(key)) != null) {
        V oldValue = e.value;
        e.value = value;
        afterNodeAccess(e);
        return oldValue;
    }
    return null;
}
ll && v.equals(oldValue)))) {
        e.value = newValue;
        afterNodeAccess(e);
        return true;
    }
    return false;
}
----------------------------------------------------------
@Override
public V replace(K key, V value) {
    Node<K,V> e;
    if ((e = getNode(key)) != null) {
        V oldValue = e.value;
        e.value = value;
        afterNodeAccess(e);
        return oldValue;
    }
    return null;
}

less复制代码@Bean
public Docket docket() {
    return new Docket(DocumentationType.OAS_30)
            .globalRequestParameters(Lists.newArrayList(
                    new RequestParameterBuilder()
                            .name("debug")
                            .description("ignore authorization")
                            .in(ParameterType.HEADER)
                            // 类内部创建了默认的builder以供属性设置
                            .query(parameterSpecificationBuilder -> parameterSpecificationBuilder.defaultValue("1")
                                    .allowEmptyValue(true))
                            .build(),
                    new RequestParameterBuilder()
                            .name("Authorization")
                            .description("token")
                            .query(parameterSpecificationBuilder -> parameterSpecificationBuilder.defaultValue("1")
                                    .allowEmptyValue(true))
                            .in(ParameterType.HEADER)
                            .build()
            ))
            .select()
            .paths(PathSelectors.regex("^(?!/error).*"))
            .build();
}

typescript复制代码public class RequestParameterBuilder {
  ......
  SimpleParameterSpecificationBuilder simpleParameterBuilder;
  
  ...... 
  
  private SimpleParameterSpecificationBuilder queryBuilder() {
    if (simpleParameterBuilder == null) {
      simpleParameterBuilder = new SimpleParameterSpecificationBuilder();
    }
    return simpleParameterBuilder;
  }
  
  public RequestParameterBuilder query(@NonNull Consumer<SimpleParameterSpecificationBuilder> parameter) {
    parameter.accept(queryBuilder());
    return this;
  }
  
  ......

less复制代码@Bean
public Docket docket() {
    return new Docket(DocumentationType.OAS_30)
            .securityContexts(Arrays.asList(SecurityContext.builder()
                    .securityReferences(Arrays.asList(SecurityReference.builder()
                            .reference("Authorization")
                            .scopes(new AuthorizationScope[]{new AuthorizationScope("global", "accessEverything")})
                            .build()))
                    .build()))
            .securitySchemes(Arrays.asList(new ApiKey("Authorization", "Authorization", "header")))
            .select()
            .paths(PathSelectors.regex("^(?!/error).*"))
            .build();
}

typescript复制代码@Service
public class LoginService {

    @Autowired
    Set<Login> loginSet;//使用了Set 

    Map<Integer,Login> loginMap;

    public User login(User userLogin) {
        Login login=loginMap.get(userLogin.getChannelNo());
        return login.login(userLogin);
    }

    @PostConstruct
    public void init() {
        loginMap = new HashMap<>();
        for (Login login : loginSet) {
            loginMap.put(login.channel(), login);
        }

    }
}

scss复制代码@Component
public interface Login {
    User login(User userLogin);
    Integer channel();
}

typescript复制代码@Component
public class PasswordLogin implements Login {
    @Autowired
    LoginDao loginDao;

    @Override
    public User login(User userLogin) {

        return loginDao.PasswordLogin(userLogin.getUsername(),userLogin.getPassword());
    }

    @Override
    public Integer channel() {
        return 2;
    }
}

typescript复制代码
@Component
public class EmailLogin implements Login {
    @Autowired
    LoginDao loginDao;

    @Override
    public User login(User userLogin) {
        return loginDao.EmailLogin(userLogin.getEmail(),userLogin.getPassword());
    }

    @Override
    public Integer channel() {
        return 3;
    }
}

typescript复制代码@Component
public class PhoneLogin implements Login {
    @Autowired
    LoginDao loginDao;

    @Override
    public User login(User userLogin) {
        return loginDao.PhoneLogin(userLogin.getPhone(),userLogin.getPassword());
    }

    @Override
    public Integer channel() {
        return 1;
    }
}

Java复制代码@Mapper
@Repository
public interface LoginDao {

    @Select("select * from user where phone=#{phone} and password=#{password}")
    User PhoneLogin(String phone,String password);

    @Select("select * from user where username=#{username} and password=#{password}")
    User PasswordLogin(String username,String password);

    @Select("select * from user where email=#{email} and password=#{password}")
    User EmailLogin(String email,String password);

}

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

html复制代码<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8" />
    <title>文件上传页面</title>
</head>
<body>
<h1>文件上传页面</h1>
<form method="post" action="/upload" enctype="multipart/form-data">
    选择要上传的文件：<input type="file" name="file"><br>
    <hr>
    <input type="submit" value="提交">
</form>
</body>
</html>

java复制代码@Controller
@Slf4j
public class UploadController {

    @Value("${file.upload.path}")
    private String path;

    @GetMapping("/")
    public String uploadPage() {
        return "upload";
    }

    @PostMapping("/upload")
    @ResponseBody
    public String create(@RequestPart MultipartFile file) throws IOException {
        String fileName = file.getOriginalFilename();
        String filePath = path + fileName;

        File dest = new File(filePath);
        Files.copy(file.getInputStream(), dest.toPath());
        return "Upload file success : " + dest.getAbsolutePath();
    }

}

properties复制代码spring.servlet.multipart.max-file-size=2MB
spring.servlet.multipart.max-request-size=2MB

file.upload.path=/Users/didi/

kotlin复制代码// flow{} 方法
public fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit): Flow<T> = SafeFlow(block)

// colletct 方法
public suspend inline fun <T> Flow<T>.collect(crossinline action: suspend (value: T) -> Unit): Unit =
    collect(object : FlowCollector<T> {
        override suspend fun emit(value: T) = action(value)
    })

kotlin复制代码public fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit): Flow<T> = SafeFlow(block)

// Named anonymous object
private class SafeFlow<T>(private val block: suspend FlowCollector<T>.() -> Unit) : AbstractFlow<T>() {
    override suspend fun collectSafely(collector: FlowCollector<T>) {
        collector.block()
    }
}

kotlin复制代码public interface Flow<out T> {
    @InternalCoroutinesApi
    public suspend fun collect(collector: FlowCollector<T>)
}

public interface FlowCollector<in T> {
    /**
     * Collects the value emitted by the upstream.
     * This method is not thread-safe and should not be invoked concurrently.
     */
    public suspend fun emit(value: T)
}

kotlin复制代码public abstract class AbstractFlow<T> : Flow<T> {

    @InternalCoroutinesApi
    public final override suspend fun collect(collector: FlowCollector<T>) {
  		// 1. collector 做一层包装
        val safeCollector = SafeCollector(collector, coroutineContext)
        try {
  			// 2. 处理数据接收者
            collectSafely(safeCollector)
        } finally {
          	// 3. 释放协程相关的参数
            safeCollector.releaseIntercepted()
        }
    }

    // collectSafely 方法应当遵循以下的约束
    // 1. 不应当在collectSafely方法里面切换线程，比如 withContext(Dispatchers.IO)
    // 2. collectSafely 默认不是线程安全的
    public abstract suspend fun collectSafely(collector: FlowCollector<T>)
}

private class SafeFlow<T>(private val block: suspend FlowCollector<T>.() -> Unit) : AbstractFlow<T>() {
    override suspend fun collectSafely(collector: FlowCollector<T>) {
        collector.block()
    }
}

kotlin复制代码/*
 * Implementor of ContinuationImpl (that will be preserved as ABI nearly forever)
 * in order to properly control 'intercepted()' lifecycle.
 */
internal actual class SafeCollector<T> actual constructor(
    @JvmField internal actual val collector: FlowCollector<T>,
    @JvmField internal actual val collectContext: CoroutineContext
) : FlowCollector<T>, ContinuationImpl(NoOpContinuation, EmptyCoroutineContext) {
	// ... 省略
}

private object NoOpContinuation : Continuation<Any?> {
    override val context: CoroutineContext = EmptyCoroutineContext

    override fun resumeWith(result: Result<Any?>) {
        // Nothing
    }
}

kotlin复制代码internal actual class SafeCollector<T> actual constructor(
    @JvmField internal actual val collector: FlowCollector<T>,
    @JvmField internal actual val collectContext: CoroutineContext
) : FlowCollector<T>, ContinuationImpl(NoOpContinuation, EmptyCoroutineContext) {

    @JvmField // Note, it is non-capturing lambda, so no extra allocation during init of SafeCollector
    internal actual val collectContextSize = collectContext.fold(0) { count, _ -> count + 1 }
    private var lastEmissionContext: CoroutineContext? = null
    private var completion: Continuation<Unit>? = null

    // ContinuationImpl
    override val context: CoroutineContext
        get() = completion?.context ?: EmptyCoroutineContext

  	
    override fun invokeSuspend(result: Result<Any?>): Any? {
      	//  当result失败的时候，lastEmissionContext等于错误处理的类
        result.onFailure { lastEmissionContext = DownstreamExceptionElement(it) }
        completion?.resumeWith(result as Result<Unit>)
        return COROUTINE_SUSPENDED
    }

    override suspend fun emit(value: T) {
      	// suspendCoroutineUninterceptedOrReturn 保证只会被调用一次
        return suspendCoroutineUninterceptedOrReturn sc@{ uCont ->
            try {
                emit(uCont, value)
            } catch (e: Throwable) {
                // Save the fact that exception from emit (or even check context) has been thrown
                lastEmissionContext = DownstreamExceptionElement(e)
                throw e
            }
        }
    }

    private fun emit(uCont: Continuation<Unit>, value: T): Any? {
        val currentContext = uCont.context
      	// 1. 保证当前currentContext有效
        currentContext.ensureActive()
    	// 2. 检查 currentContext
        val previousContext = lastEmissionContext
        if (previousContext !== currentContext) {
            checkContext(currentContext, previousContext, value)
        }
        completion = uCont
        return emitFun(collector as FlowCollector<Any?>, value, this as Continuation<Unit>)
    }

    private fun checkContext(
        currentContext: CoroutineContext,
        previousContext: CoroutineContext?,
        value: T
    ) {
        if (previousContext is DownstreamExceptionElement) {
          	// 错误处理
            exceptionTransparencyViolated(previousContext, value)
        }
        checkContext(currentContext)
        lastEmissionContext = currentContext
    }

    // ... 省略
}

internal class DownstreamExceptionElement(@JvmField val e: Throwable) : CoroutineContext.Element {
    companion object Key : CoroutineContext.Key<DownstreamExceptionElement>

    override val key: CoroutineContext.Key<*> = Key
}

kotlin复制代码public suspend inline fun <T> Flow<T>.collect(crossinline action: suspend (value: T) -> Unit): Unit =
    collect(object : FlowCollector<T> {
        override suspend fun emit(value: T) = action(value)
    })

kotlin复制代码public fun <T> Flow<T>.flowOn(context: CoroutineContext): Flow<T> {
    checkFlowContext(context)
    return when {
        context == EmptyCoroutineContext -> this
        this is FusibleFlow -> fuse(context = context)
        else -> ChannelFlowOperatorImpl(this, context = context)
    }
}

kotlin复制代码internal class ChannelFlowOperatorImpl<T>(
    flow: Flow<T>,
    context: CoroutineContext = EmptyCoroutineContext,
    capacity: Int = Channel.OPTIONAL_CHANNEL
) : ChannelFlowOperator<T, T>(flow, context, capacity) {
    override fun create(context: CoroutineContext, capacity: Int): ChannelFlow<T> =
        ChannelFlowOperatorImpl(flow, context, capacity)

    override suspend fun flowCollect(collector: FlowCollector<T>) =
        flow.collect(collector)
}

kotlin复制代码internal abstract class ChannelFlowOperator<S, T>(
    @JvmField val flow: Flow<S>,
    context: CoroutineContext,
    capacity: Int
) : ChannelFlow<T>(context, capacity) {
    protected abstract suspend fun flowCollect(collector: FlowCollector<T>)

    // Changes collecting context upstream to the specified newContext, while collecting in the original context
    private suspend fun collectWithContextUndispatched(collector: FlowCollector<T>, newContext: CoroutineContext) {
        val originalContextCollector = collector.withUndispatchedContextCollector(coroutineContext)
        // invoke flowCollect(originalContextCollector) in the newContext
        return withContextUndispatched(newContext, block = { flowCollect(it) }, value = originalContextCollector)
    }

    // Slow path when output channel is required
    protected override suspend fun collectTo(scope: ProducerScope<T>) =
        flowCollect(SendingCollector(scope))

    // Optimizations for fast-path when channel creation is optional
    override suspend fun collect(collector: FlowCollector<T>) {
        // Fast-path: When channel creation is optional (flowOn/flowWith operators without buffer)
        if (capacity == Channel.OPTIONAL_CHANNEL) {
            val collectContext = coroutineContext
            val newContext = collectContext + context // compute resulting collect context
            // #1: If the resulting context happens to be the same as it was -- fallback to plain collect
            if (newContext == collectContext)
                return flowCollect(collector)
            // #2: If we don't need to change the dispatcher we can go without channels
            if (newContext[ContinuationInterceptor] == collectContext[ContinuationInterceptor])
                return collectWithContextUndispatched(collector, newContext)
        }
        // Slow-path: create the actual channel
        super.collect(collector)
    }
}

kotlin复制代码public abstract class ChannelFlow<T>(
    // upstream context
    @JvmField public val context: CoroutineContext,
    // buffer capacity between upstream and downstream context
    @JvmField public val capacity: Int
) : FusibleFlow<T> {
   // ...
    public override fun fuse(context: CoroutineContext, capacity: Int): FusibleFlow<T> {
        // ... 省略
    }

    public open fun produceImpl(scope: CoroutineScope): ReceiveChannel<T> =
        scope.produce(context, produceCapacity, start = CoroutineStart.ATOMIC, block = collectToFun)

    override suspend fun collect(collector: FlowCollector<T>): Unit =
        coroutineScope {
            collector.emitAll(produceImpl(this))
        }

    // ...
}

kotlin复制代码public suspend fun <T> FlowCollector<T>.emitAll(channel: ReceiveChannel<T>): Unit =
    emitAllImpl(channel, consume = true)

private suspend fun <T> FlowCollector<T>.emitAllImpl(channel: ReceiveChannel<T>, consume: Boolean) {
    try {
        while (true) {
            val result = run { channel.receiveOrClosed() }
            if (result.isClosed) {
                result.closeCause?.let { throw it }
                break // returns normally when result.closeCause == null
            }
            emit(result.value)
        }
    } catch (e: Throwable) {
        cause = e
        throw e
    } finally {
        if (consume) channel.cancelConsumed(cause)
    }
}

kotlin复制代码public fun <E> CoroutineScope.produce(
    context: CoroutineContext = EmptyCoroutineContext,
    capacity: Int = 0,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    onCompletion: CompletionHandler? = null,
    @BuilderInference block: suspend ProducerScope<E>.() -> Unit
): ReceiveChannel<E> {
    val channel = Channel<E>(capacity)
    val newContext = newCoroutineContext(context)
    val coroutine = ProducerCoroutine(newContext, channel)
    if (onCompletion != null) coroutine.invokeOnCompletion(handler = onCompletion)
    coroutine.start(start, coroutine, block)
    return coroutine
}

kotlin复制代码public abstract class ChannelFlow<T>(
    // upstream context
    @JvmField public val context: CoroutineContext,
    // buffer capacity between upstream and downstream context
    @JvmField public val capacity: Int
) : FusibleFlow<T> {

    // shared code to create a suspend lambda from collectTo function in one place
    internal val collectToFun: suspend (ProducerScope<T>) -> Unit
        get() = { collectTo(it) }

    // ...

    protected abstract suspend fun collectTo(scope: ProducerScope<T>)

    public open fun produceImpl(scope: CoroutineScope): ReceiveChannel<T> =
        scope.produce(context, produceCapacity, start = CoroutineStart.ATOMIC, block = collectToFun)

    override suspend fun collect(collector: FlowCollector<T>): Unit =
        coroutineScope {
            collector.emitAll(produceImpl(this))
        }
}

internal abstract class ChannelFlowOperator<S, T>(
    @JvmField val flow: Flow<S>,
    context: CoroutineContext,
    capacity: Int
) : ChannelFlow<T>(context, capacity) {
    protected abstract suspend fun flowCollect(collector: FlowCollector<T>)

    // Slow path when output channel is required
    protected override suspend fun collectTo(scope: ProducerScope<T>) =
        flowCollect(SendingCollector(scope))

    // ...
}

internal class ChannelFlowOperatorImpl<T>(
    flow: Flow<T>,
    context: CoroutineContext = EmptyCoroutineContext,
    capacity: Int = Channel.OPTIONAL_CHANNEL
) : ChannelFlowOperator<T, T>(flow, context, capacity) {
    //...
    override suspend fun flowCollect(collector: FlowCollector<T>) =
        flow.collect(collector)
}

public class SendingCollector<T>(
    private val channel: SendChannel<T>
) : FlowCollector<T> {
    override suspend fun emit(value: T): Unit = channel.send(value)
}

kotlin复制代码public fun <T> Flow<T>.flowOn(context: CoroutineContext): Flow<T> {
    checkFlowContext(context)
    return when {
        context == EmptyCoroutineContext -> this
        this is FusibleFlow -> fuse(context = context)
        else -> ChannelFlowOperatorImpl(this, context = context)
    }
}

public abstract class ChannelFlow<T>(
    // upstream context
    @JvmField public val context: CoroutineContext,
    // buffer capacity between upstream and downstream context
    @JvmField public val capacity: Int
) : FusibleFlow<T> {
    //...
    public override fun fuse(context: CoroutineContext, capacity: Int): FusibleFlow<T> {
        // note: previous upstream context (specified before) takes precedence
        val newContext = context + this.context
        val newCapacity = when {
            this.capacity == Channel.OPTIONAL_CHANNEL -> capacity
            capacity == Channel.OPTIONAL_CHANNEL -> this.capacity
            this.capacity == Channel.BUFFERED -> capacity
            capacity == Channel.BUFFERED -> this.capacity
            this.capacity == Channel.CONFLATED -> Channel.CONFLATED
            capacity == Channel.CONFLATED -> Channel.CONFLATED
            else -> {
                // sanity checks
                assert { this.capacity >= 0 }
                assert { capacity >= 0 }
                // combine capacities clamping to UNLIMITED on overflow
                val sum = this.capacity + capacity
                if (sum >= 0) sum else Channel.UNLIMITED // unlimited on int overflow
            }
        }
        if (newContext == this.context && newCapacity == this.capacity) return this
        return create(newContext, newCapacity)
    }

    //...
}

kotlin复制代码val newContext = context + this.context

java复制代码public class Test {

    static class Order {
    
        private Long orderId;

        public Order(Long orderId) {
            this.orderId = orderId;
        }

        public Long getOrderId() {
            return orderId;
        }

        public void setOrderId(Long orderId) {
            this.orderId = orderId;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj != null && !(obj instanceof Order)) {
                return false;
            }

            return Objects.equals(this.orderId, ((Order) obj).orderId);
        }

        @Override
        public String toString() {
            return "Order{" +
                    "orderId=" + orderId +
                    '}';
        }
    }

    public static void main(String[] args) {
        Map<Order, String> map = new HashMap<>();

        Order order1 = new Order(1000000001L);
        Order order2 = new Order(1000000001L);

        map.put(order1, "");
        map.put(order2, "");

        System.out.println(map);
    }
}

java复制代码public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
     int h;
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 通过hash算出索引  通过索引取值==null的话  直接直接插入到索引位置。
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)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);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = 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;
}

java复制代码public class TestHash {

    static class Order {


        private Long orderId;

        public Order(Long orderId) {
            this.orderId = orderId;
        }

        public Long getOrderId() {
            return orderId;
        }

        public void setOrderId(Long orderId) {
            this.orderId = orderId;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj != null && !(obj instanceof Order)) {
                return false;
            }

            return Objects.equals(this.orderId, ((Order) obj).orderId);
        }

        @Override
        public int hashCode() {
        	// 这里简单重写下   实际开发根据自己需求重写即可。
            return this.orderId.intValue() >> 2;
        }

        @Override
        public String toString() {
            return "Order{" +
                    "orderId=" + orderId +
                    '}';
        }
    }

    public static void main(String[] args) {
        Map<Order, String> map = new HashMap<>();

        Order order1 = new Order(1000000001L);
        Order order2 = new Order(1000000001L);

        map.put(order1, "");
        map.put(order2, "");

        System.out.println(map);
    }
}

java复制代码final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 重写hashCode之后两个对象的orderId相同，hashCode也肯定相同。
    // 通过hash算出索引  通过索引取值  有值不进入if。
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 由于重写了hashCode  旧对象的hashCode和新的肯定相等
        if (p.hash == hash &&
        // (k = p.key) == key == false 因为比较的是对象地址
        // (key != null && key.equals(k)) == true 因为重写了equals orderId相等则相等 
            ((k = p.key) == key || (key != null && key.equals(k))))
            // 保存旧Node
            e = p;
        .......
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
            	// value覆盖旧Node的值
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
   ........
}

java复制代码public class Test {

    static class Coordinate {
        public Coordinate(int x, int y) {
            this.x = x;
            this.y = y;
        }

        private int x;
        private int y;

        public int getX() {
            return x;
        }

        public void setX(int x) {
            this.x = x;
        }

        public int getY() {
            return y;
        }

        public void setY(int y) {
            this.y = y;
        }
    }

    public static void main(String[] args) {
        Map<Coordinate, String> map = new HashMap<>();
        map.put(new Coordinate(22, 99), "手机");
        map.put(new Coordinate(44, 48), "电脑");
    }
}