hma

wheeze是有声音的喘气动词或名词asthma是哮喘病名词。pant gasp wheeze是喘息的意思。puff asthma是喘息性哮喘的意思。

#include "stdafx.h"#include <iostream>#include <hash_map>#include <string>using namespace std;int _tmain(int argc, _TCHAR* argv[]){ stdext::hash_map<std::string, float> hm; hm.insert(std::make_pair<std::string, float>("A", 70.0)); hm.insert(std::make_pair<std::string, float>("C", 75.0)); hm.insert(std::make_pair<std::string, float>("B", 80.0)); stdext::hash_map<std::string, float>::iterator it; for(it = hm.begin(); it!= hm.end(); ++it) { cout <<it->first<<" "<<it->second << std::endl; } return 0;}

歌曲名:Skyline歌手:Richard Fleeshman专辑:NeonSkyline作词者名 YUI作曲者名 YUIアーティスト名 YUI for 雨音薫ちょっとだけ　考えすぎちゃうみたい 被一些事情困扰着眠れない部屋のなか 在房间中睡不著いっそもう　夜を飞びだしてみたい 我想黑夜飞快离开窓辺にためいきが落ちる 在窗台边叹着气ツキアカリヲヌケテ　远くまで 想飞向远方羽ばたいてみたいのにどうしたらいいのだろう? 但要怎样做才行?I want to fly well　I want to fly well飞び方を　知らないだけ… 但我不知道飞行的方法I want to fly well　I want to fly well谁か教えてくれたら　いいのに 有人可以教教我 就好了きっとまだ　知らないことばかりだよ 我什么都不知道TVも嘘ばかりで TV上所说的都是谎言アマヤドリノトチュウ　いつまでも 当外面下着雨时 我只憧向里走こうしてはいられない 不可以一直都这样了ずぶ濡れでも　かまわない 就算被雨水弄得湿透也没所谓I want to fly well　I want to fly well飞び方を　知るためには… 想知道怎样去飞I want to fly well　I want to fly well空に出なくちゃいけない　to skyline 要在天空中翱翔 to skylineチャンスを待ちきれない 不要再等待时机同じ朝を缲り返して 每个早晨都是一样的いくつ数えただろう　描いてゆく　skyline 已厌倦去计算 只管去描绘 skyline飞び方は　知らないよ　飞べるかもわからないよ 不知道飞行的方法 也不确定自己是否真的可以I want to fly well　I want to fly wellだけど　ゆくよ 但只要尝试便可I want to fly well　I want to fly well飞び方を　知るためには… 想知道怎样去飞I want to fly well　I want to fly well空に出なくちゃいけない　to skyline 要在天空中翱翔http://music.baidu.com/song/7543451

Pushmail[3]，邮件推送服务。PushMail业务指面向互联网个人邮箱和企业邮箱系统的邮件推送业务，即将新到达邮件服务器的邮件准时地推送到用户移动终端上的业务形式。客户可以在移动终端接收个人邮箱和企业邮箱的邮件，阅读、回复、转发和撰写电子邮件。 VGA(Video Graphics Array)是IBM在1987年随PS／2机一起推出的一种视频传输标准，具有分辨率高、显示速率快、颜色丰富等优点，在彩色显示器领域得到了广泛的应用。 HVGA (Half-size VGA) 即VGA(640*480)的一半,分辨率为(480*320),(3:2宽高比) QVGA即"Quarter VGA"。顾名思义即VGA的四分之一尺寸，亦即在液晶屏幕（LCD）上输出的分辨率是240×320像素。QVGA支持屏幕旋转，可以开发出相应的程序，以显示旋转90°、180°、270°屏幕位置。由HandEra公司发布。多用于手持/移动设备。

这是欧姆调零旋钮。指针式万用表电阻挡在使用前，需要首先进行欧姆调零，方法是端接两个表笔，然后调整这个旋钮，是表针正好指向0欧姆刻度线（注意0欧姆刻度线是在表盘的最右侧！这与其它档位不同）。一般来说，没换一次量程都要重新进行欧姆调零。数字式万用表没有这个旋钮。

他被称为建筑设计界的“鬼才” 设计作品遍布全球 他是迪拜帆船酒店的副总设计师 他就是： Martin Jochman 马丁·约克曼 世界顶级设计师，主创设计总监 英国布里斯托大学建筑学士，英国注册建筑师 英国皇家建筑师协会会员 超40年设计和建造经验 他带领的阿特金斯团队 即迪拜帆船酒店的原班人马 历经十年 在上海，打造了一座世界海拔最低的五星级酒店 上海深坑酒店 ↓↓↓ 它是一座废弃的采石矿坑 但即将成为充满想象的地下世界 史无前例的反向拓展 遭遇前所未有的运输难题 因为特殊的地理环境 深坑酒店项目自开工以来 便受到社会各界关注 并被美国国家地理频道 《世界伟大工程巡礼》连续跟踪报道 被誉为“世界建筑奇迹” 9月13日，2017《出色trends》杂志国际设计趋势论坛 暨年度出色设计师颁奖盛典 在上海吉盛伟邦国际 家具 村盛大举行 作为国际趋势设计论坛的嘉宾之一 Martin Jochman跟大家分享了一场 题为“Sensitive Design + Intimate Relationship Between Architecture and Interior”的演讲 国际趋势设计论坛 其他 三位嘉宾 也都是重量级的国际著名设计师 香港方振华设计公司 PFD＋品牌创办人方振华教授 他的演讲主题是 “To be or not to be ,it is a question” 他从自己最初的产品设计师经历说起谈 到人们对于设计趋势的理解 在他看来，流行趋势是一个非常有争议的话题 他认为只有为生活而设计 回归“设计解决问题”的本质 才能将设计之路走得更远 参与过四次东方卫视《梦想改造家》的 台湾建筑设计师史南桥先生 以其对小空间设计的精确把握 被誉为“空间魔术师” 他的演讲主题是“设计不是变魔术” 他认为，趋势藏在曾经发生的事件中 要善于总结从 中发现事物的发展规律 而参与《梦想改造家》的改造设计 也让他愈发感受到设计师的使命及社会责任 德稻社区规划及 环保 建筑大师 Francois Valentiny万伦柯先生 则以“新观点——我眼中的世界设计趋势”为题 给大家分享了他独到的设计观念 他认为，大部分的趋势更形同于工业化、可复制 像是商人们为了经济利益而制造出的刻意潮流 “趋势”多是现代意义上的词汇 但“历史”、“文化”也有其特殊的趣味和含义 环境也不局限于自然的风光 更有可能是历史的语境 文化的氛围这种抽象性的设计元素 之后，2017年度出色设计师颁奖盛典正式开始 创新设计类“年度出色设计师”获得者分别是 上海罗昂建筑设计咨询有限公司联合创始人 创意总监Frank Krueger和CEO王芳 上海大衡建筑设计有限公司建筑师、总经理陈威宪 以材料创新为设计特色的Neuni lab 创始人吴迪 以设计创新为特色的唯想国际创始人李想 创新设计类获奖人：王芳（右） 颁奖嘉宾：Francois Valentiny万伦柯先生（左） 创新设计类获奖人：陈威宪（右） 颁奖嘉宾：中国装饰协会副会长沈国臣先生（左） 创新设计类获奖人：吴迪（右） 颁奖嘉宾：程建新先生（左） 创新设计类获奖人：李想（右） 颁奖嘉宾：史南桥先生（左） 跨界设计类“年度出色设计师”获得者是 Dariel Studio&Massion Dada 创始人Thomas Dariel CROX阔合国际有限公司总监林琮然 跨界设计类获奖人：Thomas Dariel（右） 颁奖嘉宾：方振华先生（左） 跨界设计类获奖人：林琮然（林琮然先生因故缺席颁奖典礼，由其公司合伙人张铭政先生代领）（右） 颁奖嘉宾：吉盛伟邦国际家具村总经理吴玉奇先生（左） 商业设计与管理类的“年度出色设计师”获得者是 集艾室内设计（上海）有限公司总经理、设计总监黄全 J&S国际设计联合机构创始人CEO李婕 商业设计与管理类获奖人：黄全（右） 颁奖嘉宾：Martin Jochman马丁u2022约克曼先生（左） 商业设计与管理类获奖人：李婕（右） 颁奖嘉宾：Ronald Van Triest罗万全先生（左） 公益类的“年度出色设计师”获得者是 TAD大隐设计集团董事长谭精忠先生 以及心+学社 公益类获奖人：谭精忠（谭精忠先生因故缺席颁奖典礼，由上海大隐室内设计工程有限公司的设计总监黄雪清女士代领）（右） 颁奖嘉宾：张戍华先生（左） 公益类获奖人：心+学社会长杜柏均（右） 颁奖嘉宾：中国建筑装饰协会副秘书长、中国建筑装饰协会设计委秘书长刘原先生（左） 颁奖嘉宾与获得“年度出色设计师”奖项的设计师们合影留念 这个九月，让我们相约设计不散场 9月11日-10月8日 吉盛伟邦国际家具村正在举办精彩纷呈的艺术生活节 前卫的艺术设施 经典的话剧艺术表演 热力的啤酒电影节 眼花缭乱的文创集市和环球美食街 火爆的明星演唱会 这个九月，让艺术开启质感生活新篇章

他被称为建筑设计界的“鬼才” 设计作品遍布全球 他是迪拜帆船酒店的副总设计师 他就是： Martin Jochman 马丁·约克曼 世界顶级设计师，主创设计总监 英国布里斯托大学建筑学士，英国注册建筑师 英国皇家建筑师协会会员 超40年设计和建造经验 他带领的阿特金斯团队 即迪拜帆船酒店的原班人马 历经十年 在上海，打造了一座世界海拔最低的五星级酒店 上海深坑酒店 ↓↓↓ 它是一座废弃的采石矿坑 但即将成为充满想象的地下世界 史无前例的反向拓展 遭遇前所未有的运输难题 因为特殊的地理环境 深坑酒店项目自开工以来 便受到社会各界关注 并被美国国家地理频道 《世界伟大工程巡礼》连续跟踪报道 被誉为“世界建筑奇迹” 9月13日，2017《出色trends》杂志国际设计趋势论坛 暨年度出色设计师颁奖盛典 在上海吉盛伟邦国际 家具 村盛大举行 作为国际趋势设计论坛的嘉宾之一 Martin Jochman跟大家分享了一场 题为“Sensitive Design + Intimate Relationship Between Architecture and Interior”的演讲 国际趋势设计论坛 其他 三位嘉宾 也都是重量级的国际著名设计师 香港方振华设计公司 PFD＋品牌创办人方振华教授 他的演讲主题是 “To be or not to be ,it is a question” 他从自己最初的产品设计师经历说起谈 到人们对于设计趋势的理解 在他看来，流行趋势是一个非常有争议的话题 他认为只有为生活而设计 回归“设计解决问题”的本质 才能将设计之路走得更远 参与过四次东方卫视《梦想改造家》的 台湾建筑设计师史南桥先生 以其对小空间设计的精确把握 被誉为“空间魔术师” 他的演讲主题是“设计不是变魔术” 他认为，趋势藏在曾经发生的事件中 要善于总结从 中发现事物的发展规律 而参与《梦想改造家》的改造设计 也让他愈发感受到设计师的使命及社会责任 德稻社区规划及 环保 建筑大师 Francois Valentiny万伦柯先生 则以“新观点——我眼中的世界设计趋势”为题 给大家分享了他独到的设计观念 他认为，大部分的趋势更形同于工业化、可复制 像是商人们为了经济利益而制造出的刻意潮流 “趋势”多是现代意义上的词汇 但“历史”、“文化”也有其特殊的趣味和含义 环境也不局限于自然的风光 更有可能是历史的语境 文化的氛围这种抽象性的设计元素 之后，2017年度出色设计师颁奖盛典正式开始 创新设计类“年度出色设计师”获得者分别是 上海罗昂建筑设计咨询有限公司联合创始人 创意总监Frank Krueger和CEO王芳 上海大衡建筑设计有限公司建筑师、总经理陈威宪 以材料创新为设计特色的Neuni lab 创始人吴迪 以设计创新为特色的唯想国际创始人李想 创新设计类获奖人：王芳（右） 颁奖嘉宾：Francois Valentiny万伦柯先生（左） 创新设计类获奖人：陈威宪（右） 颁奖嘉宾：中国装饰协会副会长沈国臣先生（左） 创新设计类获奖人：吴迪（右） 颁奖嘉宾：程建新先生（左） 创新设计类获奖人：李想（右） 颁奖嘉宾：史南桥先生（左） 跨界设计类“年度出色设计师”获得者是 Dariel Studio&Massion Dada 创始人Thomas Dariel CROX阔合国际有限公司总监林琮然 跨界设计类获奖人：Thomas Dariel（右） 颁奖嘉宾：方振华先生（左） 跨界设计类获奖人：林琮然（林琮然先生因故缺席颁奖典礼，由其公司合伙人张铭政先生代领）（右） 颁奖嘉宾：吉盛伟邦国际家具村总经理吴玉奇先生（左） 商业设计与管理类的“年度出色设计师”获得者是 集艾室内设计（上海）有限公司总经理、设计总监黄全 J&S国际设计联合机构创始人CEO李婕 商业设计与管理类获奖人：黄全（右） 颁奖嘉宾：Martin Jochman马丁u2022约克曼先生（左） 商业设计与管理类获奖人：李婕（右） 颁奖嘉宾：Ronald Van Triest罗万全先生（左） 公益类的“年度出色设计师”获得者是 TAD大隐设计集团董事长谭精忠先生 以及心+学社 公益类获奖人：谭精忠（谭精忠先生因故缺席颁奖典礼，由上海大隐室内设计工程有限公司的设计总监黄雪清女士代领）（右） 颁奖嘉宾：张戍华先生（左） 公益类获奖人：心+学社会长杜柏均（右） 颁奖嘉宾：中国建筑装饰协会副秘书长、中国建筑装饰协会设计委秘书长刘原先生（左） 颁奖嘉宾与获得“年度出色设计师”奖项的设计师们合影留念 这个九月，让我们相约设计不散场 9月11日-10月8日 吉盛伟邦国际家具村正在举办精彩纷呈的艺术生活节 前卫的艺术设施 经典的话剧艺术表演 热力的啤酒电影节 眼花缭乱的文创集市和环球美食街 火爆的明星演唱会 这个九月，让艺术开启质感生活新篇章

// 1. 最小树形化容量阈值：即 当哈希表中的容量 > 该值时，才允许树形化链表 （即 将链表 转换成红黑树） // 否则，若桶内元素太多时，则直接扩容，而不是树形化 // 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD static final int MIN_TREEIFY_CAPACITY = 64; // 2. 桶的树化阈值：即 链表转成红黑树的阈值，在存储数据时，当链表长度 > 该值时，则将链表转换成红黑树 static final int TREEIFY_THRESHOLD = 8; // 3. 桶的链表还原阈值：即 红黑树转为链表的阈值，当在扩容（resize（））时（此时HashMap的数据存储位置会重新计算），在重新计算存储位置后，当原有的红黑树内数量 < 6时，则将 红黑树转换成链表 static final int UNTREEIFY_THRESHOLD = 6;

想象你有一个魔法箱子（HashMap），你可以把东西放进去，并且给每个东西贴上标签（键）以便稍后找到它们。箱子的内部是由一系列抽屉组成，每个抽屉都有一个唯一的标签（哈希码）。当你要放入一样东西时，首先你会生成一个标签（哈希码），这个标签会告诉你应该将东西放入哪个抽屉。假设你想放入一本书，并给它贴上标签 "科学书"，然后根据这个标签（哈希码），你找到对应的抽屉并把书放进去。现在，如果你想找回这本书，你只需要记得它的标签 "科学书"，然后根据这个标签（哈希码）再次找到对应的抽屉，从抽屉里拿出书来。这样你就能快速找到你之前放入箱子的东西。然而，有时候不同的东西可能会有相同的标签（哈希码），这就是所谓的哈希碰撞。在箱子内部，为了解决这个问题，每个抽屉都是一个链表，可以存放多个东西。当发生哈希碰撞时，新的东西会被添加到链表中，而不是新建一个抽屉。当箱子的负载（放入的东西数量）逐渐增加时，为了保持箱子的高效性能，箱子会自动增大，并重新调整抽屉的布局，确保箱子里的抽屉数量适合放入的东西的数量。这就是 Java 中 HashMap 的底层原理。它利用哈希函数将键映射到特定的索引位置，然后在该位置存储值。如果存在哈希碰撞，它会使用链表来处理冲突。当箱子内的东西越来越多时，箱子会自动调整大小，以保持高效性能。这种数据结构使得 HashMap 在大多数情况下能够快速查找和插入数据。

理论上绝对是可以的。不过要加上新的属性可能增加存储空间（如多维数组，或者像JAVA那样的类数组）。 就像树可以线索化（而且有多种线索化都是用链表实现的），也可以按层输出这个可以看成数组，但是为了进行确定可能需要额外的空间来实现你的结

jre编译成这样了

做java开发，用的最多的结合框架，就这么几个，关于别的集合框架，一是用的不多，二是，你要是真想学这些东西，你应该去学习下，数据结构，而不是去学java的API,你懂大概原理的时候，需要用的时候，你去找API就行了，空学API实际上用处不大

第一个是O(n)，因为是遍历整个集合 ，第二个是O(m*n)，看他们提供的源码实现就可知道，两重for循环

这样理解：因为数组是引用型，test3 = hash_arrayHashSets[0];test3已经指向hash_arrayHashSets[0]这个实体， test3.add("c")，会在hash_arrayHashSets[0]增加一个元素“C”，这样实体hash_arrayHashSets[0]已经改变了。

ArrayList和Vector都实现了List接口，我们可以分析其源代码，很容易找出它们的区别：Vector中的add方法如下：publicsynchronizedbooleanadd(Ee){}ArrayList中的add方法如下：publicbooleanadd(Ee)很显然区别就在于一个有synchronized即线程同步，而另一外没有，参考源代码你会发现绝大部分方法都是这样的。也就是说当存在多线程访问时，Vector比ArrayList要安全，但这种安全的代价就是要付出更多的系统性能一般情况下我们是使用ArrayList，因为存在多线程去访问同一个list对象的可能性并不是太多。对于HashMap和Hashtable原理是一样的，Hashtable实现了线程同步，能确保多线程访问时的安全性，性能要比hashMap低

1、HashMap线程不安全原因： 原因： JDK1.7 中，由于多线程对HashMap进行扩容，调用了HashMap#transfer ()，具体原因：某个线程执行过程中，被挂起，其他线程已经完成数据迁移，等CPU资源释放后被挂起的线程重新执行之前的逻辑，数据已经被改变，造成死循环、数据丢失。

1 HashMap和HashSet的区别是Java面试中最常被问到的问题。如果没有涉及到Collection框架以及多线程的面试，可以说是不完整。而Collection框架的问题不涉及到HashSet和HashMap，也可以说是不完整。HashMap和HashSet都是collection框架的一部分，它们让我们能够使用对象的集合。collection框架有自己的接口和实现，主要分为Set接口，List接口和Queue接口。它们有各自的特点，Set的集合里不允许对象有重复的值，List允许有重复，它对集合中的对象进行索引，Queue的工作原理是FCFS算法(First Come, First Serve)。23 首先让我们来看看什么是HashMap和HashSet，然后再来比较它们之间的分别。4 什么是HashSet56 HashSet实现了Set接口，它不允许集合中有重复的值，当我们提到HashSet时，第一件事情就是在将对象存储在HashSet之前，要先确保对象重写equals()和hashCode()方法，这样才能比较对象的值是否相等，以确保set中没有储存相等的对象。如果我们没有重写这两个方法，将会使用这个方法的默认实现。78 public boolean add(Object o)方法用来在Set中添加元素，当元素值重复时则会立即返回false，如果成功添加的话会返回true。9 什么是HashMap10 11 HashMap实现了Map接口，Map接口对键值对进行映射。Map中不允许重复的键。Map接口有两个基本的实现，HashMap和TreeMap。TreeMap保存了对象的排列次序，而HashMap则不能。HashMap允许键和值为null。HashMap是非synchronized的，但collection框架提供方法能保证HashMap synchronized，这样多个线程同时访问HashMap时，能保证只有一个线程更改Map。12 13 public Object put(Object Key,Object value)方法用来将元素添加到map中。14 15 你可以阅读这篇文章看看HashMap的工作原理，以及这篇文章看看HashMap和HashTable的区别。16 HashSet和HashMap的区别17 *HashMap* *HashSet*18 HashMap实现了Map接口 HashSet实现了Set接口19 HashMap储存键值对 HashSet仅仅存储对象20 使用put()方法将元素放入map中 使用add()方法将元素放入set中21 HashMap中使用键对象来计算hashcode值 HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false22 HashMap比较快，因为是使用唯一的键来获取对象 HashSet较HashMap来说比较慢

concurrenthashmap是弱一致的，iterator 都是弱一致性的，两者的迭代器的一致性不同的。当删除了第7个元素的时候，B会感知到已删除，所以B的后续迭代都是真实的数据。

一直以来只是知道HashMap是线程不安全的，但是到底HashMap为什么线程不安全，多线程并发的时候在什么情况下可能出现问题？HashMap底层是一个Entry数组，当发生hash冲突的时候，hashmap是采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。javadoc中关于hashmap的一段描述如下：此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下所示： Map m = Collections.synchronizedMap(new HashMap(...));1、[java] view plain copyvoid addEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<K,V>(hash, key, value, e); if (size++ >= threshold) resize(2 * table.length); } 在hashmap做put操作的时候会调用到以上的方法。现在假如A线程和B线程同时对同一个数组位置调用addEntry，两个线程会同时得到现在的头结点，然后A写入新的头结点之后，B也写入新的头结点，那B的写入操作就会覆盖A的写入操作造成A的写入操作丢失2、[java] view plain copyfinal Entry<K,V> removeEntryForKey(Object key) { int hash = (key == null) ? 0 : hash(key.hashCode()); 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; else prev.next = next; e.recordRemoval(this); return e; } prev = e; e = next; } return e; } 删除键值对的代码如上：当多个线程同时操作同一个数组位置的时候，也都会先取得现在状态下该位置存储的头结点，然后各自去进行计算操作，之后再把结果写会到该数组位置去，其实写回的时候可能其他的线程已经就把这个位置给修改过了，就会覆盖其他线程的修改3、addEntry中当加入新的键值对后键值对总数量超过门限值的时候会调用一个resize操作，代码如下：[java] view plain copyvoid resize(int newCapacity) { Entry[] oldTable = table; int oldCapacity = oldTable.length; if (oldCapacity == MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return; } Entry[] newTable = new Entry[newCapacity]; transfer(newTable); table = newTable; threshold = (int)(newCapacity * loadFactor); } 这个操作会新生成一个新的容量的数组，然后对原数组的所有键值对重新进行计算和写入新的数组，之后指向新生成的数组。当多个线程同时检测到总数量超过门限值的时候就会同时调用resize操作，各自生成新的数组并rehash后赋给该map底层的数组table，结果最终只有最后一个线程生成的新数组被赋给table变量，其他线程的均会丢失。而且当某些线程已经完成赋值而其他线程刚开始的时候，就会用已经被赋值的table作为原始数组，这样也会有问题。

concurrenthashmap是弱一致的，iterator都是弱一致性的，两者的迭代器的一致性不同的。当删除了第7个元素的时候，B会感知到已删除，所以B的后续迭代都是真实的数据。

该题可以在baidu ,有很多解答.我这需要说明下 这个是面试常 问的但hashtable 基本被淘汰了 ,可用concurrentMap 替代

大概是不同的object计算出的hascode不同

两者都是非线程安全，前者无排序，后者会自动排序

ConcurrentHashMap的弱一致性主要是为了提升效率，是一致性与效率之间的一种权衡。要成为强一致性，就得到处使用锁，甚至是全局锁，这就与Hashtable和同步的HashMap一样了。

HashMap的原理介绍x0dx0ax0dx0a此乃老生常谈，不作仔细解说。x0dx0a一句话概括之：HashMap是一个散列表，它存储的内容是键值对(key-value)映射。x0dx0ax0dx0aJava 7 中HashMap的源码分析x0dx0ax0dx0a首先是HashMap的构造函数代码块1中，根据初始化的Capacity与loadFactor（加载因子）初始化HashMap.x0dx0a//代码块1x0dx0a public HashMap(int initialCapacity, float loadFactor) {x0dx0a if (initialCapacity < 0)x0dx0a throw new IllegalArgumentException("Illegal initial capacity: " +x0dx0a initialCapacity);x0dx0a if (initialCapacity > MAXIMUM_CAPACITY)x0dx0a initialCapacity = MAXIMUM_CAPACITY;x0dx0a if (loadFactor <= 0 || Float.isNaN(loadFactor))x0dx0a throw new IllegalArgumentException("Illegal load factor: " +loadFactor);x0dx0ax0dx0a this.loadFactor = loadFactor;x0dx0a threshold = initialCapacity;x0dx0a init();x0dx0a }x0dx0ax0dx0aJava7中对于的put方法实现相对比较简单，首先根据 key1 的key值计算hash值，再根据该hash值与table的length确定该key所在的index,如果当前位置的Entry不为null，则在该Entry链中遍历，如果找到hash值和key值都相同，则将值value覆盖，返回oldValue；如果当前位置的Entry为null，则直接addEntry。x0dx0a代码块2x0dx0apublic V put(K key, V value) {x0dx0a if (table == EMPTY_TABLE) {x0dx0a inflateTable(threshold);x0dx0a }x0dx0a if (key == null)x0dx0a return putForNullKey(value);x0dx0a int hash = hash(key);x0dx0a int i = indexFor(hash, table.length);x0dx0a for (Entry e = table[i]; e != null; e = e.next) {x0dx0a Object k;x0dx0a if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {x0dx0a V oldValue = e.value;x0dx0a e.value = value;x0dx0a e.recordAccess(this);x0dx0a return oldValue;x0dx0a }x0dx0a }x0dx0ax0dx0a modCount++;x0dx0a addEntry(hash, key, value, i);x0dx0a return null;x0dx0a }x0dx0ax0dx0a//addEntry方法中会检查当前table是否需要resizex0dx0a void addEntry(int hash, K key, V value, int bucketIndex) {x0dx0a if ((size >= threshold) && (null != table[bucketIndex])) {x0dx0a resize(2 * table.length); //当前map中的size 如果大于threshole的阈值，则将resize将table的length扩大2倍。x0dx0a hash = (null != key) ? hash(key) : 0;x0dx0a bucketIndex = indexFor(hash, table.length);x0dx0a }x0dx0ax0dx0a createEntry(hash, key, value, bucketIndex);x0dx0a }x0dx0ax0dx0aJava7 中resize（）方法的实现比较简单，将OldTable的长度扩展，并且将oldTable中的Entry根据rehash的标记重新计算hash值和index移动到newTable中去。代码如代码块3中所示，x0dx0a//代码块3 --JDK7中HashMap.resize()方法x0dx0avoid resize(int newCapacity) {x0dx0a Entry[] oldTable = table;x0dx0a int oldCapacity = oldTable.length;x0dx0a if (oldCapacity == MAXIMUM_CAPACITY) {x0dx0a threshold = Integer.MAX_VALUE;x0dx0a return;x0dx0a }x0dx0ax0dx0a Entry[] newTable = new Entry[newCapacity];x0dx0a transfer(newTable, initHashSeedAsNeeded(newCapacity));x0dx0a table = newTable;x0dx0a threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);x0dx0a }x0dx0ax0dx0a /**x0dx0a * 将当前table的Entry转移到新的table中x0dx0a */x0dx0a void transfer(Entry[] newTable, boolean rehash) {x0dx0a int newCapacity = newTable.length;x0dx0a for (Entry e : table) {x0dx0a while(null != e) {x0dx0a Entry next = e.next;x0dx0a if (rehash) {x0dx0a e.hash = null == e.key ? 0 : hash(e.key);x0dx0a }x0dx0a int i = indexFor(e.hash, newCapacity);x0dx0a e.next = newTable[i];x0dx0a newTable[i] = e;x0dx0a e = next;x0dx0a }x0dx0a }x0dx0a }x0dx0ax0dx0aHashMap性能的有两个参数：初始容量(initialCapacity) 和加载因子(loadFactor)。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。x0dx0a根据源码分析可以看出：在Java7 中 HashMap的entry是按照index索引存储的，遇到hash冲突的时候采用拉链法解决冲突，将冲突的key和value插入到链表list中。x0dx0a然而这种解决方法会有一个缺点，假如key值都冲突，HashMap会退化成一个链表，get的复杂度会变成O(n)。x0dx0a在Java8中为了优化该最坏情况下的性能，采用了平衡树来存放这些hash冲突的键值对，性能由此可以提升至O(logn)。x0dx0a代码块4 -- JDK8中HashMap中常量定义x0dx0a static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; x0dx0a static final int TREEIFY_THRESHOLD = 8; // 是否将list转换成tree的阈值x0dx0a static final int UNTREEIFY_THRESHOLD = 6; // 在resize操作中，决定是否untreeify的阈值x0dx0a static final int MIN_TREEIFY_CAPACITY = 64; // 决定是否转换成tree的最小容量x0dx0a static final float DEFAULT_LOAD_FACTOR = 0.75f; // default的加载因子x0dx0ax0dx0a在Java 8 HashMap的put方法实现如代码块5所示，x0dx0a代码块5 --JDK8 HashMap.put方法x0dx0a public V put(K key, V value) {x0dx0a return putVal(hash(key), key, value, false, true);x0dx0a }x0dx0ax0dx0a final V putVal(int hash, K key, V value, boolean onlyIfAbsent,x0dx0a boolean evict) {x0dx0a Node[] tab; Node p; int n, i;x0dx0a if ((tab = table) == null || (n = tab.length) == 0)x0dx0a n = (tab = resize()).length; //table为空的时候，n为table的长度x0dx0a if ((p = tab[i = (n - 1) & hash]) == null)x0dx0a tab[i] = newNode(hash, key, value, null); // (n - 1) & hash 与Java7中indexFor方法的实现相同，若i位置上的值为空，则新建一个Node，table[i]指向该Node。x0dx0a else {x0dx0a // 若i位置上的值不为空，判断当前位置上的Node p 是否与要插入的key的hash和key相同x0dx0a Node e; K k;x0dx0a if (p.hash == hash &&x0dx0a ((k = p.key) == key || (key != null && key.equals(k))))x0dx0a e = p;//相同则覆盖之x0dx0a else if (p instanceof TreeNode)x0dx0a // 不同，且当前位置上的的node p已经是TreeNode的实例，则再该树上插入新的node。x0dx0a e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);x0dx0a else {x0dx0a // 在i位置上的链表中找到p.next为null的位置，binCount计算出当前链表的长度，如果继续将冲突的节点插入到该链表中，会使链表的长度大于tree化的阈值，则将链表转换成tree。x0dx0a for (int binCount = 0; ; ++binCount) {x0dx0a if ((e = p.next) == null) {x0dx0a p.next = newNode(hash, key, value, null);x0dx0a if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1stx0dx0a treeifyBin(tab, hash);x0dx0a break;x0dx0a }x0dx0a if (e.hash == hash &&x0dx0a ((k = e.key) == key || (key != null && key.equals(k))))x0dx0a break;x0dx0a p = e;x0dx0a }x0dx0a }x0dx0a if (e != null) { // existing mapping for keyx0dx0a V oldValue = e.value;x0dx0a if (!onlyIfAbsent || oldValue == null)x0dx0a e.value = value;x0dx0a afterNodeAccess(e);x0dx0a return oldValue;x0dx0a }x0dx0a }x0dx0a ++modCount;x0dx0a if (++size > threshold)x0dx0a resize();x0dx0a afterNodeInsertion(evict);x0dx0a return null;x0dx0a }x0dx0ax0dx0a再看下resize方法，由于需要考虑hash冲突解决时采用的可能是list 也可能是balance tree的方式，因此resize方法相比JDK7中复杂了一些,x0dx0a代码块6 -- JDK8的resize方法x0dx0a inal Node[] resize() {x0dx0a Node[] oldTab = table;x0dx0a int oldCap = (oldTab == null) ? 0 : oldTab.length;x0dx0a int oldThr = threshold;x0dx0a int newCap, newThr = 0;x0dx0a if (oldCap > 0) {x0dx0a if (oldCap >= MAXIMUM_CAPACITY) {x0dx0a threshold = Integer.MAX_VALUE;//如果超过最大容量，无法再扩充tablex0dx0a return oldTab;x0dx0a }x0dx0a else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&x0dx0a oldCap >= DEFAULT_INITIAL_CAPACITY)x0dx0a newThr = oldThr << 1; // threshold门槛扩大至2倍x0dx0a }x0dx0a else if (oldThr > 0) // initial capacity was placed in thresholdx0dx0a newCap = oldThr;x0dx0a else { // zero initial threshold signifies using defaultsx0dx0a newCap = DEFAULT_INITIAL_CAPACITY;x0dx0a newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);x0dx0a }x0dx0a if (newThr == 0) {x0dx0a float ft = (float)newCap * loadFactor;x0dx0a newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?x0dx0a (int)ft : Integer.MAX_VALUE);x0dx0a }x0dx0a threshold = newThr;x0dx0a @SuppressWarnings({"rawtypes","unchecked"})x0dx0a Node[] newTab = (Node[])new Node[newCap];// 创建容量为newCap的newTab，并将oldTab中的Node迁移过来，这里需要考虑链表和tree两种情况。

首页所有文章资讯Web架构基础技术书籍教程Java小组工具资源谈谈HashMap线程不安全的体现2016/10/18|分类：基础技术|6条评论|标签：HASHMAP,并发分享到：26原文出处：HoseeHashMap的原理以及如何实现，之前在JDK7与JDK8中HashMap的实现中已经说明了。那么，为什么说HashMap是线程不安全的呢？它在多线程环境下，会发生什么情况呢？1.resize死循环我们都知道HashMap初始容量大小为16,一般来说，当有数据要插入时，都会检查容量有没有超过设定的thredhold，如果超过，需要增大Hash表的尺寸，但是这样一来，整个Hash表里的元素都需要被重算一遍。这叫rehash，这个成本相当的大。voidresize(intnewCapacity){Entry[]oldTable=table;intoldCapacity=oldTable.length;if(oldCapacity==MAXIMUM_CAPACITY){threshold=Integer.MAX_VALUE;return;}Entry[]newTable=newEntry[newCapacity];transfer(newTable,initHashSeedAsNeeded(newCapacity));table=newTable;threshold=(int)Math.min(newCapacity*loadFactor,MAXIMUM_CAPACITY+1);}voidtransfer(Entry[]newTable,booleanrehash){intnewCapacity=newTable.length;for(Entrye:table){while(null!=e){Entrynext=e.next;if(rehash){e.hash=null==e.key?0:hash(e.key);}inti=indexFor(e.hash,newCapacity);e.next=newTable[i];newTable[i]=e;e=next;}}}大概看下transfer：对索引数组中的元素遍历对链表上的每一个节点遍历：用next取得要转移那个元素的下一个，将e转移到新Hash表的头部，使用头插法插入节点。循环2，直到链表节点全部转移循环1，直到所有索引数组全部转移经过这几步，我们会发现转移的时候是逆序的。假如转移前链表顺序是1->2->3，那么转移后就会变成3->2->1。这时候就有点头绪了，死锁问题不就是因为1->2的同时2->1造成的吗？所以，HashMap的死锁问题就出在这个transfer()函数上。

去看看这个帖子吧，或许对你有所帮助http://www.cnblogs.com/yxysuanfa/p/6932010.html

HashMap的原理介绍此乃老生常谈，不作仔细解说。一句话概括之：HashMap是一个散列表，它存储的内容是键值对(key-value)映射。Java 7 中HashMap的源码分析首先是HashMap的构造函数代码块1中，根据初始化的Capacity与loadFactor（加载因子）初始化HashMap.//代码块1 public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " +loadFactor); this.loadFactor = loadFactor; threshold = initialCapacity; init(); }Java7中对于<key1,value1>的put方法实现相对比较简单，首先根据 key1 的key值计算hash值，再根据该hash值与table的length确定该key所在的index,如果当前位置的Entry不为null，则在该Entry链中遍历，如果找到hash值和key值都相同，则将值value覆盖，返回oldValue；如果当前位置的Entry为null，则直接addEntry。代码块2public V put(K key, V value) { if (table == EMPTY_TABLE) { inflateTable(threshold); } if (key == null) return putForNullKey(value); int hash = hash(key); int i = indexFor(hash, table.length); 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++; addEntry(hash, key, value, i); return null; }//addEntry方法中会检查当前table是否需要resize void addEntry(int hash, K key, V value, int bucketIndex) { if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length); //当前map中的size 如果大于threshole的阈值，则将resize将table的length扩大2倍。 hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } createEntry(hash, key, value, bucketIndex); }Java7 中resize（）方法的实现比较简单，将OldTable的长度扩展，并且将oldTable中的Entry根据rehash的标记重新计算hash值和index移动到newTable中去。代码如代码块3中所示，//代码块3 --JDK7中HashMap.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]; transfer(newTable, initHashSeedAsNeeded(newCapacity)); table = newTable; threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); } /** * 将当前table的Entry转移到新的table中 */ void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; for (Entry<K,V> e : table) { while(null != e) { Entry<K,V> next = e.next; if (rehash) { e.hash = null == e.key ? 0 : hash(e.key); } int i = indexFor(e.hash, newCapacity); e.next = newTable[i]; newTable[i] = e; e = next; } } }HashMap性能的有两个参数：初始容量(initialCapacity) 和加载因子(loadFactor)。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。根据源码分析可以看出：在Java7 中 HashMap的entry是按照index索引存储的，遇到hash冲突的时候采用拉链法解决冲突，将冲突的key和value插入到链表list中。然而这种解决方法会有一个缺点，假如key值都冲突，HashMap会退化成一个链表，get的复杂度会变成O(n)。在Java8中为了优化该最坏情况下的性能，采用了平衡树来存放这些hash冲突的键值对，性能由此可以提升至O(logn)。代码块4 -- JDK8中HashMap中常量定义 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; static final int TREEIFY_THRESHOLD = 8; // 是否将list转换成tree的阈值 static final int UNTREEIFY_THRESHOLD = 6; // 在resize操作中，决定是否untreeify的阈值 static final int MIN_TREEIFY_CAPACITY = 64; // 决定是否转换成tree的最小容量 static final float DEFAULT_LOAD_FACTOR = 0.75f; // default的加载因子在Java 8 HashMap的put方法实现如代码块5所示，代码块5 --JDK8 HashMap.put方法 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } 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; //table为空的时候，n为table的长度 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); // (n - 1) & hash 与Java7中indexFor方法的实现相同，若i位置上的值为空，则新建一个Node，table[i]指向该Node。 else { // 若i位置上的值不为空，判断当前位置上的Node p 是否与要插入的key的hash和key相同 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) // 不同，且当前位置上的的node p已经是TreeNode的实例，则再该树上插入新的node。 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { // 在i位置上的链表中找到p.next为null的位置，binCount计算出当前链表的长度，如果继续将冲突的节点插入到该链表中，会使链表的长度大于tree化的阈值，则将链表转换成tree。 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; }再看下resize方法，由于需要考虑hash冲突解决时采用的可能是list 也可能是balance tree的方式，因此resize方法相比JDK7中复杂了一些,代码块6 -- JDK8的resize方法 inal 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) { threshold = Integer.MAX_VALUE;//如果超过最大容量，无法再扩充table return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // threshold门槛扩大至2倍 } 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; @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];// 创建容量为newCap的newTab，并将oldTab中的Node迁移过来，这里需要考虑链表和tree两种情况。

什么是HashSetHashSet实现了Set接口，它不允许集合中有重复的值，当我们提到HashSet时，第一件事情就是在将对象存储在HashSet之前，要先确保对象重写equals()和hashCode()方法，这样才能比较对象的值是否相等，以确保set中没有储存相等的对象。如果我们没有重写这两个方法，将会使用这个方法的默认实现。public boolean add(Object o)方法用来在Set中添加元素，当元素值重复时则会立即返回false，如果成功添加的话会返回true。什么是HashMapHashMap实现了Map接口，Map接口对键值对进行映射。Map中不允许重复的键。Map接口有两个基本的实现，HashMap和TreeMap。TreeMap保存了对象的排列次序，而HashMap则不能。HashMap允许键和值为null。HashMap是非synchronized的，但collection框架提供方法能保证HashMap synchronized，这样多个线程同时访问HashMap时，能保证只有一个线程更改Map。public Object put(Object Key,Object value)方法用来将元素添加到map中。你可以阅读这篇文章看看HashMap的工作原理，以及这篇文章看看HashMap和HashTable的区别。HashSet和HashMap的区别*HashMap* *HashSet* HashMap实现了Map接口 HashSet实现了Set接口 HashMap储存键值对 HashSet仅仅存储对象 使用put()方法将元素放入map中 使用add()方法将元素放入set中 HashMap中使用键对象来计算hashcode值 HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false HashMap比较快，因为是使用唯一的键来获取对象 HashSet较HashMap来说比较慢

一、继承父类不同Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类；但二者都实现了Map接口。二、线程的安全性1、HashTable是同步（方法中使用了Synchronize)的；而HashMap是未同步（方法中缺省Synchronize）的。2、Hashtable线程安全，因为它每个方法中都加入了Synchronize，在多线程并发的环境下，可以直接使用Hashtable，不需自己在加同步；HashMap线程不安全，因为HashMap底层是一个Entry数组，当发生hashmap冲突的时候，hashmap是采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。三、是否有contains方法1、HashTable有一个contains(Object value)方法，功能和containsValue方法（Object value)功能一样。2、HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey。四、可否允许有null值key、value都是对象，但是不能拥有重复key值，value值可以重复出现。1、Hashtable中，key和value都不允许出现null值。2、HashMap允许null值（key和value都可以），因为在HashMap中null可以作为健，而它对应的值可以有多个null。五、遍历方式内部实现不同1.HashTable使用Enumeration，HashMap使用Iterator。

并不能保证,但是可以通过判断,得到现在有无数据,若有,进入下一层。

HashTable不就可以吗。

http://blog.csdn.net/rickiyeat/article/details/52708794

首先介绍一下什么是Map.在数组中我们是通过数组下标来对其内容索引的，而在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key,其对应的对象叫做value.这就是我们平时说的键值对。　　HashMap通过hashcode对其内容进行快速查找，而 TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。　　HashMap 非线程安全 TreeMap 非线程安全　　线程安全　　在Java里，线程安全一般体现在两个方面：　　1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized.如ArrayList和Vector,HashMap和Hashtable　　（后者每个方法前都有synchronized关键字）。如果你在interator一个List对象时，其它线程remove一个element,问题就出现了。　　2、每个线程都有自己的字段，而不会在多个线程之间共享。它主要体现在java.lang.ThreadLocal类，而没有Java关键字支持，如像static、transient那样。　　1.AbstractMap抽象类和SortedMap接口　　AbstractMap抽象类：（HashMap继承AbstractMap）覆盖了equals（）和hashCode（）方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同，则这两个映射相等。映射的哈希码是映射元素哈希码的总和，其中每个元素是Map.Entry接口的一个实现。因此，不论映射内部顺序如何，两个相等映射会报告相同的哈希码。　　SortedMap接口：（TreeMap继承自SortedMap）它用来保持键的有序顺序。SortedMap接口为映像的视图（子集），包括两个端点提供了访问方法。除了排序是作用于映射的键以外，处理SortedMap和处理SortedSet一样。添加到SortedMap实现类的元素必须实现Comparable接口，否则您必须给它的构造函数提供一个Comparator接口的实现。TreeMap类是它的唯一一份实现。　　2.两种常规Map实现　　HashMap:基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode（）和equals（）[可以重写hashCode（）和equals（）],为了优化HashMap空间的使用，您可以调优初始容量和负载因子。　　（1）HashMap（）： 构建一个空的哈希映像　　（2）HashMap（Map m）： 构建一个哈希映像，并且添加映像m的所有映射　　（3）HashMap（int initialCapacity）： 构建一个拥有特定容量的空的哈希映像　　（4）HashMap（int initialCapacity, float loadFactor）： 构建一个拥有特定容量和加载因子的空的哈希映像　　TreeMap:基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。　　（1）TreeMap（）：构建一个空的映像树　　（2）TreeMap（Map m）： 构建一个映像树，并且添加映像m中所有元素　　（3）TreeMap（Comparator c）： 构建一个映像树，并且使用特定的比较器对关键字进行排序　　（4）TreeMap（SortedMap s）： 构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序　　3.两种常规Map性能　　HashMap:适用于在Map中插入、删除和定位元素。　　Treemap:适用于按自然顺序或自定义顺序遍历键（key）。　　4.总结　　HashMap通常比TreeMap快一点（树和哈希表的数据结构使然），建议多使用HashMap,在需要排序的Map时候才用TreeMap.　　import java.util.HashMap;　　import java.util.Hashtable;　　import java.util.Iterator;　　import java.util.Map;　　import java.util.TreeMap;　　public class HashMaps {　　public static void main（String[] args） {　　Map<String, String> map = new HashMap<String, String>（）；　　map.put（"a", "aaa"）；　　map.put（"b", "bbb"）；　　map.put（"c", "ccc"）；　　map.put（"d", "ddd"）；　　Iterator<String> iterator = map.keySet（）。iterator（）；　　while （iterator.hasNext（）） {　　Object key = iterator.next（）；　　System.out.println（"map.get（key） is :" + map.get（key））；　　}　　// 定义HashTable,用来测试　　Hashtable<String, String> tab = new Hashtable<String, String>（）；　　tab.put（"a", "aaa"）；　　tab.put（"b", "bbb"）；　　tab.put（"c", "ccc"）；　　tab.put（"d", "ddd"）；　　Iterator<String> iterator_1 = tab.keySet（）。iterator（）；　　while （iterator_1.hasNext（）） {　　Object key = iterator_1.next（）；　　System.out.println（"tab.get（key） is :" + tab.get（key））；　　}　　TreeMap<String, String> tmp = new TreeMap<String, String>（）；　　tmp.put（"a", "aaa"）；　　tmp.put（"b", "bbb"）；　　tmp.put（"c", "ccc"）；　　tmp.put（"d", "cdc"）；　　Iterator<String> iterator_2 = tmp.keySet（）。iterator（）；　　while （iterator_2.hasNext（）） {　　Object key = iterator_2.next（）；　　System.out.println（"tmp.get（key） is :" + tmp.get（key））；　　}　　}　　}　　运行结果如下：　　map.get（key） is :ddd　　map.get（key） is :bbb　　map.get（key） is :ccc　　map.get（key） is :aaa　　tab.get（key） is :bbb　　tab.get（key） is :aaa　　tab.get（key） is :ddd　　tab.get（key） is :ccc　　tmp.get（key） is :aaa　　tmp.get（key） is :bbb　　tmp.get（key） is :ccc　　tmp.get（key） is :cdc　　HashMap的结果是没有排序的，而TreeMap输出的结果是排好序的。　　下面就要进入本文的主题了。先举个例子说明一下怎样使用HashMap:　　import java.util.*;　　public class Exp1 {　　public static void main（String[] args）{　　HashMap h1=new HashMap（）；　　Random r1=new Random（）；　　for （int i=0;i<1000;i++）{　　Integer t=new Integer（r1.nextInt（20））；　　if （h1.containsKey（t））　　（（Ctime）h1.get（t））。count++;　　else　　h1.put（t, new Ctime（））；　　}　　System.out.println（h1）；　　}　　}　　class Ctime{　　int count=1;　　public String toString（）{　　return Integer.toString（count）；　　}　　}　在HashMap中通过get（）来获取value,通过put（）来插入value,ContainsKey（）则用来检验对象是否已经存在。可以看出，和ArrayList的操作相比，HashMap除了通过key索引其内容之外，别的方面差异并不大。　　前面介绍了，HashMap是基于HashCode的，在所有对象的超类Object中有一个HashCode（）方法，但是它和equals方法一样，并不能适用于所有的情况，这样我们就需要重写自己的HashCode（）方法。下面就举这样一个例子：　　import java.util.*;　　public class Exp2 {　　public static void main（String[] args）{　　HashMap h2=new HashMap（）；　　for （int i=0;i<10;i++）　　h2.put（new Element（i）， new Figureout（））；　　System.out.println（"h2:"）；　　System.out.println（"Get the result for Element:"）；　　Element test=new Element（5）；　　if （h2.containsKey（test））　　System.out.println（（Figureout）h2.get（test））；　　else　　System.out.println（"Not found"）；　　}　　}　　class Element{　　int number;　　public Element（int n）{　　number=n;　　}　　}　　class Figureout{　　Random r=new Random（）；　　boolean possible=r.nextDouble（）>0.5;　　public String toString（）{　　if （possible）　　return "OK!";　　else　　return "Impossible!";　　}　　}　　在这个例子中，Element用来索引对象Figureout,也即Element为key,Figureout为value.在Figureout中随机生成一个浮点数，如果它比0.5大，打印"OK!",否则打印"Impossible!".之后查看Element（3）对应的Figureout结果如何。　　结果却发现，无论你运行多少次，得到的结果都是"Not found".也就是说索引Element（3）并不在HashMap中。这怎么可能呢？　　原因得慢慢来说：Element的HashCode方法继承自Object,而Object中的HashCode方法返回的HashCode对应于当前的地址，也就是说对于不同的对象，即使它们的内容完全相同，用HashCode（）返回的值也会不同。这样实际上违背了我们的意图。因为我们在使用 HashMap时，希望利用相同内容的对象索引得到相同的目标对象，这就需要HashCode（）在此时能够返回相同的值。在上面的例子中，我们期望 new Element（i） （i=5）与 Elementtest=newElement（5）是相同的，而实际上这是两个不同的对象，尽管它们的内容相同，但它们在内存中的地址不同。因此很自然的，上面的程序得不到我们设想的结果。下面对Element类更改如下：　　class Element{　　int number;　　public Element（int n）{　　number=n;　　}　　public int hashCode（）{　　return number;　　}　　public boolean equals（Object o）{　　return （o instanceof Element） && （number==（（Element）o）。number）；　　}　　}　　在这里Element覆盖了Object中的hashCode（）和equals（）方法。覆盖hashCode（）使其以number的值作为 hashcode返回，这样对于相同内容的对象来说它们的hashcode也就相同了。而覆盖equals（）是为了在HashMap判断两个key是否相等时使结果有意义（有关重写equals（）的内容可以参考我的另一篇文章《重新编写Object类中的方法》）。修改后的程序运行结果如下：　　h2:　　Get the result for Element:　　Impossible!　　请记住：如果你想有效的使用HashMap,你就必须重写在其的HashCode（）。　　还有两条重写HashCode（）的原则：　　[list=1]　　不必对每个不同的对象都产生一个唯一的hashcode,只要你的HashCode方法使get（）能够得到put（）放进去的内容就可以了。即"不为一原则".　　生成hashcode的算法尽量使hashcode的值分散一些，不要很多hashcode都集中在一个范围内，这样有利于提高HashMap的性能。即"分散原则".至于第二条原则的具体原因，有兴趣者可以参考Bruce Eckel的《Thinking in Java》，在那里有对HashMap内部实现原理的介绍，这里就不赘述了。　　掌握了这两条原则，你就能够用好HashMap编写自己的程序了。不知道大家注意没有，java.lang.Object中提供的三个方法：clone（），equals（）和hashCode（）虽然很典型，但在很多情况下都不能够适用，它们只是简单的由对象的地址得出结果。这就需要我们在自己的程序中重写它们，其实java类库中也重写了千千万万个这样的方法。利用面向对象的多态性--覆盖，Java的设计者很优雅的构建了Java的结构，也更加体现了Java是一门纯OOP语言的特性。

HashMap是Hashtable的轻量级实现(非线程安全的实现)，他们都完成了Map接口，主要区别在于HashMap允许空(null)键值(key),由于非线程安全，效率上可能高于Hashtable。HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步(如果是ArrayList：List lst = Collections.synchronizedList(new ArrayList());如果是HashMap：Map map = Collections.synchronizedMap(new HashMap());)。Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

从结构实现来讲，HashMap是:数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下如所示。

【答案】：Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(load factor)和扩容极限(threshold resizing)。

在Windows下运行应用程序时出现非法操作的提示此类故障引起原因较多，在如下几钟可能:（1） 系统文件被更改或损坏，倘若由此引发则打开一些系统自带的程序时就会出现非法操作，（例如，打开控制面板）（2） 驱动程序未正确安装，此类故障一般表现在显卡驱动程序之止，倘若由此引发，则打开一些游戏程序时就会产生非法操作，有时打开一此网页也会出现这种程况。（3） 内存质量不好，降低内存速度也可能会解决这个问题。（4） 软件不兼容，如，IE 5。5在Windows 98 SE 上，当打开多个网页也会产生非法操作。

很大吧，现在的NOSQL不就是这种原理吗，专门用来处理大数据的。

用hashmap>作为数据结构，然后，添加删除什么的就在hashmap里面的hashset加一个A比如说

这个是基础题呀，主要看你对常用的东西是否真的了解如果只是会用，而不了解原理，他们就认为你没有专研的精神也就是说潜力不大

上一篇文章 HashMap的底层原理探索 我们分析了JDK1.7中Hashmap的源码实现，但是在JDK1.8的时候HashMap的实现做了很大的变动和优化。1.7和1.7之前HashMap都是“数组+链表”实现的，1.8之后就是“数组+（链表或红黑树）”来实现的了。这里我特地将“链表或红黑树”用一对括号括在一起，因为HashMap底层依旧是一个数组，然后数组中的元素是链表或者红黑树来实现的。 HashMap的实现就先介绍到这，下面就先讲一下红黑树，然后才能理解为什么要用红黑树来优化HashMap，用红黑树有什么好处。 在介绍红黑树之前我们要先理解二叉查找树的数据结构。下面简单介绍一下。 上面这张图就是一个二叉查找树。二叉查找树有如下几条特性 （1）.左子树上所有结点的值均小于或等于它的根结点的值。 （2）.右子树上所有结点的值均大于或等于它的根结点的值。 （3）.左、右子树也分别为二叉排序树 那既然他名字中是有“查找”的，那么他是怎么查找的呢？比如我们要查找10这个元素，查找过程为：首先找到根节点，然后根据二叉查找树的第一二条特性，我们知道要查找的10>9所以是在根节点的右边去查找，找到13，10<13,所以接着在13的左边找，找到11,10<11,继续在11的左边查找，这样就找到了10.这其实就是二分查找的思想。最后我们要查出结果所需的最大次数就是二叉树的高度！（二分查找的思想:找到数组的中间位置的元素v，将数组分成>v和<v两部分，然后将v和要查找的数据进行一个比较，如果大于v那么就在>v的部分再次进行二分查找，否则就在<v的部分进行二分查找，直到找到对应的元素。） 那既然要查出结果所需的最大次数就是二叉树的高度，那这个高度会不会有时候很长呢？ 比如我们依次插入 根节点为9如下五个节点：7,6,5,4,3。依照二叉查找树的特性，结果会变成什么样呢？7,6,5,4,3一个比一个小，那么就会成一条直线，也就是成为了线性的查询，时间复杂度变成了O（N）级别。为了解决这种情况，该红黑树出场了。 红黑树其实就是一种 自平衡 的二叉查找树。他这个自平衡的特性就是对HashMap中链表可能会很长做出的优化。 红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求: 性质1. 节点是红色或黑色。 性质2. 根节点是黑色。 性质3 每个叶节点（NIL节点，空节点）是黑色的。 性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 下面这棵树就是一个典型的红黑树 红黑树那么多规则，那么在插入和删除元素会不会破坏红黑树的规则呢？什么情况下会破坏？什么情况下不会？ 比如我们向原红黑树插入为14的新节点就不会破坏规则 向原红黑树插入值为21的新节点就破坏了规则 那么红黑树是怎么维护这个二叉查找树的自平衡性的呢？ 红黑树通过 “变色”和“旋转” 来维护红黑树的规则，变色就是让黑的变成红的，红的变成黑的，旋转又分为“左旋转”和“右旋转”。这个比较复杂，容易晕，我们就只要知道红黑树就是通过这种方式来实现它的自平衡性就行了。 JDK1.7的时候是使用一个Entry数组来存储数据，用key的hashcode取模来决定key会被放到数组里的位置，如果hashcode相同，或者hashcode取模后的结果相同（hash collision），那么这些key会被定位到Entry数组的同一个格子里，这些key会形成一个链表。在hashcode特别差的情况下，比方说所有key的hashcode都相同，这个链表可能会很长，那么put/get操作都可能需要遍历这个链表。也就是说时间复杂度在最差情况下会退化到O(n) 红黑树我们大致了解了，他的好处就是他的自平衡性，让他这棵树的最大高度为2log(n+1)，n是树的节点数。那么红黑树的复杂度就只有 O(log n)。 下面我们通过追踪JDK1.8 HashMap的put方法的源码来理解 put方法调用了putVal方法 通过putVal方法可以看到这里的数组和1.7不同，是使用了一个Node数组来存储数据。那这个Node和1.7里面的Entry的区别是什么呢？ HashMap中的红黑树节点 采用的是TreeNode 类 TreeNode和Entry都是Node的子类，也就说Node可能是链表结构，也可能是红黑树结构。 如果插入的key的hashcode相同，那么这些key也会被定位到Node数组的同一个格子里。如果同一个格子里的key不超过8个，使用链表结构存储。如果超过了8个，那么会调用treeifyBin函数，将链表转换为红黑树。 先分析到这。。。。。

Hashtable的实现方法里面都添加了synchronized关键字来确保线程同步，因此相对而言HashMap性能会高一些，我们平时使用时若无特殊需求建议使用HashMap，在多线程环境下若使用HashMap需要使用Collections.synchronizedMap()方法来获取一个线程安全的集合（Collections.synchronizedMap()实现原理是Collections定义了一个SynchronizedMap的内部类，这个类实现了Map接口，在调用方法时使用synchronized来保证线程同步,当然了实际上操作的还是我们传入的HashMap实例，简单的说就是Collections.synchronizedMap()方法帮我们在操作HashMap时自动添加了synchronized来实现线程同步，类似的其它Collections.synchronizedXX方法也是类似原理）

上面的仁兄讲的挺清楚的，回楼主的追问，hash值是不会一样的

HashMap在实际开发中用到的频率非常高，面试中也是热点。所以决定写一篇文章进行分析，希望对想看源码的人起到一些帮助，看之前需要对链表比较熟悉。 以下都是我自己的理解，欢迎讨论，写的不好轻喷。 HashMap中的数据结构为散列表，又名哈希表。在这里我会对散列表进行一个简单的介绍，在此之前我们需要先回顾一下 数组 、 链表 的优缺点。 数组和链表的优缺点取决于他们各自在内存中存储的模式，也就是直接使用 顺序存储 或 链式存储 导致的。无论是数组还是链表，都有明显的缺点。而在实际业务中，我们想要的往往是寻址、删除、插入性能都很好的数据结构，散列表就是这样一种结构，它巧妙的结合了数组与链表的优点，并将其缺点弱化（并不是完全消除） 散列表的做法是将key映射到数组的某个下标，存取的时候通过key获取到下标（index）然后通过下标直接存取。速度极快，而将key映射到下标需要使用 散列函数 ，又名 哈希函数 。说到哈希函数可能有人已经想到了，如何将key映射到数组的下标。 图中计算下标使用到了以下两个函数： 值得注意的是，下标并不是通过hash函数直接得到的，计算下标还要对hash值做index()处理。 Ps：在散列表中，数组的格子叫做 桶 ，下标叫做 桶号 ，桶可以包含一个key-value对，为了方便理解，后文不会使用这两个名词。 以下是哈希碰撞相关的说明： 以下是下标冲突相关的说明： 很多人认为哈希值的碰撞和下标冲突是同一个东西，其实不是的，它们的正确关系是这样的， hashCode发生碰撞，则下标一定冲突；而下标冲突，hashCode并不一定碰撞 上文提到，在jdk1.8以前HashMap的实现是 散列表 = 数组 + 链表 ，但是到目前为止我们还没有看到链表起到的作用。事实上，HashMap引入链表的用意就是解决下标冲突。 下图是引入链表后的散列表： 如上图所示，左边的竖条，是一个大小为16的数组，其中存储的是链表的头结点，我们知道，拥有链表的头结点即可访问整个链表，所以认为这个数组中的每个下标都存储着一个链表。其具体做法是，如果发现下标冲突，则 后插入的节点以链表的形式追加到前一个节点的后面 。 这种使用链表解决冲突的方法叫做： 拉链法 （又叫链地址法）。HashMap使用的就是拉链法，拉链法是冲突发生以后的解决方案。 Q：有了拉链法，就不用担心发生冲突吗？ A：并不是！由于冲突的节点会不停的在链表上追加，大量的冲突会导致单个链表过长，使查询性能降低。所以一个好的散列表的实现应该从源头上减少冲突发生的可能性，冲突发生的概率和哈希函数返回值的均匀程度有直接关系，得到的哈希值越均匀，冲突发生的可能性越小。为了使哈希值更均匀，HashMap内部单独实现了hash()方法。 以上是散列表的存储结构，但是在被运用到HashMap中时还有其他需要注意的地方，这里会详细说明。 现在我们清楚了散列表的存储结构，细心的人应该已经发现了一个问题：Java中数组的长度是固定的， 无论哈希函数是否均匀，随着插入到散列表中数据的增多，在数组长度不变的情况下，链表的长度会不断增加 。这会导致链表查询性能不佳的缺点出现在散列表上，从而使散列表失去原本的意义。为了解决这个问题，HashMap引入了扩容与负载因子。 以下是和扩容相关的一些概念和解释： Ps： 扩容要重新计算下标 ， 扩容要重新计算下标 ， 扩容要重新计算下标 ，因为下标的计算和数组长度有关，长度改变，下标也应当重新计算。 在1.8及其以上的jdk版本中，HashMap又引入了红黑树。 红黑树的引入被用于替换链表，上文说到，如果冲突过多，会导致链表过长，降低查询性能，均匀的hash函数能有效的缓解冲突过多，但是并不能完全避免。所以HashMap加入了另一种解决方案，在往链表后追加节点时，如果发现链表长度达到8，就会将链表转为红黑树，以此提升查询的性能。

回顾一下基本概念： 一. put方法 HashMap使用哈希算法得到数组中保存的位置，然后调用put方法将key-value对保存到table变量中。我们通过图来演示一下存储的过程。 简单解释一下： 我们关注一下这里面最重要的三个方法，hash()，putVal()，resize(). 1. hash方法 我们通过hash方法计算索引，得到数组中保存的位置，看一下源码 我们可以看到HashMap中的hash算法是通过key的hashcode值与其hashcode右移16位后得到的值进行异或运算得到的，那么为什么不直接使用key.hashCode()，而要进行异或操作？我们知道hash的目的是为了得到进行索引，而hash是有可能冲突的，也就是不同的key得到了同样的hash值，这样就很容易产业碰撞，如何减少这种情况的发生呢，就通过上述的hash(Object key)算法将hashcode 与 hashcode的低16位做异或运算，混合了高位和低位得出的最终hash值，冲突的概率就小多了。举个例子： 我们的hash(Object key)算法一个道理，最终的hash值混合了高位和低位的信息，掺杂的元素多了，那么最终hash值的随机性越大，而HashMap的table下标依赖于最终hash值与table.length()-1的&运算，这里的&运算类似于挑包子的过程，自然冲突就小得多了。计算过程如下： 2. putVal方法 通过putVal方法将传递的key-value对添加到数组table中。 3. resize方法 HashMap通过resize()方法进行扩容，容量规则为2的幂次 二. get方法 我们先简单说一下get(Object key)流程，通过传入的key通过hash()算法得到hash值，在通过(n - 1) & hash找到数组下标，如果数组下标所对应的node值正好key一样就返回，否则找到node.next找到下一个节点，看是否是treenNode，如果是，遍历红黑树找到对应node，如果不是遍历链表找到node。我们看一下源码 这几个方法是核心，虽然HashMap还有很多常用方法，不过大体和这几个方法有关，或者实现逻辑相似，这里就不再多说了。 三. 总结 本文在上一章基本概念和底层结构的基础上，从源码的角度讲解了扩容机制以及存取原理，主要分析了put方法和get方法，put方法的核心为hash()，putVal()，resize()，get方法的核心为getNode()。

Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(loadfactor)和扩容极限(thresholdresizing)。

我们常见的有集合数据有三种结构：1、数组结构 2、链表结构 3、哈希表结构 下面我们来看看各自的数据结构的特点： 而我们常见的HashMap就是这样的一种数据结构 （1）、首先将k,v封装到Node对象当中（节点）。 （2）、然后它的底层会调用K的hashCode()方法得出hash值。 （3）、通过哈希表函数/哈希算法，将hash值转换成数组的下标，下标位置上如果没有任何元素，就把Node添加到这个位置上。如果说下标对应的位置上有链表。此时，就会拿着k和链表上每个节点的k进行equal。如果所有的equals方法返回都是false，那么这个新的节点将被添加到链表的末尾。如其中有一个equals返回了true，那么这个节点的value将会被覆盖。 (1)、先调用k的hashCode()方法得出哈希值，并通过哈希算法转换成数组的下标。 (2)、通过上一步哈希算法转换成数组的下标之后，在通过数组下标快速定位到某个位置上。重点理解如果这个位置上什么都没有，则返回null。如果这个位置上有单向链表，那么它就会拿着参数K和单向链表上的每一个节点的K进行equals，如果所有equals方法都返回false，则get方法返回null。如果其中一个节点的K和参数K进行equals返回true，那么此时该节点的value就是我们要找的value了，get方法最终返回这个要找的value。 原因 : 增删是在链表上完成的，而查询只需扫描部分，则效率高。 HashMap集合的key，会先后调用两个方法，hashCode and equals方法，这这两个方法都需要重写。 因为equals方法默认比较的是两个对象的内存地址 https://blog.csdn.net/qq_37840993/article/details/108048597

hashmap底层实现原理是SortedMap接口能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator遍历TreeMap时，得到的记录是排过序的。如果使用排序的映射，建议使用TreeMap。在使用TreeMap时，key必须实现Comparable接口或者在构造TreeMap传入自定义的Comparator，否则会在运行时抛出java.lang.ClassCastException类型的异常。Hashtable是遗留类，很多映射的常用功能与HashMap类似，不同的是它承自Dictionary类，并且是线程安全的，任一时间只有一个线程能写Hashtable从结构实现来讲，HashMap是：数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的。扩展资料从源码可知，HashMap类中有一个非常重要的字段，就是 Node[] table，即哈希桶数组。Node是HashMap的一个内部类，实现了Map.Entry接口，本质是就是一个映射(键值对)，除了K，V，还包含hash和next。HashMap就是使用哈希表来存储的。哈希表为解决冲突，采用链地址法来解决问题，链地址法，简单来说，就是数组加链表的结合。在每个数组元素上都一个链表结构，当数据被Hash后，得到数组下标，把数据放在对应下标元素的链表上。如果哈希桶数组很大，即使较差的Hash算法也会比较分散，如果哈希桶数组数组很小，即使好的Hash算法也会出现较多碰撞，所以就需要在空间成本和时间成本之间权衡，其实就是在根据实际情况确定哈希桶数组的大小，并在此基础上设计好的hash算法减少Hash碰撞。

kathmandu nepal是【尼泊尔首都加德满都】。尼泊尔联邦民主共和国（英语：Federal Democratic Republic of Nepal），简称尼泊尔。南亚山区的内陆国，位于喜马拉雅山脉南麓（属青藏高原南底），北与中国相接，其余三面与印度为邻。喜玛拉雅山脉是中尼的天然国界，包括珠峰在内，世界十大高峰有八座在中尼边境。全国总面积14.7万平方公里，总人口约为2850万人。

正常。 我的电脑前两天显示也和你的一样，这几天我卸载了鲁大师。

抱歉碰不到机器可能无法确定问题的具体原因，但从你的问题看出你可能走入了一个误区——认为Hbase启动或安装出现问题从原理上讲，在集群中Zookeeper中会通过投票方式选举出一个Zookeeper为主，其余类似于主的热备而主Zookeeper会指定Hmaster，并由指定的Hmaster来进行Hbase的操作现在你的报错是ZooKeeper create failed after 4 attempts（Zookeeper尝试创建并失败4次导致最终无法创建）带来的后果就是你的Hmaster未选举出（并离线），使得你的Hbase无法管理大概原因可能有两种一种是因为各机器间无法正常通信导致集群脑裂Zookeeper无法进行选举或是各主机之间权限不足导致声明Master的短命节点文件无法被创建（可能性较低）（也许干脆就是集群数量过小无法选举？）大概是这些可能，我也还在学习阶段无法给出太过明确的答案，不过建议你从集群互相的通讯（包括每个节点上的Zookeeper安装情况以及互信、网络情况来入手考虑一下？我和很多朋友在安装过程中因为各个节点的软件源以及互信以及软件仓库网络配置等问题纠结了很多天，还有些安装包本身是有问题的（文件损坏或是唯独nagios安装包权限为222导致错误），你可以从这方面入手试试

HashMap的工作原理是近年来常见的Java面试题。几乎每个Java程序员都知道HashMap，都知道哪里要用HashMap，知道HashTable和HashMap之间的区别，那么为何这道面试题如此特殊呢？是因为这道题考察的深度很深。这题经常出现在高级或中高级面试中。投资银行更喜欢问这个问题，甚至会要求你实现HashMap来考察你的编程能力。ConcurrentHashMap和其它同步集合的引入让这道题变得更加复杂。让我们开始探索的旅程吧！

HashMap的实现原理：首先有一个每个元素都是链表（可能表述不准确）的数组，当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了。这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，所以说数组存放的是链表。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率。当链表数组的容量超过初始容量的0.75时，再散列将链表数组扩大2倍，把原链表数组的搬移到新的数组中。扩展资料HashMap和Hashtable的区别1、HashMap可以接受为null的键值（key）和值（value），而Hashtable则不行。2、HashMap是非synchronized，而Hashtable是synchronized。意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。3、由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。5、HashMap不能保证随着时间的推移Map中的元素次序是不变的。

HashMap的实现原理：首先有一个每个元素都是链表（可能表述不准确）的数组，当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了。这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，所以说数组存放的是链表。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率。当链表数组的容量超过初始容量的0.75时，再散列将链表数组扩大2倍，把原链表数组的搬移到新的数组中。HashMap和哈希表的关系1、HashMap可以接受为null的键值（key）和值（value），而Hashtable则不行。2、HashMap是非synchronized，而Hashtable是synchronized。意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。3、由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。5、HashMap不能保证随着时间的推移Map中的元素次序是不变的。

动词不用过去时的原因可能有以下几点：1. 句子中的动作在过去发生，但仍然与现在的情境相关。在英语中，有时我们使用现在时来描述过去的事件，以便让听者或读者感觉这个事件正在发生或与当前情况密切相关。例如，"They drug the watchman and rob the bank"可能暗示这个事件与当前的讨论或故事情节有关。2. 过去时态可能带有某种主观色彩，而使用现在时能够提供客观描述。在一些情况下，使用过去时态可能会赋予动作某种完成并过去的意味。然而，使用现在时态可以使描述更加客观，减少对事件的主观评价。3. 句子中的动作是习惯性的或经常性的。在某些情况下，无论动作何时发生，人们倾向于使用现在时来描述一种经常性的行为或习惯。例如，"They drug the watchman and rob the bank"可能表示这是他们的惯常行为。需要注意的是，语言是灵活的，使用过去时态或现在时态取决于交流的目的和语境。以上仅提供了一些可能的原因，但并不适用于所有情况。

不可以。netwatchman这个是一个微软的系统组件，是系统的一个重要的组件，不可以进行卸载，卸载的话会影响电脑的正常运行。电脑是指计算机，计算机俗称电脑，是现代一种用于高速计算的电子计算机器，可以进行数值计算，又可以进行逻辑计算，还具有存储记忆功能。

《The Night Watchman》（Mynheir, Mark）电子书网盘下载免费在线阅读链接: https://pan.baidu.com/s/1KjjPD5Gcvj5j2i89uWp8Aw 提取码: 7ajg书名：The Night Watchman作者：Mynheir, Mark页数：383

关键是录像机是否支持 ONVIF 标准协议。只要支持， 都可以对接

全集12本 但是是英文的 楼主将就一下吧 http://www.verycd.com/topics/2734388/

歌曲名:DEAR FUTURE by WATCHMAN 歌手:coaltar of the deepers专辑:DEAR FUTURE「DEAR FUTURE by SECRET SHINE」作词∶岩里祐穂/EMI K. Lynn作/编曲∶NARASAKI歌∶coaltar of the deepersI don"t know what to do,tell me where we are nowSomebody show us the way,where should we go from here?If we were born with fate,If we have our destinyWhy are we trying so hard?Why do we cry so much?Don"t worry you don"t have to cryDon"t worry nothing is your faultYou don"t have to feel sorryand alone now, no moreNow we are here alone,looking at each otherBut we still can"t realize the pain that we both feelSo we try to look inside and listen to our heartsThen we can hear words of love,sounding sweet and beautifulDon"t worry you can find the wayDon"t worry it won"t be the sameI can"t tell, I can"t tell you so well but I…Remember when we swamdeep in the ocean blueRemember starting our life,beginning life anewDon"t worry you don"t have to cryDon"t worry nothing is your faultYou don"t have to feel sorrowand alone now, no moreDon"t worry you can find the wayDon"t worry it won"t be the sameI can"t tell, I can"t tell you so well but I…DEAR MY FUTUREDEAR YOUR FUTURE【 おわり 】http://music.baidu.com/song/16651769

这种全新手术通过微创，闭合了房颤病人血栓发生的根源部位——左心耳，由此可降低房颤病人中风的风险。左心耳是从左心房伸出的耳状小囊，属于左心房的一部分，它是左心房主要组成部位。

楼主你好！你可以下载个腾讯电脑管家、试试里面的软件管理功能它会检测当前电脑上已经安装的软件，并且按照一定的分类展示，卸载不常用的软件有助于提升系统性能，增加磁盘可用空间。卸载界面默认按照软件使用频率排序，用户可以按照软件名称、空间占用、安装时间等排序可卸载的软件。选择不想继续使用的软件，点击【卸载】按钮，一刻完成卸载操作。

Watchman监控的初始密码admin12345。监控是安防系统中应用最多的系统之-，由前端部分和控制部分构成。它通过摄像头、录像机、监视器、交换机、网线等一整套监控设备组成视频系统来实现人们的监控用途。监控几乎可以应用在所有行业，为人们生活、工作、生产都带来了极大的便利。

你搜网址盒子 里边很多百度网盘电影 应该有你要的

曾敬骅。曾敬骅，1997年12月30日出生于台湾省宜兰县，毕业于义守大学电影与电视学系，中国台湾影视男演员。在《逆局》中饰演watchman，真名陆齐，是陆振声医院创始人的独子。幼年时母亲自杀，父亲也在同年去世。由现任的医院执行长穆雪松，也是陆振声的左右手将其抚养成人。剧情：《逆局》是由爱奇艺国际站推出的，庄绚维、陈冠仲执导，周渝民、张榕容、吴兴国、李铭顺、朱轩洋、曾敬骅主演的悬疑电视剧，于2021年9月3日在爱奇艺国际站上线，2021年9月4日在中国台湾纬来电影台播出。该剧改编自中国大陆作家千羽之城的小说《追凶者》，讲述了虚构的沿海城市东林市里发生了耸人听闻的连续杀人命案的故事。

这是携程网招募java工程师的邮箱。可以收邮件的。邮件是指经传递方式处理的文件。邮件进行传递的过程称为“邮递”，而从事邮递服务的机构或系统，则称为邮政。邮件有国内邮件和国际邮件两类。电子邮件是—种用电子手段提供信息交换的通信方式，是互联网应用最广的服务。

组队模式

poshmark注册有效账号的做法是从APP商店下载Ehpv6ePoshmarkZLFUM3 APP，或是访yqcoqt问PoshmarGbwPCIk网站创建账号。Poshmark是一个时尚电商平台，位于加州Redwood City，销售服装和配饰，包括二手T恤、高端精品女装和自有品牌，消费者可以对产品进行出价购买，被称为海外版“闲鱼”。目前有超过8000万的用户和450万的活跃卖家，卖出商品超1.3亿件！是美国领先的二手电商平台。Pushmark的平台操作也很简单。卖家只需下载APP后注册，拍照上传，给出衣服的描述，定价，就可以在平台上卖自己的二手物品了。Poshmark拥有“简单、社交、有趣”三大特色，将社交注入线上购物。独特的社区功能，让购物不再是冷冰冰的体验、专属于一个人的狂欢。也让Poshmark与亚马逊和eBay等其他电商平台得以区分。

直译为：肖邦，拉赫玛尼诺夫大提琴奏鸣曲。这是什么呀！楼主把问题问得清楚点。

理论上是可以用的，主板支持zen2的说。3900X上b450可以的，之前在B站见过Up主用来拷机使劲造，性能释放还是蛮不错。至于怎么选肯定是推荐华硕，tufb450mprogaming是最佳选择，用料好，10相供电，供电模块也有散热片，还有声卡，外观等，这些方面比微星同价位要强。在Bios方面华硕的软件用起来比微星的好使，微星所有AMD主板自检很慢，影响开机速度，最后建议把X570省下的钱用在高频内存上，华硕官方称tufb450mpro最高支持DDR4-4400，自己用上3600就很不错了，体验加分。

方法如下。微星主板安装固态硬盘的话，如果是m.2固态，那就在主板支持的情况下，拧开固态硬盘安装位置的螺丝，将固态硬盘插好，然后再把螺丝拧上就可以，如果是普通sata接口固态，那就把电源线和sata线连接好，固态在机箱上找位置固定好就可以了。

自己探索更有意思，用eclipse调试一下呗，看一下values返回的对象是什么类：System.out.println(map.values().getClass().getName());

棉花奶油糖

呵呵 好 鼓掌

软软 软软 软软 软软的你很特别 你很完美 再怎么跟别人比较和其他的人都不一样(不一样 不一样的Boy)/我很寒心 我很不足 却喜欢上了你只能傻傻的看着你的傻瓜我怎么会这样 只想着你啦啦啦啦 啦啦 飞上天空就是现在 怎么办 你正向我走来[Blah Blah快说话吧你说了什么 我听不清楚滴滴答答的时间STOP棉花糖 棉花糖 很甜所以很好棉花糖 棉花糖 爱情就是这样的吗软软 软软 软软的 真的真的 软软的Girl Girl baby girl Clap Clap & let it go像果冻一样的有弹性 像饼干一样的湿湿的Boy Boy baby boy boy (棉花糖)我很小心 我很担心 当我想起你会像个脸红的孩子一样我怎么会这样 只想着你啦啦啦啦 啦啦 飞上天空就是现在 怎么办 你正向我走来(Say what)我们交往吧 这样的跟我表白(怎么办 我该怎么办)我只想听见你的声音 真的等等 等等 一切都 嘘棉花糖 棉花糖 很甜所以很好棉花糖 棉花糖 爱情就是这样的吗软软 软软 软软的 真的真的 软软的Girl Girl baby girl Clap Clap & let it go像果冻一样的有弹性 像饼干一样的湿湿的Boy Boy baby boy boy是做梦吧 只要睁开眼 就会像谎言一样的消失是不是能遇见你 是不是能好好的 我不知道棉花糖 棉花糖 很甜所以很好棉花糖 棉花糖 爱情就是这样的吗软软 软软 软软的 真的真的 软软的Girl Girl baby girl Clap Clap & let it go像果冻一样的有弹性 像饼干一样的湿湿的Boy Boy baby boy boy棉花糖

ub9d0ub791 ub9d0ub791 ub9d0ub791 ub9d0ub791 ud574吗浪 吗浪 吗浪 吗浪 还ub10c ud2b9ubcc4ud574 uc644ubcbdud574 ube44uad50 ubd84uc11d ud574ubd10ub3c4闹恩 特表来 完表开 批giao本扫 还吧都ub2e4ub978 uc560ub4e4uacfcub294 ub2e4ub974uc9c0 (ub2ecub77c ub2ecub77c Boy)他了恩 爱的儿挂嫩 他了几（他拉他拉）ub09c ud55cuc2ecud574 ubd80uc871ud574 ub108uc5d0uac8cuc11c ub5a8uc5b4uc838难 喊西没 不走开 闹也给扫 到蒌叫ubc14ub77cubcf4uae30ub9cc ud558ub294 ubc14ubcf4uc9c0怕拉剖gi满 哈嫩 怕包几ub0b4uac00 uc65c uc774ub7f4uae4c ub108ub9cc uc0dduac01ud558ub2e4乃噶 外 一喽噶 闹满 僧噶卡大ub77cub784ub77cub77c ub784ub77c ub0a0uc544 uc62cub77c拉拉拉了 那拉 偶拉ubc14ub85c uadf8ub54c uc5b4ub5a1ud574 ub69cubc85 ub69cubc85 ub124uac00 uac78uc5b4uc640怕咯 可带 哦到开 读拨 读拨 内噶 口楼哇Blah Blah uc598uae30ub97c ud558uc9c0~~~~~~~~~呀gi了儿 哈几ubb34uc2a8 ub9d0uc744 ud574ub3c4 ub4e4ub9acuc9c0uac00 uc54auc544木森 吗了儿 还都 的里起噶 啊那uc9f8uae4d uc9f8uae4d uc2dcuac04uc774 STOP在噶 在噶 西噶你ub9c8uc26cuba5cub85cuc6b0 ub9c8uc26cuba5cub85cuc6b0 ub2ecucf64ud574uc11c ub108ubb34 uc88buc544吗许没楼无 吗许没楼无 他儿口买扫 闹木 走啊ub9c8uc26cuba5cub85cuc6b0 ub9c8uc26cuba5cub85cuc6b0 uc0acub791uc774ub780 uc774ub7f0 uac78uae4c吗许没蒌无 ~~~~~~~撒浪一蓝 一论够儿噶ub9d0ub791 ub9d0ub791 ub9d0ub791ud574 ub108ubb34 ub108ubb34ub098 ub9d0ub791ud574吗浪 吗浪 吗浪还 闹木 闹木 那吗浪还Girl Girl baby girl Clap Clap & let it gouc824ub9acucc98ub7fc ud1b5ud1b5ud574 ucfe0ud0a4ucc98ub7fc ucd09ucd09ud574贼里草楼木 同同还 cookie草楼木 凑凑开Boy Boy baby boy boy ub9c8uc26cuba5cub85cuc6b0 吗许没六无ub09c uc18cuc2ecud574 uace0ubbfcud574 ub108ub97c ub5a0uc62cub9b4 ub54cuba74难 艘西没 口米乃 闹了儿 到偶里儿 带面uc5bcuad74uc774 uc0c8ube68uac8c uc9c0ub294 uc544uc774uc778 uac78哦儿古里 塞把儿给 起嫩 啊一因 够儿ub0b4uac00 uc65c uc774ub7f4uae4c ub108ub9cc uc0c1uc0c1ud558ub2e4乃噶 外 一楼儿噶 闹满 桑桑哈大ub77cub784ub77cub77c ub784ub77c ub0a0uc544 uc62cub77c拉拉~~~~~~~~闹拉 偶拉ubc14ub85c uadf8ub54c uc5b4ub5a1ud574怕楼 可带 哦到开ub450uadfc ub450uadfc ub124uac00 ub2e4uac00uc640 (Say what)土跟 土跟 内噶 他噶哇uc0acuadc0uc790uace0 ub300uc26cub97c ud558uc9c0 (uc5b4ub5a1ud574 uc5b4ub5a1ud574)撒归家够 带许了儿哈几 哦到开哦到开ub108uc758 ubaa9uc18cub9acub9cc ub4e3uace0 uc2f6uc5b4 uc815ub9d0闹也 某艘里满 的够西破 增吗儿uac00ub9cc uac00ub9cc ubaa8ub450 ub2e4 uc27f卡满 卡满 某度 他 许

软绵绵 软绵绵 软绵绵的你很特别 很完美 即使对比分析跟别人不同 （不同不同 boy）我很没用 很不足 被你推开只能看着你的傻瓜我为什么这样 只想着你lalalala lala 飞翔吧就是那时 怎么办 一步一步 你走过来Blah Blah 说着话听不清你在说什么滴答滴答 时间stopMarshmallow Marshmallow 因为甜蜜所以非常喜欢Marshmallow Marshmallow 所谓爱情就是这样吗软绵绵 软绵绵 软绵绵的 非常 非常柔软Girl Girl baby girl Clap Clap & let it go像果冻一样胖嘟嘟 像曲奇饼一样入口即化Boy Boy baby boy boy Marshmallow我小心翼翼 苦恼着 当我想起你的时候脸会变得通红我为什么这样 只想象着你lalalala lala 飞翔吧就是那时 怎么办 心跳动着 你走过来(Say what)冲过开说我们交往吧 （怎么办 怎么办）只想听你的声音 真的等等 等等 大家都嘘Marshmallow Marshmallow 因为甜蜜所以非常喜欢Marshmallow Marshmallow 所谓爱情就是这样吗软绵绵 软绵绵 软绵绵的 非常 非常柔软Girl Girl baby girl Clap Clap & let it go像果冻一样胖嘟嘟 像曲奇饼一样入口即化Boy Boy baby boy boy Marshmallow是做梦吧 睁开眼都像谎言一样消失了会见到你的 我会再次入睡 不知道吗Marshmallow Marshmallow 因为甜蜜所以非常喜欢Marshmallow Marshmallow 所谓爱情就是这样吗软绵绵 软绵绵 软绵绵的 非常 非常柔软Girl Girl baby girl Clap Clap & let it go像果冻一样胖嘟嘟 像曲奇饼一样入口即化Boy Boy baby boy boy Marshmallow

Marshmallow IU软绵绵 软绵绵 软绵绵的你很特别 很完美 即使对比分析跟别人不同 （不同不同 boy）我很没用 很不足 被你推开只能看着你的傻瓜我为什么这样 只想着你lalalala lala 飞翔吧就是那时 怎么办 一步一步 你走过来Blah Blah 说着话听不清你在说什么滴答滴答 时间stopMarshmallow Marshmallow 因为甜蜜所以非常喜欢Marshmallow Marshmallow 所谓爱情就是这样吗软绵绵 软绵绵 软绵绵的 非常 非常柔软Girl Girl baby girl Clap Clap & let it go像果冻一样胖嘟嘟 像曲奇饼一样入口即化Boy Boy baby boy boy Marshmallow我小心翼翼 苦恼着 当我想起你的时候脸会变得通红我为什么这样 只想象着你lalalala lala 飞翔吧就是那时 怎么办 心跳动着 你走过来(Say what)冲过开说我们交往吧 （怎么办 怎么办）只想听你的声音 真的等等 等等 大家都嘘Marshmallow Marshmallow 因为甜蜜所以非常喜欢Marshmallow Marshmallow 所谓爱情就是这样吗软绵绵 软绵绵 软绵绵的 非常 非常柔软Girl Girl baby girl Clap Clap & let it go像果冻一样胖嘟嘟 像曲奇饼一样入口即化Boy Boy baby boy boy Marshmallow是做梦吧 睁开眼都像谎言一样消失了会见到你的 我会再次入睡 不知道吗Marshmallow Marshmallow 因为甜蜜所以非常喜欢Marshmallow Marshmallow 所谓爱情就是这样吗软绵绵 软绵绵 软绵绵的 非常 非常柔软Girl Girl baby girl Clap Clap & let it go像果冻一样胖嘟嘟 像曲奇饼一样入口即化Boy Boy baby boy boy Marshmallow

歌曲名:Later On歌手:Marshmallow专辑:MarshmallowDr. Dog - LaterI"ve got a jobI"ve got to move this paperI guess it"s all the same to youBut I can"t sit around and waitCan"t Sit around and wait for you.It never worksYou say you"ll call me laterAnd then you never ever do.I can"t sit around and waitJust another cup of coffee,I"ll sit around and wait for you.I always knewYeah, I always knewYou were a liar.I"m not a king, I"m not a cop.I"m not here to punish you.When I really can"t see anymoreof what the fuss is all aboutIt"s not my careerTo wait and do you favorsI guess it"s really nothing doWhen I"m running lateYou call the undertakerBecause you"ve got so much shit to doCan"t sit around and wait for you.Just one more cigarette,I guess I really willhttp://music.baidu.com/song/8297402