1.点 “window”-> "Preferences" -> "Java" -> "Installed JRES"
2.此时"Installed JRES"右边是列表窗格，列出了系统中的 JRE 环境，选择你的JRE，然后点边上的 "Edit..."， 会出现一个窗口(Edit JRE)
3.选中rt.jar文件的这一项：“c:\program files\java\jre_1.5.0_06\lib\rt.jar”
点 左边的“+” 号展开它，
4.展开后，可以看到“Source Attachment:(none)”，点这一项，点右边的按钮“Source Attachment...”, 选择你的JDK目录下的 “src.zip”文件
5.一路点"ok",结束。
㈡ 2022-04-24 IDEA调试jdk源码
如果想调试jdk源码，比如HashMap的put方法。F7进入之后，会看到key和value很奇怪，key是D://program Files/java/ 这样的。原因是oracle的rt.jar是锁住的。想调试jdk源码，可以自已编译openjdk源码，也可以简单的设置一下。
下面介绍简单设置的方法：
1，首先找到jdk的目录中javafx-src.zip和src.zip这2个压缩文件
2，复制到另一文件夹下，并解压
3，在IDEA中创建普通的java工程
4，设置IDEA的DEBUGGER项：去掉勾选
5，设置sourcepath，把原来的2个删掉，换上解压的文件夹javafx-src, src
这样就可以调试jdk源码了。
㈢ 如何用Mac完美编译OpenJDK 7
1.选择OSX版本很重要。目前这里Mac版本是10.10，配置好必要信息以后就开始编，结果错误满屏。简单看过之后发现是编译C文件的时候参数有误，于是查了一下，才知道是LLVM版本太新，不兼容低版本的一些编译参数。照着上面改了点代码，但是依旧编译不过。既然高版本不行，就装个低版本的呗。由于最新的OSX不能装低版本的Xcode（装了Xcode才能装LLVM），所以去下了一个10.8的OSX装在虚拟机里，然后再装个Xcode4.4。装好Xcode以后，要手动下载LLVM安装。打开Xcode，随便建立一个空项目，然后打开Preferences，找到如下所示的地方开始安装第一步咱就这么搞定了。2.安装X11X11这玩意是unix类os使用的图形系统，10.8以前的OSX是自带的，但是从此以后就不自带了。对应于Mac，你需要装XQuartz，这个没有版本限制，去网上下最新版即可。装这个的原因是当时在编译PolicyTools的时候出现了如下错误：ld:librarynotfoundfor-lX11安装以后要为X11建立软连接sudoln-s/usr/X11/include/X11/usr/include/X113.安装freetype在linux下编译openjdk的朋友可能遇到过需要安装freetype的要求，然后安装下并将安装目录加到环境变量里就好了。但是OSX不一样，freetype单独安装实际是没用的。虽然单独安装能让编译前的检查通过，但是到后面还是会出错，至于原因我没找到。那怎么呢？实际上如果安装好X11，freetype就一起安装好了，大家可以去X11的目录里看看是否有freetype。虽然说安装了X11就自带freetype，但是编译过程中可能会出现如下错误：error:freetype/config/ftheader.h:Nosuchfileordirectory实际上就是目录问题，执行下面这句命令就好了：sudoln-s/sr/X11/include/freetype2/freetype//usr/X11/include/freetype4.配置环境变量和在Linux下编译相比，OSX的环境变量配置相对来说简单很多。只需要配置编译需要的jdk和llvm的目录就可以了。因为很多源代码都是用本机现有的jdk来编译，所以预装一个低版本的jdk是必须的，这里我们需要安装jdk6。安装好以后，找到其安装目录，并添加如下环境变量：[plain]viewplainexportALT_BOOTDIR=/System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home通常来说安装目录都应该在/System/Library/Java/JavaVirtualMachines目录下。如果不在的话，有个技巧可以找到。因为安装好jdk以后，系统会自动在/usr/bin下建立指向java命令的软连接，所以执行“ls-l/usr/bin/java”就能看到这个命令指向哪，然后这么顺着找下去就能找到。llvm是编译C类文件所必须的，所以要把它的所在目录添加到环境变量里。通常OSX下安装app都会把app移到Applications目录下，所以我最初安装Xcode的时候也把他移进去了，如果你把Xcode放在了别的目录，那就找到对应的目录即可。[plain]viewplainexportALT_COMPILER_PATH=/Applications/Xcode.app/Contents/Developer/usr/bin5.获取编译源码按照这上面的第三点获取源代码如果没有装hg的需要自行安装到现在为止，编译前的准备工作已经完成。我们可以先执行makesanity执行下编译前的检查。如果检查通过，先来看看具体的编译命令：[plain]viewplainmakeALLOW_DOWNLOADS=trueSA_APPLE_BOOT_JAVA=trueSKIP_DEBUG_BUILD=falseSKIP_FASTDEBUG_BUILD=falseALWAYS_PASS_TEST_GAMMA=trueHOTSPOT_BUILD_JOBS=`sysctl-nhw.ncpu`这里有两个问题：a.ALLOW_DOWNLOADS=true表示编译过程中允许下载。因为有些编译模块，比如jaxp，编译脚本中指定了需要下载特定的包。虽然我没试过设置成false会不会影响编译，但是还是推荐设置成true。但是这就带来另一个问题，下载这类包很费时间，有时候就会在那卡很长时间，所以我根据编译日志找到编译脚本中控制下载的具体命令，修改修改并且把用迅雷下的对应包放到正确目录中，然后重新编译一遍，就能顺利通过了。这一点后面我会详说。b.SKIP_DEBUG_BUILD=falseSKIP_FASTDEBUG_BUILD=false这两个表示编译出来的jdk或者hotspot是否可以debug。FASTDEBUG表示的应该是提供简单的debug功能，如果想要完整的debug，则SKIP_DEBUG_BUILD必须设置为false。不过这里提醒一点，如果想在debugjdk的时候能看到debug信息，比如变量名等，只需要SKIP_FASTDEBUG_BUILD设置为false就可以了如果这两个问题都不是问题，那么就可以按回车了。如果debug和fastdebug都是false，再加上用虚拟机编译，所以需要的时间会比较长，你也许需要找一部长一点的电影来消磨一下了。最后编译出来的结果是这样的：j2sdk-image就是自己编译出来的jdk，可以直接用了。至于其他目录下的内容，各位自己琢磨吧。现在来说下ALLOW_DOWNLOADS=true引起的问题。但是遇到下载很久的包总共有三个：jaxp145_01.zip、jdk7-jaf-2010_08_19.zip、jdk7-jaxws2_2_4-b03-2011_05_27.zip之前说过可以修改编译脚本跳过下载并且用我们已经下载好的，但是实际编译过程中，这三个包对应的的编译脚本是动态生成的，所以只能等到他卡在那了，才能停下来并找到脚本修改之。因此因为这三个包，总共需要停3次。，比起一直卡在那好太多了。假设编译的是普通版本，即非DEBUG和非FASTDEBUG。下面以jaxp145_01.zip为例子讲一下怎么修改对应脚本：脚本所在位置：openjdk根目录/build/macosx-universal/jaxp/build/xml_generated/build-drop-jaxp_src.xml
㈣ JDK7.0 与 JDK6.0 区别 及 JDK7的新特性
JDK7.0和JDK6.0有什么区别？
jdk7是模块化程序,模块间的依赖性变小了.jdk的好多功能间有相互依赖性,导致一个配置不对,好多不能用.举例来说：假设你正使用Logging API（java.util.logging)），Logging需要NIO和JMX，JMX需要JavaBeans, JNDI, RMI和CORBA，JNDI需要java.applet.Applet而且JavaBeans依赖AWT.
JDK7 新特性：
JSR203:JDK中会更多的IO API（“NIO.2”）访问文件系统与之前的JDK中通过java.io.File访问文件的方式不同，JDK7将通过java.nio.file包中的类完成。JDK7会使用java.nio.file.Path类来操作任何文件系统中的文件。（这里说的任何文件系统指的是可以使用任何文件存储方式的文件系统）
示例：
Java7之前
File file = new File(“some_file”);
使用Java7
Path path = Paths.get(“some_file”);
在File类中加入了新的方法toPath()，可以方便的转换File到Path
Path path = new File(“some_file”).toPath();
Socket通道绑定和配置在JDK7中面向通道的网络编程也得以更新！JDK7中可以直接绑定通道的socket和直接操作socket属性。JDK7提供了平台socket属性和指定实现的socket属性。
JDK7加入了一个新的字节通道类，SeekableByteChannel
NetworkChannel是面向网络通道编程模块中的又一个新的超接口。利用它可以方便的绑定通道socket，并且方便设置和获取socket的属性。
MulticastChannel接口方便创建IP协议多播。多播实现直接绑定到本地的多播设备。
灵活的异步I/O可以通过真正的异步I/O，在不同的线程中运行数以万计的流操作！JKD7提供了对文件和socket的异步操作。一些JDK7中的新通道：
AsynchronousFileChannel：异步文件通道可以完成对文件的异步读写操作。
AsynchronouseSocketChannel：Socket中的一个简单异步通道，方法是异步的并且支持超时。
：异步的ServerSocket
AsynchronousDatagramChannel：基于数据包的异步socket
JSR292:Java平台中的动态编程语言Da Vinci Machine项目（JSR292）的主旨是扩展JVM支持除Java以外的其它编程语言，尤其是对动态编程语言的支持。所支持的语言必须和Java一样不收到歧视并共同存在。JSR334:Java语言的一些改进OpenJDK项目的创造（JSR334）的主旨是对Java语言进行一些小的改进来提高每天的Java开发人员的工作。这些改进包括：
Switch语句允许使用String类型
支持二进制常量和数字常量中可以使用下划线
使用一个catch语言来处理多种异常类型
对通用类型实例的创建提供类型推理
Try-with-resources语句来自动关闭资源
JSR119:Java编译器APIJSR199是在JDK6中加入的，主要用来提供调用Java编译器的API。除了提供javac的命令行工具，JSR199提供Java编译器到程序交互的能力。Java编译器API要达到三个目标：
对编译器和其它工具的调用
对结构化的编译信息进行访问
对文件输入输出定制化处理的能力
JSR206:Java XML处理的API （JAXP）JSR206即Java API for XML Processing（JAXP），是Java处理XML文档的一个与实现无关，灵活的API。
JAXP1.3的主要特性包括：
DOM3
内建通过XML Schema进行文档校验的处理器
对XML Schema中的数据类型的实现，在javax.xml.datatype包中。
XSLTC，最快的转换器，也是XSLT处理中的默认引擎。
提供对XInclude的实现。这将会方便我们使用文本和其它已有的XML来创建新的文档，这样可以对文档片段进行重用。
JDK7中会包含JAXP1.3，这个是JAXP的最新实现。
绑定技术（JAXB）JSR222即Java Architecture for XML Binding（JAXB）。JAXB的目的是便于Java程序进行Java类到XML文档的映射。
JAXB2的主要特性：
支持全部的W3C XML Schema特性。（JAXB1.0说明了对于W3C XML Schema中某些特性的不支持）
支持绑定Java到XML文档，通过添加javax.xml.bind.annotation包来控制绑定。
大量减少了对于schema衍生出来的类。
通过JAXP1.3的校验API来提供额外的校验能力。
JDK7中将包括JAXB2.2
JSR224：基于XML的Web服务API（JAX-WS）JSR224即Java API for XML-based Web Services（JAX-WS），是一个基于Annotation标注的编程模型，主要针对Web Service应用和客户端开发。
JAX-WS2的主要特性包括：
对JAXB2.1 API的支持（JSR222）
对Web Services Addressing 1.0的支持
EndpointReference(EPR)的API：创建(BindingProvider.getEndpointReference()，Endpoint.getEndpointReference()，MessageContext.getEndpointReference())
事务处理(使用JAXB2.1绑定W3C EPR到W3CEndpointReference类，使用JAXB Marshall/Unmarshall W3CendpointReference类)
提供友好的API来启用和停止某些特性，例如MTOM特性和Addressing特性
JDK7将包含JAX-WS2.2
可插拔的Annotation处理APIJSR269即Pluggable Annotation-Processing API
从JDK5开始，Annotation标注就成了强大的机制用来标注我们的类、属性和方法。通常Annotation标注是在创建阶段或者运行阶段进行处理的，并获取语义结果。JSR269主要用来定义一套API，允许通过可插拔的API来进行标注处理器的创建。
规范包括一部分的API用来对Java编程语言进行构建，还有就对标注处理器声明和控制运行的部分。
有了程序中的Annotation标注，就需要有标注处理器框架来反射程序的结构。
Annotation处理器会指定他们处理的标注并且更多的处理器可以合作运行。
标注处理器和程序结构的API可以在构建阶段访问。
小的改进java.util.Objects提供了一套9个静态方法。其中两个方法用来检测当前对象是null还是非null。两个方法用来提供生成toString()字符串同时支持null对象。两个用来处理hash的方法。两个方法用来处理equals。最后一个compare方法用来进行比较。Swing JLayer组件JXLayer是一个组件装饰器，提供了用来装饰多个组合组件的方式，并且可以捕获所有鼠标、键盘和FocusEvent的事件，并针对所有的XLayer子组件。这个组件只会对public swing的api起作用，对全局设置没有作用，例如对EventQueue或者RepaintManager。（除了这些，Swing还将在JDK7中提供JXDatePicker和CSS方式样式）并发和集合APIJSR166，并发和集合API提供了灵活的异步处理，并发HashMap，传输队列和轻量级的fork/join框架以及本地线程方式的伪随机数生成器。类加载器体系结构类加载器已经升级到了可以在无等级类加载器拓扑中避免死锁。JDK7中包含了一个对于多线程自定义类加载器的增强实现，名字为具有并行能力的类加载器。使用平行能力的类加载器加载class，会同步到类加载器和类名。Locale类的改进Java Locale避免由于小的变化导致数据丢失。除此，Locale应该提供更多的特性，例如IETF BCP 47和UTR 35（CLDR/LDML）。分离用户Locale和用户接口LocaleJDK7分离了UI语言的locale和格式化locale，这个已经在Vista之后的windows系统中实现了。严格的类文件检测通过JavaSE6的规范，version51（SE7）的类文件和之后的版本必须通过类型检测来检验。对于老的推理验证VM不可以宕掉Elliptic-Curve
Cryptography (ECC)椭圆曲线加密
从JDK7开始，Java提供对标准的ECC算法的灵活实现（基于椭圆曲线的公钥加密算法）Swing中的Nimbus外观Nimbus是JDS（Java Desktop System）中的新外观。这个也是Solaris11的GTK主题Java2D中的XRender PipelineJDK7中加入了基于X11 XRender扩展的Java2D图形管道。这将提供更多的对于当前先进的GPUs访问的功能。TLS1.2TLS (Transport Layer Security)是一个用在Internet上的数据传输安全协议，用来避免监听、引诱和消息伪造。TLS的主要目的是提供两个应用间通信的隐私和数据完整。TLS是RFC5246标准，在JDK7中提供1.2JDBC4.0/4.1JDBC4.1特性只在JDK7或者更高版本中存在。JDBC4.1只是对JDBC4.0进行较小的改动。关于一些JDBC4.0/4.1的特性：
数据源—Derby包括了对于javax.sql.DataSource的新的实现
JDBC驱动自动加载—应用不必在通过Class.forName()方法来加载数据库驱动了。取而代之的是DriverManager会根据应用请求连接的情况，自动查找到合适的JDBC驱动。
包装—这是JDBC4.0中的新的概念，主要是通过这种机制可以让应用获取的厂商提供的标准JDBC对象实现，例如Connections，Statements和ResultSets。
Statement事件—连接池可以监听Statement的关闭和错误时间。addStatementEventListener和removeStatementEventListener被加入到了javax.sql.PooledConnection
JDK7提供了JDBC4.1全部的支持
透明窗体和异形窗体为了6u10版本的图形处理，JDK提供了透明效果的支持（简单透明和像素透明）并且提供了对于异形窗体的支持（可以将窗体设置成任意形状），轻重混合并且增强了AWT安全警告。透明效果和异形窗体是通过com.sun.awt.AWTUtilities类实现的。Unicode6.0Unicode6.0提供了诸如2.088字符集、对已经存在字符集的属性改进、格式化改进以及新的属性和数据文件。
JDK7已经更新到对Unicode6.0的支持。
要来关闭URLClassLoader的方法
对JMX代理和MBeans的改进
通过URLClassLoader，应用可以通过URL搜索路径来加载类和资源。JKD7提供了close()新方法来帮助URLClassLoader清理资源。
这个改进来至于JRockit，可以方便连接平台。MBean服务器可以通过防火墙提供一套MBeans，这些暴露了VM中的一些内部操作的信息
新的垃圾回收器JDK7提供了新的垃圾回收器，针对目前的CMS垃圾回收器，这将会让垃圾回收器有更少的停顿时间和更高的语言效果。改进的JSRJSR901：Java Language Specification（JLS）Java语言计划
JSR901包括了从第一版Java规范到现在为止的所有的变化、说明和补充。Java语言通过JLS规范。
对于JLS的改变通过JSR901进行管理
JDK7将会包括最新的JSR901
JSR924：JVM平台规范
JSR924目的是维护Java虚拟机规范的变化，其中第二版是为了J2SE1.5的。
Java SE API
JavaSE APIs保持着对例行维护和小范围改进的加入计划的记录
延期到JDK8或者之后的规范
JSR294：Java语言和虚拟机对模块编程技术的支持—当前JSR主要的目的是提供在编译期和运行期的模块编程支持
JSR308：对于Java类型的Annotation注释—这将是对于当前注释符号系统的扩展，将允许我们在类型中出现注释符号。
JSR296：Swing应用框架—主旨是消除Swing编程中的模板代码并且提供Swing程序更加简单的结构。
模块化—提供一个明确的、简单的、低级别的模块系统，主要目的是将JDK模块化。
JSR TBD：Lambda项目—Lambda表达式（通俗的也称为“闭包“）和对Java编程语言的保护方法
JSR TBD：对于集合支持的语言—常量表达式对于lists、sets和maps的迭代以及通过索引符号对lists和maps的访问。
Swing JDatePicker组件—添加SwingLabs JXDatePicker组件到平台。
㈤ 2021-01-18：java中，HashMap的创建流程是什么
jdk1.7创建流程：
三种构造器。
1.初始容量不能为负数，默认16。
2.初始容量大于最大容量时，初始容量等于最大容量。
3.负载因子必须大于0，默认0.75。
4.根据初始容量算出容量，容量是2的n次幂。
5.设置负载因子loadFactor 。
6.设置容量极限threshold。
7.设置table数组。
8.调用init()空方法。
参数为集合的构造器。
1.调用有两个参数的构造器。
2.inflateTable方法。初始化table数组。
3.putAllForCreate方法。遍历参数，放入当前map。
jdk1.8创建流程：
两种构造器。
1.初始容量不能为负数，默认16。
2.初始容量大于最大容量时，初始容量等于最大容量。
3.负载因子必须大于0，默认0.75。
4.设置负载因子loadFactor 。
5.设置容量极限threshold，调用tableSizeFor方法，大于initialCapacity的最小的二次幂数值 。。
无参构造器。
1.只设置了负载因子，其他什么都没做。
参数为集合的构造器。
1.设置负载因子。
2.putMapEntries方法。遍历参数，放入当前map。
***
[HashMap源码分析（jdk7）](https://www.cnblogs.com/fsmly/p/11278561.html)
[JDK1.8中的HashMap实现](https://www.cnblogs.com/doufuyu/p/10874689.html)
[评论](https://user.qzone.qq.com/3182319461/blog/1610924590)
㈥ java7和java8对hashmap做了哪些优化
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。
代码块2
public 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两种情况。
㈦ 求java里面的Hash<Map>的用法和基本解释，谢谢
HashMap 和 HashSet 是 Java Collection Framework 的两个重要成员，其中 HashMap 是 Map 接口的常用实现类，HashSet 是 Set 接口的常用实现类。虽然 HashMap 和 HashSet 实现的接口规范不同，但它们底层的 Hash 存储机制完全一样，甚至 HashSet 本身就采用 HashMap 来实现的。
通过 HashMap、HashSet 的源代码分析其 Hash 存储机制
实际上，HashSet 和 HashMap 之间有很多相似之处，对于 HashSet 而言，系统采用 Hash 算法决定集合元素的存储位置，这样可以保证能快速存、取集合元素；对于 HashMap 而言，系统 key-value 当成一个整体进行处理，系统总是根据 Hash 算法来计算 key-value 的存储位置，这样可以保证能快速存、取 Map 的 key-value 对。
在介绍集合存储之前需要指出一点：虽然集合号称存储的是 Java 对象，但实际上并不会真正将 Java 对象放入 Set 集合中，只是在 Set 集合中保留这些对象的引用而言。也就是说：Java 集合实际上是多个引用变量所组成的集合，这些引用变量指向实际的 Java 对象。
集合和引用
就像引用类型的数组一样，当我们把 Java 对象放入数组之时，并不是真正的把 Java 对象放入数组中，只是把对象的引用放入数组中，每个数组元素都是一个引用变量。
HashMap 的存储实现
当程序试图将多个 key-value 放入 HashMap 中时，以如下代码片段为例：
Java代码
HashMap<String , Double> map = new HashMap<String , Double>();
map.put("语文" , 80.0);
map.put("数学" , 89.0);
map.put("英语" , 78.2);
HashMap 采用一种所谓的“Hash 算法”来决定每个元素的存储位置。
当程序执行 map.put("语文" , 80.0); 时，系统将调用"语文"的 hashCode() 方法得到其 hashCode 值——每个 Java 对象都有 hashCode() 方法，都可通过该方法获得它的 hashCode 值。得到这个对象的 hashCode 值之后，系统会根据该 hashCode 值来决定该元素的存储位置。
我们可以看 HashMap 类的 put(K key , V value) 方法的源代码：
Java代码
public V put(K key, V value)
{
// 如果 key 为 null，调用 putForNullKey 方法进行处理
if (key == null)
return putForNullKey(value);
// 根据 key 的 keyCode 计算 Hash 值
int hash = hash(key.hashCode());
// 搜索指定 hash 值在对应 table 中的索引
int i = indexFor(hash, table.length);
// 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素
for (Entry<K,V> e = table[i]; e != null; e = e.next)
{
Object k;
// 找到指定 key 与需要放入的 key 相等（hash 值相同
// 通过 equals 比较放回 true）
if (e.hash == hash && ((k = e.key) == key
|| key.equals(k)))
{
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 如果 i 索引处的 Entry 为 null，表明此处还没有 Entry
modCount++;
// 将 key、value 添加到 i 索引处
addEntry(hash, key, value, i);
return null;
}
上面程序中用到了一个重要的内部接口：Map.Entry，每个 Map.Entry 其实就是一个 key-value 对。从上面程序中可以看出：当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。这也说明了前面的结论：我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。
上面方法提供了一个根据 hashCode() 返回值来计算 Hash 码的方法：hash()，这个方法是一个纯粹的数学计算，其方法如下：
Java代码
static int hash(int h)
{
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(int h) 方法所计算得到的 Hash 码值总是相同的。接下来程序会调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处。indexFor(int h, int length) 方法的代码如下：
Java代码
static int indexFor(int h, int length)
{
return h & (length-1);
}
这个方法非常巧妙，它总是通过 h &(table.length -1) 来得到该对象的保存位置——而 HashMap 底层数组的长度总是 2 的 n 次方，这一点可参看后面关于 HashMap 构造器的介绍。
当 length 总是 2 的倍数时，h & (length-1) 将是一个非常巧妙的设计：假设 h=5,length=16, 那么 h & length - 1 将得到 5；如果 h=6,length=16, 那么 h & length - 1 将得到 6 ……如果 h=15,length=16, 那么 h & length - 1 将得到 15；但是当 h=16 时 , length=16 时，那么 h & length - 1 将得到 0 了；当 h=17 时 , length=16 时，那么 h & length - 1 将得到 1 了……这样保证计算得到的索引值总是位于 table 数组的索引之内。
根据上面 put 方法的源代码可以看出，当程序试图将一个 key-value 对放入 HashMap 中时，程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置：如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。如果这两个 Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有 Entry 的 value，但 key 不会覆盖。如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链，而且新添加的 Entry 位于 Entry 链的头部——具体说明继续看 addEntry() 方法的说明。
当向 HashMap 中添加 key-value 对，由其 key 的 hashCode() 返回值决定该 key-value 对（就是 Entry 对象）的存储位置。当两个 Entry 对象的 key 的 hashCode() 返回值相同时，将由 key 通过 eqauls() 比较值决定是采用覆盖行为（返回 true），还是产生 Entry 链（返回 false）。
上面程序中还调用了 addEntry(hash, key, value, i); 代码，其中 addEntry 是 HashMap 提供的一个包访问权限的方法，该方法仅用于添加一个 key-value 对。下面是该方法的代码：
Java代码
void addEntry(int hash, K key, V value, int bucketIndex)
{
// 获取指定 bucketIndex 索引处的 Entry
Entry<K,V> e = table[bucketIndex]; // ①
// 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
// 如果 Map 中的 key-value 对的数量超过了极限
if (size++ >= threshold)
// 把 table 对象的长度扩充到 2 倍。
resize(2 * table.length); // ②
}
上面方法的代码很简单，但其中包含了一个非常优雅的设计：系统总是将新添加的 Entry 对象放入 table 数组的 bucketIndex 索引处——如果 bucketIndex 索引处已经有了一个 Entry 对象，那新添加的 Entry 对象指向原有的 Entry 对象（产生一个 Entry 链），如果 bucketIndex 索引处没有 Entry 对象，也就是上面程序①号代码的 e 变量是 null，也就是新放入的 Entry 对象指向 null，也就是没有产生 Entry 链。
JDK 源码
在 JDK 安装目录下可以找到一个 src.zip 压缩文件，该文件里包含了 Java 基础类库的所有源文件。只要读者有学习兴趣，随时可以打开这份压缩文件来阅读 Java 类库的源代码，这对提高读者的编程能力是非常有帮助的。需要指出的是：src.zip 中包含的源代码并没有包含像上文中的中文注释，这些注释是笔者自己添加进去的。
Hash 算法的性能选项
根据上面代码可以看出，在同一个 bucket 存储 Entry 链的情况下，新放入的 Entry 总是位于 bucket 中，而最早放入该 bucket 中的 Entry 则位于这个 Entry 链的最末端。
上面程序中还有这样两个变量：
* size：该变量保存了该 HashMap 中所包含的 key-value 对的数量。
* threshold：该变量包含了 HashMap 能容纳的 key-value 对的极限，它的值等于 HashMap 的容量乘以负载因子（load factor）。
从上面程序中②号代码可以看出，当 size++ >= threshold 时，HashMap 会自动调用 resize 方法扩充 HashMap 的容量。每扩充一次，HashMap 的容量就增大一倍。
上面程序中使用的 table 其实就是一个普通数组，每个数组都有一个固定的长度，这个数组的长度就是 HashMap 的容量。HashMap 包含如下几个构造器：
* HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。
* HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。
* HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。
当创建一个 HashMap 时，系统会自动创建一个 table 数组来保存 HashMap 中的 Entry，下面是 HashMap 中一个构造器的代码：
Java代码
// 以指定初始化容量、负载因子创建 HashMap
public HashMap(int initialCapacity, float loadFactor)
{
// 初始容量不能为负数
if (initialCapacity < 0)
throw new IllegalArgumentException(
"Illegal initial capacity: " +
initialCapacity);
// 如果初始容量大于最大容量，让出示容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 负载因子必须大于 0 的数值
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException(
loadFactor);
// 计算出大于 initialCapacity 的最小的 2 的 n 次方值。
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
this.loadFactor = loadFactor;
// 设置容量极限等于容量 * 负载因子
threshold = (int)(capacity * loadFactor);
// 初始化 table 数组
table = new Entry[capacity]; // ①
init();
}
上面代码中粗体字代码包含了一个简洁的代码实现：找出大于 initialCapacity 的、最小的 2 的 n 次方值，并将其作为 HashMap 的实际容量（由 capacity 变量保存）。例如给定 initialCapacity 为 10，那么该 HashMap 的实际容量就是 16。
程序①号代码处可以看到：table 的实质就是一个数组，一个长度为 capacity 的数组。
对于 HashMap 及其子类而言，它们采用 Hash 算法来决定集合中元素的存储位置。当系统开始初始化 HashMap 时，系统会创建一个长度为 capacity 的 Entry 数组，这个数组里可以存储元素的位置被称为“桶（bucket）”，每个 bucket 都有其指定索引，系统可以根据其索引快速访问该 bucket 里存储的元素。
无论何时，HashMap 的每个“桶”只存储一个元素（也就是一个 Entry），由于 Entry 对象可以包含一个引用变量（就是 Entry 构造器的的最后一个参数）用于指向下一个 Entry，因此可能出现的情况是：HashMap 的 bucket 中只有一个 Entry，但这个 Entry 指向另一个 Entry ——这就形成了一个 Entry 链。如图 1 所示：
图 1. HashMap 的存储示意
HashMap 的读取实现
当 HashMap 的每个 bucket 里存储的 Entry 只是单个 Entry ——也就是没有通过指针产生 Entry 链时，此时的 HashMap 具有最好的性能：当程序通过 key 取出对应 value 时，系统只要先计算出该 key 的 hashCode() 返回值，在根据该 hashCode 返回值找出该 key 在 table 数组中的索引，然后取出该索引处的 Entry，最后返回该 key 对应的 value 即可。看 HashMap 类的 get(K key) 方法代码：
Java代码
public V get(Object key)
{
// 如果 key 是 null，调用 getForNullKey 取出对应的 value
if (key == null)
return getForNullKey();
// 根据该 key 的 hashCode 值计算它的 hash 码
int hash = hash(key.hashCode());
// 直接取出 table 数组中指定索引处的值，
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
// 搜索该 Entry 链的下一个 Entr
e = e.next) // ①
{
Object k;
// 如果该 Entry 的 key 与被搜索 key 相同
if (e.hash == hash && ((k = e.key) == key
|| key.equals(k)))
return e.value;
}
return null;
}
从上面代码中可以看出，如果 HashMap 的每个 bucket 里只有一个 Entry 时，HashMap 可以根据索引、快速地取出该 bucket 里的 Entry；在发生“Hash 冲突”的情况下，单个 bucket 里存储的不是一个 Entry，而是一个 Entry 链，系统只能必须按顺序遍历每个 Entry，直到找到想搜索的 Entry 为止——如果恰好要搜索的 Entry 位于该 Entry 链的最末端（该 Entry 是最早放入该 bucket 中），那系统必须循环到最后才能找到该元素。
归纳起来简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据 Hash 算法来决定其存储位置；当需要取出一个 Entry 时，也会根据 Hash 算法找到其存储位置，直接取出该 Entry。由此可见：HashMap 之所以能快速存、取它所包含的 Entry，完全类似于现实生活中母亲从小教我们的：不同的东西要放在不同的位置，需要时才能快速找到它。
当创建 HashMap 时，有一个默认的负载因子（load factor），其默认值为 0.75，这是时间和空间成本上一种折衷：增大负载因子可以减少 Hash 表（就是那个 Entry 数组）所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的的操作（HashMap 的 get() 与 put() 方法都要用到查询）；减小负载因子会提高数据查询的性能，但会增加 Hash 表所占用的内存空间。
掌握了上面知识之后，我们可以在创建 HashMap 时根据实际需要适当地调整 load factor 的值；如果程序比较关心空间开销、内存比较紧张，可以适当地增加负载因子；如果程序比较关心时间开销，内存比较宽裕则可以适当的减少负载因子。通常情况下，程序员无需改变负载因子的值。
如果开始就知道 HashMap 会保存多个 key-value 对，可以在创建时就使用较大的初始化容量，如果 HashMap 中 Entry 的数量一直不会超过极限容量（capacity * load factor），HashMap 就无需调用 resize() 方法重新分配 table 数组，从而保证较好的性能。当然，开始就将初始容量设置太高可能会浪费空间（系统需要创建一个长度为 capacity 的 Entry 数组），因此创建 HashMap 时初始化容量设置也需要小心对待。
㈧ HashMap扩容机制
之前写过一篇专门介绍HashMap的文章，反响很不错，不过在留言区问得最多的问题就是HashMap的负载因子初始值为什么是0.75，私下又好好地研究了一番，总结了这篇文章。
本篇文章基于JDK1.8，特在此说明。
OK。下面我们就开始进行分析。
HashMap源码分析（jdk1.8，保你能看懂）
一、负载因子的作用
对于HashMap的研究，我之前一直停留在考虑源码是如何实现的，现在当我重新再来看的时候，才发现，系统默认的各种参数值，才是HashMap的精华所在。
负载因子是和扩容机制有关的，意思是如果当前容器的容量，达到了我们设定的最大值，就要开始执行扩容操作。举个例子来解释，避免小白听不懂：
比如说当前的容器容量是16，负载因子是0.75,16*0.75=12，也就是说，当容量达到了12的时候就会进行扩容操作。
他的作用很简单，相当于是一个扩容机制的阈值。当超过了这个阈值，就会触发扩容机制。HashMap源码已经为我们默认指定了负载因子是0.75。
我截取了部分源码，从这里可以看出，系统默认的负载因子值就是0.75，而且我们还可以在构造方法中去指定。下面我们就正式来分析一下为什么是默认的0.75。
二、原因解释（重点）
我们在考虑HashMap的时候，首先要想到的是HashMap只是一个数据结构，既然是数据结构最主要的就是节省时间和空间。负载因子的作用肯定也是节省时间和空间。为什么节省呢？我们考虑两种极端情况。
1、负载因子是1.0
我们先看HashMap的底层数据结构
我们的数据一开始是保存在数组里面的，当发生了Hash碰撞的时候，就是在这个数据节点上，生出一个链表，当链表长度达到一定长度的时候，就会把链表转化为红黑树。
当负载因子是1.0的时候，也就意味着，只有当数组的8个值（这个图表示了8个）全部填充了，才会发生扩容。这就带来了很大的问题，因为Hash冲突时避免不了的。当负载因子是1.0的时候，意味着会出现大量的Hash的冲突，底层的红黑树变得异常复杂。对于查询效率极其不利。这种情况就是牺牲了时间来保证空间的利用率。
因此一句话总结就是负载因子过大，虽然空间利用率上去了，但是时间效率降低了。
2、负载因子是0.5
负载因子是0.5的时候，这也就意味着，当数组中的元素达到了一半就开始扩容，既然填充的元素少了，Hash冲突也会减少，那么底层的链表长度或者是红黑树的高度就会降低。查询效率就会增加。
但是，兄弟们，这时候空间利用率就会大大的降低，原本存储1M的数据，现在就意味着需要2M的空间。
一句话总结就是负载因子太小，虽然时间效率提升了，但是空间利用率降低了。
3、负载因子0.75
经过前面的分析，基本上为什么是0.75的答案也就出来了，这是时间和空间的权衡。当然这个答案不是我自己想出来的。答案就在源码上，我们可以看看：
大致意思就是说负载因子是0.75的时候，空间利用率比较高，而且避免了相当多的Hash冲突，使得底层的链表或者是红黑树的高度比较低，提升了空间效率。
OK，写到这答案基本上就出来了，一句话能总结的写成了一篇文章。如有问题，还请批评指正。
㈨ jdk1.8 HashMap扩容原理解析
最近看面试题有聊到hashmap扩容，追本溯源，追到了1.8版本resize方法做的核心改进，找了资料一直也看不太懂，最后苦苦冥思总算弄懂了，在此做下笔记，也是做下分享，分享给同样云里雾里的码友。时间有限，所以研究的不全面，后期会陆续更新。
在讲解源码之前还是要先做下铺垫。。。
&运算是二进制位运算符中的一种
简单来说
------------------------------------------------------
1 & 1 = 1 1 & 0 = 0
0 & 1 = 0 0 & 0 = 0
------------------------------------------------------
两个操作数都为1，结果才为1，否则为0
说到这里，再说一下与运算很重要的一个技巧：取位
举个例子，我们有这样一个二进制 1010 0101
我们想取出看看第3位是0还是1，怎么做呢，我们这样
为了方便理解，转换一下
------------------------------------------------------
------------------------------------------------------
我们看，下面只有第三位为1，其他全部为0，那么上面对应的位置肯定也为0
而第三位为1，那么结果就取决于上面对应第三位是0还是1了
如果是1 那么 1 & 1 = 1
如果是0 那么 0 & 0 = 0
如此我们计算上面的结果
那如果是取第四位呢，同理
------------------------------------------------------
------------------------------------------------------
结果显而易见
hashmap的数组长度，一定是2的次幂，其扩容就是长度直接扩2倍。
当散列表很大，节点很拥挤，链表会大量的出现，但是链表的查询速率很低，若节点数达到了加载因子的扩容条件，
——————————————————
注：虽然链表长度大于等于8会转化成红黑树，但是我们还是要尽量减少链表出现的概率，要使得节点更加分散。于是有了加载因子。0.75是很好的一个折中，因为扩容是很消耗资源的。
——————————————————
这时为了减少hash冲突得情况，减少链表出现的概率，我们得对hashmap进行扩容，并对node节点进行一次重新分布，使其分布得更均匀一些，怎么做呢。
我们看，假设这个hashmap的情况现在是这样
假设，它很挤了，需要扩容，那么扩容变成这样，再加一倍长度变成32
仅仅是这样还不行，否则没有最大限度利用扩容所做的牺牲(资源消耗)，我们需要对node节点进行重新分布
怎么做呢，我们可以拿一部分节点，放到扩容出来的空间上，也就是
举个例子，假设我们把2和6拿过去，那就是变成这样
如此一来，原本的节点顺序没有发生太大的改动，新的空间得到了利用，节点分布也更均匀，链表出现的概率也更少，计算也更加简单
这就是jdk1.8的hashmap改动的巧妙之处。
这里还有一个问题，我们拿哪一部分，换句话说，怎么决定这个节点是不变还是移动到新的位置
为了降低hash冲突，我们得让它自己决定，我们要充分利用随机的特性，随机才会更加均匀
下面看源码实现
我们都知道，hashmap的初始默认容量为16，换成二进制就是 1 0000 （16=2^5-1）
但是，数组下标是从0开始的，那么16-1=15，换成二进制就是 0 1111
那么扩容一次呢，长度会变成32，那么32-1=31 ，换成二进制就是 01 1111
就是在1111的基础上加了一位而已，我们知道，node节点是不变的，那么它的hash也不会变。
假设在经过扰动以后 hash = 1010 0101
对16-1进行与运算
——————————————————
------------------------------------------------
结果自然是0101 = 2^2 + 2^0 = 4 + 1 = 5
在扩容后，长度32，31的二进制是0001 1111
对比原来的hash
———————————————————
----------------------------------------------------
分析，我们便可以知道，hash是随机的，那么其第5位也是随机的
那我们只要把第5位取出来，看看，
结合第一节，我们只需这样做
转换一下
—————————————————
1010 0101
0001 0000 （16）
--------------------------------------------
结果为0，所以这个节点不移动。
那如果是1011 0101，那么这个节点就要移动
标黄的地方就是整个的精髓所在，e是当前判断是否要移动的节点，oldCap就是原数组长度。
今天先到这里，如有疑问，可在下方评论，我后续更新补充。本文若有不妥之处，欢迎指正。谢谢观看。
㈩ java7和java8对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中对于