jdk1.4 和1.5的所有区别，你知道多少？

Question

如题，要分有加

Answer 1

最明显的区别就是
1.5增加了泛型支持和for的新规则

Answer 2

改变了很多，jpa，泛型，循环便利，垃圾回收器。 

Answer 3

还有流的操作，nio包的引入，阻塞与非阻塞socket。还有一些集合的锁与并发安全的问题。改变的东西太多了

Answer 4

没多大区别,只要你注意别用那些过时的方法就行,若是新版本加的或有改变的方法,docs里会说的,在方法解释下面 jdk6.0将会有很大变化 
增强的for循环 
为了迭代集合和数组，增强的for循环提供了一个简单、兼容的语法。有两点值得一提： 
Init表达式 
在循环中，初始化表达式只计算一次。这意味着您通常可以移除一个变量声明。在这个例子中，我们必须创建一个整型数组来保存computeNumbers()的结果，以防止每一次循环都重新计算该方法。您可以看到，下面的代码要比上面的代码整洁一些，并且没有泄露变量numbers： 
未增强的For： int sum = 0; Integer[] numbers = computeNumbers(); for (int i=0; i < numbers.length ; i++) sum += numbers[i]; 增强后的For： int sum = 0; 
for ( int number: computeNumbers() ) sum += number; 局限性 
有时需要在迭代期间访问迭代器或下标，看起来增强的for循环应该允许该操作，但事实上不是这样，请看下面的例子： 
for (int i=0; i < numbers.length ; i++) { if (i != 0) System.out.print(","); System.out.print(numbers[i]); } 我们希望将数组中的值打印为一个用逗号分隔的清单。我们需要知道目前是否是第一项，以便确定是否应该打印逗号。使用增强的for循环是无法获知这种信息的。我们需要自己保留一个下标或一个布尔值来指示是否经过了第一项。 这是另一个例子： 
for (Iterator<integer> it = n.iterator() ; it.hasNext() ; ) if (it.next() < 0) it.remove(); 
在此例中，我们想从整数集合中删除负数项。为此，需要对迭代器调用一个方法，但是当使用增强的for 循环时，迭代器对我们来说是看不到的。因此，我们只能使用Java 5之前版本的迭代方法。 顺便说一下，这里需要注意的是，由于Iterator是泛型，所以其声明是Iterator<Integer>。许多人都忘记了这一点而使用了Iterator的原始格式。 没多大区别,只要你注意别用那些过时的方法就行,若是新版本加的或有改变的方法,docs里会说的,在方法解释下面 jdk6.0将会有很大变化 
增强的for循环 
为了迭代集合和数组，增强的for循环提供了一个简单、兼容的语法。有两点值得一提： 
Init表达式 
在循环中，初始化表达式只计算一次。这意味着您通常可以移除一个变量声明。在这个例子中，我们必须创建一个整型数组来保存computeNumbers()的结果，以防止每一次循环都重新计算该方法。您可以看到，下面的代码要比上面的代码整洁一些，并且没有泄露变量numbers： 
未增强的For： int sum = 0; Integer[] numbers = computeNumbers(); for (int i=0; i < numbers.length ; i++) sum += numbers[i]; 增强后的For： int sum = 0; 
for ( int number: computeNumbers() ) sum += number; 局限性 
有时需要在迭代期间访问迭代器或下标，看起来增强的for循环应该允许该操作，但事实上不是这样，请看下面的例子： 
for (int i=0; i < numbers.length ; i++) { if (i != 0) System.out.print(","); System.out.print(numbers[i]); } 我们希望将数组中的值打印为一个用逗号分隔的清单。我们需要知道目前是否是第一项，以便确定是否应该打印逗号。使用增强的for循环是无法获知这种信息的。我们需要自己保留一个下标或一个布尔值来指示是否经过了第一项。 这是另一个例子： 
for (Iterator<integer> it = n.iterator() ; it.hasNext() ; ) if (it.next() < 0) it.remove(); 
在此例中，我们想从整数集合中删除负数项。为此，需要对迭代器调用一个方法，但是当使用增强的for 循环时，迭代器对我们来说是看不到的。因此，我们只能使用Java 5之前版本的迭代方法。 顺便说一下，这里需要注意的是，由于Iterator是泛型，所以其声明是Iterator<Integer>。许多人都忘记了这一点而使用了Iterator的原始格式。 注释 
注释处理是一个很大的话题。因为本文只关注核心的语言特性，所以我们不打算涵盖它所有的可能形式和陷阱。 我们将讨论内置的注释（SuppressWarnings，Deprecated和Override）以及一般注释处理的局限性。 Suppress Warnings 
该注释关闭了类或方法级别的编译器警告。有时候您比编译器更清楚地知道，代码必须使用一个被否决的方法或执行一些无法静态确定是否类型安全的动作，而使用： 
@SuppressWarnings("deprecation") public static void selfDestruct() { Thread.currentThread().stop(); } 这可能是内置注释最有用的地方。遗憾的是，1.5.0_04的javac不支持它。但是1.6支持它，并且Sun正在努力将其向后移植到1.5中。 
Eclipse 3.1中支持该注释，其他IDE也可能支持它。这允许您把代码彻底地从警告中解脱出来。如果在编译时出现警告，可以确定是您刚刚把它添加进来——以帮助查看那些可能不安全的代码。随着泛型的添加，它使用起来将更趁手。 Deprecated 
遗憾的是，Deprecated没那么有用。它本来旨在替换@deprecated javadoc标签，但是由于它不包含任何字段，所以也就没有方法来建议deprecated类或方法的用户应该使用什么做为替代品。大多数用法都同时需要javadoc标签和这个注释。 Override 
Override表示，它所注释的方法应该重写超类中具有相同签名的方法： 
@Override public int hashCode() { ... } 看上面的例子，如果没有在hashCode中将“C”大写，在编译时不会出现错误，但是在运行时将无法像期望的那样调用该方法。通过添加Override标签，编译器会提示它是否真正地执行了重写。 
在超类发生改变的情况中，这也很有帮助。如果向该方法中添加一个新参数，而且方法本身也被重命名了，那么子类将突然不能编译，因为它不再重写超类的任何东西。 其它注释 
注释在其他场景中非常有用。当不是直接修改行为而是增强行为时，特别是在添加样板代码的情况下，注释在诸如EJB和Web services这样的框架中运行得非常好。 
注释不能用做预处理器。Sun的设计特别预防了完全因为注释而修改类的字节码。这样可以正确地理解该语言的成果，而且IDE之类的工具也可以执行深入的代码分析和重构之类的功能。 
注释不是银弹。第一次遇到的时候，人们试图尝试各种技巧。请看下面这个从别人那里获得的建议： 
public class Foo { 
@Property 
private int bar; } 其思想是为私有字段bar自动创建getter和setter方法。遗憾的是，这个想法有两个失败之处：1)它不能运行，2)它使代码难以阅读和处理。 它是无法实现的，因为前面已经提到了，Sun特别阻止了对出现注释的类进行修改。 
即使是可能的，它也不是一个好主意，因为它使代码可读性差。第一次看到这段代码的人会不知道该注释创建了方法。此外，如果将来您需要在这些方法内部执行一些操作，注释也是没用的。 总之，不要试图用注释去做那些常规代码可以完成的事情。 枚举 
enum非常像public static final int声明，后者作为枚举值已经使用了很多年。对int所做的最大也是最明显的改进是类型安全——您不能错误地用枚举的一种类型代替另一种类型，这一点和int不同，所有的int对编译器来说都是一样的。除去极少数例外的情况，通常都应该用enum实例替换全部的枚举风格的int结构。 
枚举提供了一些附加的特性。EnumMap和EnumSet这两个实用类是专门为枚举优化的标准集合实现。如果知道集合只包含枚举类型，那么应该使用这些专门的集合来代替HashMap或HashSet。 
大部分情况下，可以使用enum对代码中的所有public static final int做插入替换。它们是可比的，并且可以静态导入，所以对它们的引用看起来是等同的，即使是对于内部类（或内部枚举类型）。注意，比较枚举类型的时候，声明它们的指令表明了它们的顺序值。 “隐藏的”静态方法 
两个静态方法出现在所有枚举类型声明中。因为它们是枚举子类上的静态方法，而不是Enum本身的方法，所以它们在java.lang.Enum的javadoc中没有出现。 
第一个是values()，返回一个枚举类型所有可能值的数组。 
第二个是valueOf()，为提供的字符串返回一个枚举类型，该枚举类型必须精确地匹配源代码声明。 
方法 
关于枚举类型，我们最喜欢的一个方面是它可以有方法。过去您可能需要编写一些代码，对public static final int进行转换，把它从数据库类型转换为JDBC URL。而现在则可以让枚举类型本身带一个整理代码的方法。下面就是一个例子，包括DatabaseType枚举类型的抽象方法以及每个枚举实例中提供的实现： 
public enum DatabaseType { ORACLE { 
public String getJdbcUrl() {...} 
}, MYSQL { 
public String getJdbcUrl() {...} 
}; 
public abstract String getJdbcUrl(); 
} 现在枚举类型可以直接提供它的实用方法。例如： 
DatabaseType dbType = ...; 
String jdbcURL = dbType.getJdbcUrl(); 
要获取URL，必须预先知道该实用方法在哪里。 可变参数(Vararg) 
正确地使用可变参数确实可以清理一些垃圾代码。典型的例子是一个带有可变的String参数个数的log方法： 
Log.log(String code) 
Log.log(String code, String arg) 
Log.log(String code, String arg1, String arg2) 
Log.log(String code, String[] args) 当讨论可变参数时，比较有趣的是，如果用新的可变参数替换前四个例子，将是兼容的： 
Log.log(String code, String... args) 
所有的可变参数都是源兼容的——那就是说，如果重新编译log()方法的所有调用程序，可以直接替换全部的四个方法。然而，如果需要向后的二进制兼容性，那么就需要舍去前三个方法。只有最后那个带一个字符串数组参数的方法等效于可变参数版本，因此可以被可变参数版本替换。 类型强制转换 
如果希望调用程序了解应该使用哪种类型的参数，那么应该避免用可变参数进行类型强制转换。看下面这个例子，第一项希望是String，第二项希望是Exception： 
Log.log(Object... objects) { 
String message = (String)objects[0]; 
if (objects.length > 1) { 
Exception e = (Exception)objects[1]; 
// Do something with the exception 
} 
} 方法签名应该如下所示，相应的可变参数分别使用String和Exception声明： Log.log(String message, Exception e, Object... objects) {...} 
不要使用可变参数破坏类型系统。需要强类型化时才可以使用它。对于这个规则，PrintStream.printf()是一个有趣的例外：它提供类型信息作为自己的第一个参数，以便稍后可以接受那些类型。 协变返回 
协变返回的基本用法是用于在已知一个实现的返回类型比API更具体的时候避免进行类型强制转换。在下面这个例子中，有一个返回Animal对象的Zoo接口。我们的实现返回一个AnimalImpl对象，但是在JDK 1.5之前，要返回一个Animal对象就必须声明。: 
public interface Zoo { 
public Animal getAnimal(); 
} public class ZooImpl implements Zoo { 
public Animal getAnimal(){ 
return new AnimalImpl(); 
} 
} 
协变返回的使用替换了三个反模式： 直接字段访问。为了规避API限制，一些实现把子类直接暴露为字段： ZooImpl._animal 另一种形式是，在知道实现的实际上是特定的子类的情况下，在调用程序中执行向下转换： 
((AnimalImpl)ZooImpl.getAnimal()).implMethod(); 我看到的最后一种形式是一个具体的方法，该方法用来避免由一个完全不同的签名所引发的问题： ZooImpl._getAnimal(); 这三种模式都有它们的问题和局限性。要么是不够整洁，要么就是暴露了不必要的实现细节。 协变 
协变返回模式就比较整洁、安全并且易于维护，它也不需要类型强制转换或特定的方法或字段： 
public AnimalImpl getAnimal(){ 
return new AnimalImpl(); 
} 
使用结果： 
ZooImpl.getAnimal().implMethod(); 

Answer 5

1、泛型的支持
2、for-each
3、枚举
4、可变参数
5、自动装箱和自动拆箱
6、静态类导入

Answer 6

泛型的支持
for-each 
...

Answer 7

1、泛型的支持 
2、for-each 
3、枚举 
4、可变参数 
5、自动装箱和自动拆箱 
6、静态类导入

Answer 8

5.0 新特性
1、泛型ArrayList<Integer> aList = new ArrayList<Integer>();
aList.add(new Integer(1));
Integer myInteger = aList.get(0);//不用类型转换2、增强型 for 循环List<String> strs= getStrs();
for (String str: strs){
    System.out.println(str);
}3、自动装箱与自动拆箱Integer i=4;
Integer ii = new Integer(5);
i = ii;4、静态导入import static java.lang.Math.*;sqrt(pow(x, 2) + pow(y, 2));//不用Math.sqrt()了
5、类型安全的枚举6、C风格的格式化输出
7、可变长参数
public static double sum(double... ds) {
double result = 0d;
for (double d : ds) {
result += d;
}
return result;
}8、Annotation // 这个在框架中应用很多
9、新增 StringBuilder
StringBuffer的轻量级、非线程安全实现
10、Callable 和 Future接口……

Answer 9

楼上诸位说的已经够多了，呵呵，还有一个漏掉的是
用于从控制台输入数据的Scanner类，这个类偶非常喜欢啊，
输入数据特方便……

Answer 10

就是你想把基本类型做为对象使用的时候（比如放入集合中），不用在强制转换了，
JAVA会自动转换

Answer 11

此外拆箱装箱时，对于Integer还要注意，在某些应用的时候
-128～127是比较特殊的

Answer 12

for的新规则和c#中的foreach用起来一样..

Answer 13

最重要的两个：泛型，annotition

Answer 14

增强一：增加for each循环
for(type variable:array)             
{body}for(type variable:arrayList)
{body}增强二：泛型数组列表
ArrayList<Type> arrayList = new ArrayList<Type>();
arrayList.get(i) 增强三：自动打包
5.0                                      1.4
Integer wrapper=n;        Integer wrapper = new Integer(n);
int n = wrapper           int n = wrapper.intvalue();增强四：变量参数列表
5.0                                      1.4
method(other params,p1,p2,p3)      method(other params,new Type[]{p1,p2,p3})增强五：协变的返回类型
5.0                                      1.4
public Employee clone(){...}             public Object clone(){...}
...                                      ...
Employee cloned=e.clone();               Employee cloned = (Employee).eclone();增强六：静态导入增强七：控制台输入
在JDK5.0以前的版本中不，没有Scanner类，需要使用JOpentionPane.showInputDialog替代增强八：格式化输出
多个printf方法
这些是看corejava时看到的

Answer 15

泛型，annotition，增强for （：）循环。

Answer 16

java核心技术的最后总结了一下，很全面的

Answer 17

1.5增加了泛型支持和for的新规则 优化了程序 比如垃圾回收器

Answer 18

看到了一个新的    对字符串的处理String s1 = "a";
String s2 = "b";
s3 = s1+s2;
StringBuffer 会对这个+作处理

Answer 19

8 对，8 对！JPA 是 Java EE 5 中引入的，不是 JDK 1.5 引入的。NIO 和 Socket 在 JDK 1.4 中就存在的。实际上这种问题根本没必要发帖子来提问，在 Sun 的官方网站上，JDK 每个版本的文档说明上都有 Feature and Enhancement 的。

Answer 20

不懂什么意思，首先我不认为我很懒，我觉得有些东西不懂的就要问啊，这个问题也不是我刻意去问的，只是前面面试有问到这个问题，答不上；
我也不知道官网上的jdk文档会有这样的东西，反正我用的是 中文的API文档，我找不到在哪有专门讲1.5与1.4区别的；另外，我看到上面有些人的意见有分歧，可能有的人对这个问题的解释原来是错误的，而现在有人能站出来帮他纠正，我就觉得我的帖子，至少在这一点上是有意义的；你认为呢？也许我应该去更仔细地看书，看文档，但是我只是有问题想问，并不代表我不会去思考，而且，我不知道去刻意的找出1.4和1.5之间的区别对于我初学java是不是有什么意义（不是否定，是确实不知道他的意义所在，我不可能看书的时候，去记着哪个是1.5新出来的，因为我从一开始接触的就是1.5，也许以后看1.6的时候会留意一下，不过现在也没用1.6的jdk和文档）；说的有点多，只是因为今天在面试的时候跟面试官讨论学习方法的时候他也是总说我的这样的学习方法不是很好，当时想解释一下，但是说的可能不是很清楚，在这里就多说两句了。

Answer 21

下面这个链接中有 JDK 5 与 JDK 1.4 所有的增强和不同
http://java.sun.com/j2se/1.5.0/docs/relnotes/features.html顺便也可以找到 JDK 6 相对于 JDK 5 增加了些什么
http://java.sun.com/javase/6/webnotes/features.html

Answer 22

我现在用jdk1.6,听说它不太稳定,是吗