Ⅰ 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组件到平台。
Ⅱ jdk7 Map<String, Integer> map = {"key":1}; List<String> list = ["item"];
你去网络一下关键字“关于网传JDK1.7语法层次支持集合的问题”，会找到csdn上面的一篇博文，看了你就明白了。
网上有人以讹传讹，其实jdk7甚至到jdk8都根本没有实现这样的特性，我都试过了，写的语法没错，可是jdk7不支持而已。
Ⅲ 怎样查看JDK源码实现
1打开eclipse，点 “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",结束
Ⅳ jdk源代码在哪里下啊
在jdk的安装目录下，有一个src.zip，这里面就是源代码
当然，这个源代码并不全，有些类的源代码是没有的。不过除非你要看非常深入的jdk代码，一般这点就足够了。
Ⅳ jdk的哪些源码适合阅读！！！！
我觉得有这么几个不错，说给你听听。如果你是初学者的话，java集合框架，比如hashmap ,hashtable,arraylist这些代表数据结构的类。这个可以学到优雅的内部类的设计，如何做多线程同步，代码重构堪称典范。java的io包，学习一下他是如何使用装饰器模式的。 还有java的logging包的代码，这个很简单，练手用最合适了。
Ⅵ java jdk1.7源码包,和经典资料
jdk 源码 在你下jdk1.7 并安装的时候就有 在jdk 里 就有src的压缩包 里面就是源码
至于资料 看API文档吧..这没啥资料 一般 源码都能看懂 也没啥难得..
Ⅶ 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)
Ⅷ java：哪里能看到JDK的源代码
我认为你说的是Java的源码，JDK是一个编译器
Java源码在Javajdk1.8.0_60src.zip中
如果你要的真的是Jdk的源码的话，Orccle官网应该会有
Ⅸ 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两种情况。