blocks|key|1484630|text|枚举。替换|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1484631|public+static+final+int+CLUBS+=+0;
public+static+final+int+DIAMONDS+=+1;
public+static+final+int+HEARTS+=+2;
public+static+final+int+SPADES+=+3;|code-block|syntax|javascript|1484632|使用|1484633|public+enum+Suit+{+
++CLUBS,+
++DIAMONDS,+
++HEARTS,+
++SPADES+
}|1484634|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Enums. Replacing 

<pre><code>public static final int CLUBS = 0;
public static final int DIAMONDS = 1;
public static final int HEARTS = 2;
public static final int SPADES = 3;
</code></pre>

with

<pre><code>public enum Suit { 
 CLUBS, 
 DIAMONDS, 
 HEARTS, 
 SPADES 
}
</code></pre>

blocks|key|1699555|text|泛型，不再需要创建迭代器来遍历集合中的所有元素。新版本更好，更容易使用，更容易理解。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1699556|编辑：|1699557|之前：|1699558|List+l+=+someList;
Iterator+i+=+l.getIterator();
while+(i.hasNext())+{
++++MyObject+o+=+(MyObject)i.next();
}|code-block|syntax|javascript|1699559|之后|1699560|List<MyObject>+l+=+someList;
for+(MyObject+o+:+l)+{
++++//do+something
}|1699561|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Generics and no longer needing to create an iterator to go through all elements in a collection. The new version is much better, easier to use, and easier to understand.

EDIT:

Before:

<pre><code>List l = someList;
Iterator i = l.getIterator();
while (i.hasNext()) {
 MyObject o = (MyObject)i.next();
}
</code></pre>

After

<pre><code>List&lt;MyObject&gt; l = someList;
for (MyObject o : l) {
 //do something
}
</code></pre>

blocks|key|1699854|text|使用StringBuffer类型的局部变量执行字符串连接。除非需要同步，否则现在建议使用StringBuilder，因为这个类提供了更好的性能(可能是因为它是非同步的)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1699855|entityMap^0|2|C|18|D|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Using local variables of type <code>StringBuffer</code> to perform string concatenation. Unless synchronization is required, it is now recommended to use <code>StringBuilder</code> instead, because this class offers better performance (presumably because it is unsynchronized).

blocks|key|1699793|text|这是我看到的一个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1699794|String.split()与StringTokenizer。|offset|length|style|CODE|1699795|对于新代码，不推荐使用StringTokenizer，但我仍然看到人们在使用它。|1699796|至于兼容性，Sun做出了巨大的努力让Java向后和向前兼容。这部分解释了为什么泛型如此复杂。弃用也被认为有助于简化从旧代码到新代码的转换。|1699797|entityMap^0|0|0|E|F|F|0|B|F|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|M|$]]

Here is one that I see:

<code>String.split()</code> versus <code>StringTokenizer</code>.

<code>StringTokenizer</code> is not recommended for new code, but I still see people use it.

As for compatibility, Sun makes a huge effort to have Java be backwards and forwards compatible. That partially accounts for why generics are so complex. Deprecation is also supposed to help ease transitions from old to new code.

blocks|key|1700201|text|使用Thread而不是Thread的许多其他替代方案的旧代码...如今，我遇到的代码中很少有代码仍然需要使用原始线程。它们最好由一定程度的抽象来服务，特别是Callable/Futures/Executors.。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1700202|请参见：|1700203|java.util.Timer|1700204|javax.swing.Timer|1700205|java.util.concurrent.*|1700206|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/javase/6/docs/api/java/util/concurrent/Callable.html|1|http://java.sun.com/javase/6/docs/api/java/util/concurrent/Future.html|2|http://java.sun.com/javase/6/docs/api/java/util/concurrent/ExecutorService.html|3|http://java.sun.com/javase/6/docs/api/java/util/Timer.html|4|http://java.sun.com/javase/6/docs/api/javax/swing/Timer.html|5|http://java.sun.com/javase/6/docs/api/java/util/concurrent/package-summary.html^0|26|8|0|2F|7|1|2N|9|2|0|0|0|F|3|0|0|H|4|0|0|M|5|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@$A|14|B|15|1|16]|$A|17|B|18|1|19]|$A|1A|B|1B|1|1C]]|C|$]]|$1|D|3|E|5|6|7|1D|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1E|8|@]|9|@$A|1F|B|1G|1|1H]]|C|$]]|$1|H|3|I|5|6|7|1I|8|@]|9|@$A|1J|B|1K|1|1L]]|C|$]]|$1|J|3|K|5|6|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|L|3|-4|5|6|7|1Q|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]|T|$5|O|P|Q|C|$R|U]]|V|$5|O|P|Q|C|$R|W]]|X|$5|O|P|Q|C|$R|Y]]|Z|$5|O|P|Q|C|$R|10]]|11|$5|O|P|Q|C|$R|12]]]]

Older code using Thread instead of the many other alternatives to Thread... these days, very little of the code I run across still needs to use a raw thread. They would be better served by a level of abstraction, particular <a href="http://java.sun.com/javase/6/docs/api/java/util/concurrent/Callable.html" rel="noreferrer">Callable</a>/<a href="http://java.sun.com/javase/6/docs/api/java/util/concurrent/Future.html" rel="noreferrer">Futures</a>/<a href="http://java.sun.com/javase/6/docs/api/java/util/concurrent/ExecutorService.html" rel="noreferrer">Executors</a>.

See:

<a href="http://java.sun.com/javase/6/docs/api/java/util/Timer.html" rel="noreferrer">java.util.Timer</a>

<a href="http://java.sun.com/javase/6/docs/api/javax/swing/Timer.html" rel="noreferrer">javax.swing.Timer</a>

<a href="http://java.sun.com/javase/6/docs/api/java/util/concurrent/package-summary.html" rel="noreferrer">java.util.concurrent.*</a>

blocks|key|1485248|text|VARARGS也很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1485249|例如，您可以使用：|1485250|public+int+add(int...+numbers){
++++int+sum+=+0+;
++++for+(int+i+:+numbers){
++++++++sum%2B=i;
++++}
++++return+sum+;
}|code-block|syntax|javascript|1485251|而不是：|1485252|public+int+add(int+n1,+int+n2,+int+n3,+int+n4)+;|1485253|或|1485254|public+int+add(List<Integer>+numbers)+;|1485255|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

VARARGS can be useful too.

For example, you can use:

<pre><code>public int add(int... numbers){
 int sum = 0 ;
 for (int i : numbers){
 sum+=i;
 }
 return sum ;
}
</code></pre>

instead of:

<pre><code>public int add(int n1, int n2, int n3, int n4) ;
</code></pre>

or

<pre><code>public int add(List&lt;Integer&gt; numbers) ;
</code></pre>

blocks|key|1699917|text|使用类型为Vector的局部变量来保存对象列表。除非需要同步，否则现在建议使用诸如ArrayList之类的列表实现，因为该类提供了更好的性能(因为它是非同步的)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1699918|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Using local variables of type Vector to hold a list of objects. Unless synchronization is required, it is now recommended to use a List implementation such as ArrayList instead, because this class offers better performance (because it is unsynchronized).

blocks|key|1485613|text|格式化打印直到JDK1.5中才被引入。因此，不要使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1485614|String+str+=+"test+"+%2B+intValue+%2B+"+test+"+%2B+doubleValue;|code-block|syntax|javascript|1485615|或使用StringBuilder的等价物，|1485616|一个人可以使用|1485617|String+str+=+String.format("test+%25d+test+%25lg",+intValue,+doubleValue);|1485618|后者的可读性更好，无论是从字符串连接版本还是从字符串构建器版本。尽管如此，我发现人们采用这种风格的速度非常慢。例如，Log4j框架没有使用这一点，尽管我相信这样做会带来很大的好处。|1485619|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Formatted printing was introduced as late as in JDK 1.5. So instead of using:

<pre><code>String str = "test " + intValue + " test " + doubleValue;
</code></pre>

or the equivalent using a StringBuilder,

one can use 

<pre><code>String str = String.format("test %d test %lg", intValue, doubleValue);
</code></pre>

The latter is much more readable, both from the string concatenation and the string builder versions. Still I find that people adopt this style very slowly. Log4j framework for example, doesn't use this, although I believe it would be greatly benefited to do so.

blocks|key|1700007|text|原语和包装器类型之间的显式转换(例如，从Integer到int或反之亦然)，这是从Java1.5开始由自动装箱/拆箱自动处理的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1700008|一个例子是|1700009|Integer+myInteger+=+6;
int+myInt+=+myInteger.intValue();|code-block|syntax|javascript|1700010|可以简单地写成|1700011|Integer+myInteger+=+6;
int+myInt+=+myInteger;|1700012|但要注意NullPointerExceptions+:)|1700013|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Explicit conversion between primitive and wrapper types (e.g. Integer to int or vice versa) which is taken care of automatically by autoboxing/unboxing since Java 1.5.

An example is

<pre><code>Integer myInteger = 6;
int myInt = myInteger.intValue();
</code></pre>

Can simply be written as

<pre><code>Integer myInteger = 6;
int myInt = myInteger;
</code></pre>

But watch out for NullPointerExceptions :)

blocks|key|1699614|text|Q1:嗯，最明显的情况是泛型/类型特定的集合。另一个立即浮现在脑海中的是改进的for循环，我觉得它看起来更干净，更容易理解。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1699615|Q2:一般来说，我一直将have虚拟机与我的应用程序捆绑在一起，用于面向客户的应用程序。这使我们可以使用新的语言特性，而不必担心JVM不兼容。|1699616|如果我没有捆绑JRE，出于兼容性的原因，我可能会坚持使用1.4。|1699617|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Q1: Well, the most obvious situations are in the generics / type specific collections. The other one that immediately springs to mind is the improved for loop, which I feel is a lot cleaner looking and easier to understand.

Q2: In general, I have been bundling the JVM along side of my application for customer-facing apps. This allows us to use new language features without having to worry about JVM incompatibility. 

If I were not bundling the JRE, I would probably stick to 1.4 for compatibility reasons.

blocks|key|1699703|text|从1.5开始的一个简单更改，但有一个小的不同-在访问JFrame的contentPane的Swing+API中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1699704|myframe.getContentPane().add(mycomponent);|code-block|syntax|javascript|1699705|变成了|1699706|myframe.add(mycomponent);|1699707|当然，枚举的引入改变了许多过去使用常量的应用程序的行为方式。|1699708|String.format()极大地改进了字符串操作，并且三元if语句在使代码更易于阅读方面非常有帮助。|1699709|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

A simple change in since 1.5 but makes a small difference - in the Swing API accessing the contentPane of a JFrame:

<pre><code>myframe.getContentPane().add(mycomponent);
</code></pre>

becomes

<pre><code>myframe.add(mycomponent);
</code></pre>

And of course the introduction of Enums has changed the way many applications that used constants in the past behave.

String.format() has greatly improved String manipulation and the ternary if statement is quite helpful in making code easier to read.

blocks|key|1485010|text|泛型集合使编码更具抗虫性。旧的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1485011|Vector+stringVector+=+new+Vector();
stringVector.add("hi");
stringVector.add(528);+//+oops!
stringVector.add(new+Whatzit());++//+Oh+my,+could+spell+trouble+later+on!|code-block|syntax|javascript|1485012|新的：|1485013|ArrayList<String>+stringList+=+new+ArrayList<String>();
stringList.add("hello+again");
stringList.add(new+Whatzit());+//+Won't+compile!|1485014|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Generic collections make coding much more bug-resistant.
OLD:

<pre><code>Vector stringVector = new Vector();
stringVector.add("hi");
stringVector.add(528); // oops!
stringVector.add(new Whatzit()); // Oh my, could spell trouble later on!
</code></pre>

NEW:

<pre><code>ArrayList&lt;String&gt; stringList = new ArrayList&lt;String&gt;();
stringList.add("hello again");
stringList.add(new Whatzit()); // Won't compile!
</code></pre>

blocks|key|1485145|text|使用迭代器：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1485146|List+list+=+getTheList();
Iterator+iter+=+list.iterator()
while+(iter.hasNext())+{
++String+s+=+(String)+iter.next();
++++//+..+do+something
}|code-block|syntax|javascript|1485147|或者有时可以看到的另一种形式：|1485148|List+list+=+getTheList();
for+(Iterator+iter+=+list.iterator();+iter.hasNext();)+{
++String+s+=+(String)+iter.next();
++//+..+do+something
}|1485149|现在全部替换为：|1485150|List<String>+list+=+getTheList();
for+(String+s+:+list)+{
++//+..+do+something
}|1485151|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Using Iterator:

<pre><code>List list = getTheList();
Iterator iter = list.iterator()
while (iter.hasNext()) {
 String s = (String) iter.next();
 // .. do something
}
</code></pre>

Or an alternate form sometimes seen:

<pre><code>List list = getTheList();
for (Iterator iter = list.iterator(); iter.hasNext();) {
 String s = (String) iter.next();
 // .. do something
}
</code></pre>

Is now all replaced with:

<pre><code>List&lt;String&gt; list = getTheList();
for (String s : list) {
 // .. do something
}
</code></pre>

blocks|key|1700587|text|尽管我承认静态导入很容易被过度使用，但我喜欢使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1700588|import+static+Math.*+;|code-block|syntax|javascript|1700589|在使用大量数学函数的类中。它确实可以减少代码的冗长。不过，我不建议将其用于鲜为人知的库，因为这可能会导致混淆。|1700590|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Although I admit that static imports can easily be overused, I like to use

<pre><code>import static Math.* ;
</code></pre>

in classes that use a lot of Math functions. It can really decrease the verbosity of your code. I wouldn't recommend it for lesser-known libraries, though, since that can lead to confusion.

blocks|key|1699657|text|将数字转换为字符串：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1699658|String+s+=+n+%2B+"";|code-block|syntax|javascript|1699659|在这种情况下，我认为总是有一种更好的方法来做到这一点：|1699660|String+s+=+String.valueOf(n);|1699661|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Converting a number to a String:

<pre><code>String s = n + "";
</code></pre>

In this case I think there has always been a better way of doing this:

<pre><code>String s = String.valueOf(n);
</code></pre>

blocks|key|1700958|text|与varargs相关；实用程序方法Arrays.asList()非常有用，它从Java5开始接受varargs参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1700959|我经常发现自己简化了一些事情，比如|1700960|List<String>+items+=+new+ArrayList<String>();
items.add("one");
items.add("two");
items.add("three");
handleItems(items);|code-block|syntax|javascript|1700961|通过使用|1700962|handleItems(Arrays.asList("one",+"two",+"three"));|1700963|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/258954/java-out-with-the-old-in-with-the-new/261297#261297|1|http://java.sun.com/javase/6/docs/api/java/util/Arrays.html#asList%2528T...%2529^0|1|7|0|H|F|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]|$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|16|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|18|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

Related to <a href="https://stackoverflow.com/questions/258954/java-out-with-the-old-in-with-the-new/261297#261297">varargs</a>; the utility method <a href="http://java.sun.com/javase/6/docs/api/java/util/Arrays.html#asList%28T...%29" rel="nofollow noreferrer">Arrays.asList()</a> which, starting from Java 5, takes varargs parameters is immensely useful.

I often find myself simplifying something like

<pre><code>List&lt;String&gt; items = new ArrayList&lt;String&gt;();
items.add("one");
items.add("two");
items.add("three");
handleItems(items);
</code></pre>

by using

<pre><code>handleItems(Arrays.asList("one", "two", "three"));
</code></pre>

blocks|key|1486104|text|注解|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1486105|我很奇怪到目前为止还没有人提到它，但是许多框架都依赖于注释，例如Spring和Hibernate.今天普遍不赞成使用xml配置文件而是代码中的注释(虽然这意味着失去了从配置到元代码的灵活性，但这通常是正确的选择).The最好的例子是EJB2(以及更老的版本)，与EJB+3.0相比，它说明了如何通过注释简化编程。|offset|length|1486106|我发现注释在与AspectJ或Spring+AOP等面向方面编程工具结合使用时也非常有用。这样的组合可能非常强大。|1486107|entityMap|0|LINK|mutability|MUTABLE|url|http://www.springsource.org/|1|https://www.hibernate.org/|2|http://www.oracle.com/technology/tech/java/newsletter/articles/simplifying_ejb3.html^0|0|W|6|0|13|A|1|3N|7|2|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@$D|V|E|W|1|X]|$D|Y|E|Z|1|10]|$D|11|E|12|1|13]]|A|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]|R|$5|K|L|M|A|$N|S]]]]

Annotations

I wonder no one mentioned it so far, but many frameworks rely on annotations, for example <a href="http://www.springsource.org/" rel="noreferrer">Spring</a> and <a href="https://www.hibernate.org/" rel="noreferrer">Hibernate.</a> It is common today to deprecate xml configuration files are in favor of annotations in code (though this means losing flexibility in moving from configuration to meta-code, but is often the right choice).The best example is EJB 2 (and older) compared to <a href="http://www.oracle.com/technology/tech/java/newsletter/articles/simplifying_ejb3.html" rel="noreferrer">EJB 3.0</a> and how programming EJB has been simplified thanks to annotations. 

I find annotations also very useful in combination with some AOP tools like AspectJ or Spring AOP. Such combination can be very powerful.

blocks|key|1700500|text|更改JUnit+3风格的测试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1700501|class+Test+extends+TestCase+{
++++public+void+testYadaYada()+{+...+}
}|code-block|syntax|javascript|1700502|要执行JUnit+4风格的测试，请执行以下操作：|1700503|class+Test+{
+++@Test+public+void+yadaYada()+{+...+}
}|1700504|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Changing JUnit 3-style tests:

<pre><code>class Test extends TestCase {
 public void testYadaYada() { ... }
}
</code></pre>

to JUnit 4-style tests:

<pre><code>class Test {
 @Test public void yadaYada() { ... }
}
</code></pre>

blocks|key|1701246|text|改进的单例模式。从技术上讲，这些都包含在流行的答案枚举中，但这是一个重要的子类别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1701247|public+enum+Singleton+{
++++INSTANCE;

++++public+void+someMethod()+{
++++++++...
++++}
}|code-block|syntax|javascript|1701248|更干净、更安全|1701249|public+class+Singleton+{
++++public+static+final+Singleton+INSTANCE+=+new+Singleton();

++++private+Singleton()+{
++++++++...
++++}

++++public+void+someMethod()+{
++++++++...
++++}
}|1701250|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Improved singleton patterns. Technically these are covered under the popular answer enums, but it's a significant subcategory.

<pre><code>public enum Singleton {
 INSTANCE;

 public void someMethod() {
 ...
 }
}
</code></pre>

is cleaner and safer than

<pre><code>public class Singleton {
 public static final Singleton INSTANCE = new Singleton();

 private Singleton() {
 ...
 }

 public void someMethod() {
 ...
 }
}
</code></pre>

blocks|key|1485696|text|将类转换为使用泛型，从而避免使用不必要的强制转换的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1485697|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Converting classes to use generics, thereby avoiding situations with unnecessary casts.

blocks|key|1700876|text|好了，现在轮到我被骂了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1700877|我不推荐其中的90%25的改变。|1700878|这并不是说在新代码中使用它们不是一个好主意，而是在现有代码中将for循环更改为for(:)循环，这只是浪费时间和破坏某些东西的机会。(IIWDFWI)如果它起作用了，不要修复它！|1700879|如果你在一家真正的开发公司，这种变化现在变成了代码审查、测试和可能的调试。|1700880|如果有人无缘无故地做这样的重构，会导致任何类型的问题，我会让他们没完没了地拉屎。|1700881|另一方面，如果您在代码中，并且无论如何都要更改该行中的内容，请随时清理它。|1700882|此外，所有以“性能”为名的建议都需要了解优化的规律。简而言之，不要！永远不会！(如果你不相信我，请用谷歌搜索“优化规则”)。|1700883|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

Okay, now it's my turn to get yelled at.

I don't recommend 90% of these changes.

It's not that it's not a good idea to use them with new code, but breaking into existing code to change a for loop to a for(:) loop is simply a waste of time and a chance to break something. (IIWDFWI) If it works, don't fix it!

If you are at a real development company, that change now becomes something to code-review, test and possibly debug.

If someone doing this kind of a refactor for no reason caused a problem of ANY sort, I'd give them no end of shit.

On the other hand, if you're in the code and changing stuff on that line anyway, feel free to clean it up.

Also, all the suggestions in the name of "Performance" really need to learn about the laws of optimization. In two words, Don't! Ever! (Google the "Rules of optimization if you don't believe me).

blocks|key|1485953|text|使用Swing的新DefaultRowSorter排序表，而不是从头开始滚动自己的表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1485954|entityMap^0|9|G|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Using Swing's new <code>DefaultRowSorter</code> to sort tables versus rolling your own from scratch.

blocks|key|1484968|text|新版本的Java很少会破坏现有的代码，所以就让旧代码保持原样，专注于新特性如何让您的生活更轻松。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1484969|如果你不去管旧代码，那么使用新特性编写新代码就不那么可怕了。|1484970|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

New version of Java rarely break existing code, so just leave old code alone and focus on how the new feature makes your life easier.

If you just leave old code alone, then writing new code using new features isn't as scary.

blocks|key|1485187|text|字符串比较，我遇到过的非常老派的Java程序员会这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1485188|String+s1+=+"...",+s2+=+"...";

if+(s1.intern()+==+s2.intern())+{
++++....
}|code-block|syntax|javascript|1485189|(假设是出于性能原因)|1485190|然而现在大多数人都是这样做的：|1485191|String+s1+=+"...",+s2+=+"...";

if+(s1.equals(s2))+{
++++....
}|1485192|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

String comparisons, really old school Java programmers I've met would do:

<pre><code>String s1 = "...", s2 = "...";

if (s1.intern() == s2.intern()) {
 ....
}
</code></pre>

(Supposedly for performance reasons)

Whereas these days most people just do:

<pre><code>String s1 = "...", s2 = "...";

if (s1.equals(s2)) {
 ....
}
</code></pre>

blocks|key|1700430|text|使用Vector而不是新的集合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1700431|使用类而不是枚举|1700432|+public+class+Enum
++{
++++++public+static+final+Enum+FOO+=+new+Enum();
++++++public+static+final+Enum+BAR+=+new+Enum();
++}|code-block|syntax|javascript|1700433|使用线程而不是新的java.util.concurrency包。|1700434|Using+marker+interfaces+instead+of+annotations|offset|length|1700435|entityMap|0|LINK|mutability|MUTABLE|url|http://www.artima.com/weblogs/viewpost.jsp?thread=98061^0|0|0|0|0|0|1A|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Using Vector instead of the new Collections.

Using classes instead of enums

<pre><code> public class Enum
 {
 public static final Enum FOO = new Enum();
 public static final Enum BAR = new Enum();
 }
</code></pre>

Using Thread instead of the new java.util.concurrency package.

<a href="http://www.artima.com/weblogs/viewpost.jsp?thread=98061" rel="nofollow noreferrer">Using marker interfaces instead of annotations</a>

blocks|key|1486022|text|值得注意的是，Java+5.0已经推出五年了，从那时起只有很小的变化。你必须在非常旧的代码上工作，才能继续重构它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1486023|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It is worth noting that Java 5.0 has been out for five years now and there have only been minor changes since then. You would have to be working on very old code to be still refactoring it.

Java is nearing version 7. It occurs to me that there must be plenty of textbooks and training manuals kicking around that teach methods based on older versions of Java, where the methods taught, would have far better solutions now.

What are some boilerplate code situations, especially ones that you see people implement through force of habit, that you find yourself refactoring to utilize the latest versions of Java?

Java: Out with the Old, In with the New

虚拟机

Java

Java正在接近版本7。我突然想到，肯定有大量的教科书和培训手册在传授基于Java旧版本的方法，这些方法现在会有更好的解决方案。您发现自己正在重构以利用最新版本的Java的一些样板代码情况，特别是那些您看到人们通过习惯的力量实现的情况？

问Java:走出旧，走进新
EN

回答 26

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java:走出旧，走进新EN

回答 26

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java:走出旧，走进新
EN