语言级assert关键字。

我真的很喜欢从Java 1.6重写的线程API。可调用对象很棒。它们基本上是带有返回值的线程。

静态导入可以“增强”语言，这样你就可以以类型安全的方式做一些漂亮的文字工作:

List<String> ls = List("a", "b", "c");

(也可以做映射，数组，集)。

http://gleichmann.wordpress.com/2008/01/13/building-your-own-literals-in-java-lists-and-arrays/

更进一步说:

List<Map<String, String>> data = List(Map( o("name", "michael"), o("sex", "male")));

我认为java的另一个“被忽视”的特性是JVM本身。它可能是可用的最好的VM。它支持许多有趣和有用的语言(Jython, JRuby, Scala, Groovy)。所有这些语言都可以轻松无缝地合作。

如果你设计了一种新的语言(就像在scala的例子中)，你会立刻拥有所有现有的库，因此你的语言从一开始就是“有用的”。

所有这些语言都利用了HotSpot优化。VM可以很好地监控和调试。

几个月前当我第一次发现它时，双括号初始化让我感到惊讶，以前从未听说过它。

作为存储每个线程状态的一种方式，ThreadLocals通常并不广为人知。

由于JDK 1.5 Java已经有了非常好的实现和健壮的并发工具，而不仅仅是锁，它们存在于Java .util.concurrent中，一个特别有趣的例子是Java .util.concurrent.atomic子包，它包含线程安全的原语，实现比较和交换操作，并可以映射到这些操作的实际本机硬件支持版本。

并不是一个真正的功能，但它让我笑，goto是一个保留词，除了提示javac戳你的眼睛什么也不做。只是想提醒你，你现在在天堂。

作为初学者，我非常欣赏Java 6中的JConsole监控软件，它已经为我解决了一些问题，而且我还在不断地寻找它的新用途。

显然JConsole在Java 5中已经有了，但我认为现在它已经改进了，至少现在工作得更稳定了。

Java 5中的JConsole: Java 5中的JConsole

Java 6中的JConsole: Java 6中的JConsole

当你在做它的时候，好好看看本系列中的其他工具: java6故障排除工具

它并不是完全隐藏的，但反射是非常有用和强大的。使用简单的class . forname("…"). newinstance()是很好的，其中类类型是可配置的。编写这种工厂实现很容易。

那么自JDK 1.5以来就存在的协变返回类型呢?它的宣传很差，因为它是一个不吸引人的附加，但据我所知，它对泛型工作是绝对必要的。

本质上，编译器现在允许子类将被覆盖方法的返回类型缩小为原始方法返回类型的子类。所以这是允许的:

class Souper {
    Collection<String> values() {
        ...
    }
}

class ThreadSafeSortedSub extends Souper {
    @Override
    ConcurrentSkipListSet<String> values() {
        ...
    }
}

您可以调用子类的values方法并获得一个排序的线程安全的字符串集，而不必向下强制转换为ConcurrentSkipListSet。

函子很酷。它们非常接近于函数指针，而这在Java中是不可能的。

Java中的函子

对于我面试的大多数Java开发人员来说，标记为块的职位是非常令人惊讶的。这里有一个例子:

// code goes here

getmeout:{
    for (int i = 0; i < N; ++i) {
        for (int j = i; j < N; ++j) {
            for (int k = j; k < N; ++k) {
                //do something here
                break getmeout;
            }
        }
    }
}

谁说goto在java中只是一个关键字?：）

我知道Java 6包括脚本支持，但我最近才发现jrunscript， 它可以交互式地解释和运行JavaScript(以及其他脚本语言，如Groovy)，有点像Ruby中的Python shell或irb

动态代理(在1.3中添加)允许您在运行时定义符合接口的新类型。它派上用场的次数多得惊人。

类型参数方差的联合:

public class Baz<T extends Foo & Bar> {}

例如，如果你想取一个参数，它既是可比的又是集合的:

public static <A, B extends Collection<A> & Comparable<B>>
boolean foo(B b1, B b2, A a) {
   return (b1.compareTo(b2) == 0) || b1.contains(a) || b2.contains(a);
}

如果两个给定的集合相等，或者其中任何一个包含给定元素，则该方法返回true，否则返回false。需要注意的一点是，您可以对参数b1和b2调用Comparable和Collection方法。

我知道这是在1.5版中添加的，但是新的enum类型是一个很棒的特性。不必使用旧的“int enum模式”极大地帮助了我的一堆代码。看看JLS 8.9的甜肉汁你的土豆!

实例变量的Final:

对多线程代码非常有用，它使争论实例状态和正确性变得容易得多。在工业环境中还没见过很多，在java类中也没想过。

静态{东西;}:

用于初始化静态成员(我也喜欢用静态方法来做它(因为它有一个名称)。没有思想。

前几天我对实例初始化器感到惊讶。我删除了一些代码折叠方法，最终创建了多个实例初始化器:

public class App {
    public App(String name) { System.out.println(name + "'s constructor called"); }

    static { System.out.println("static initializer called"); }

    { System.out.println("instance initializer called"); }

    static { System.out.println("static initializer2 called"); }

    { System.out.println("instance initializer2 called"); }

    public static void main( String[] args ) {
        new App("one");
        new App("two");
  }
}

执行main方法将显示:

static initializer called
static initializer2 called
instance initializer called
instance initializer2 called
one's constructor called
instance initializer called
instance initializer2 called
two's constructor called

我想，如果您有多个构造函数并且需要通用代码，那么这些将很有用

它们还提供了初始化类的语法糖:

List<Integer> numbers = new ArrayList<Integer>(){{ add(1); add(2); }};

Map<String,String> codes = new HashMap<String,String>(){{ 
  put("1","one"); 
  put("2","two");
}};

Joshua Bloch的新书《Effective Java》是一个很好的资源。

局部类。 从包含类的外部实例化Java内部类。

在枚举中允许使用方法和构造函数让我感到惊讶。例如:

enum Cats {
  FELIX(2), SHEEBA(3), RUFUS(7);

  private int mAge;
  Cats(int age) {
    mAge = age;
  }
  public int getAge() {
    return mAge;
   }
}

你甚至可以有一个“常量特定类主体”，它允许特定的枚举值覆盖方法。

更多文档请点击这里。

不是Java语言的一部分，但是Sun的JDK附带的javap反汇编程序并不广为人知或被广泛使用。

Self-bound泛型:

class SelfBounded<T extends SelfBounded<T>> {
}

http://www.artima.com/weblogs/viewpost.jsp?thread=136394

JDK 1.6_07+包含一个名为VisualVM (bin/jvisualvm.exe)的应用程序，它是许多工具之上的一个漂亮的GUI。它似乎比JConsole更全面。

泛型方法的类型参数可以像这样显式指定:

Collections.<String,Integer>emptyMap()

他们花了足够长的时间来增加支持，

系统托盘

java.util.Arrays中的asList方法允许变量参数、泛型方法和自动装箱的良好组合:

List<Integer> ints = Arrays.asList(1,2,3);

一些控制流的技巧，最后围绕一个return语句:

int getCount() { 
  try { return 1; }
  finally { System.out.println("Bye!"); }
}

确定赋值规则将检查最终变量总是通过简单的控制流分析进行赋值:

final int foo;
if(...)
  foo = 1;
else
  throw new Exception();
foo+1;

JDK发行版中的bin目录下的JVisualVM。监视甚至分析任何java应用程序，即使是没有使用任何特殊参数启动的应用程序。仅在Java 6SE JDK的最新版本中。

finally块中的控制权转移会丢弃任何异常。下面的代码不会抛出RuntimeException——它丢失了。

public static void doSomething() {
    try {
      //Normally you would have code that doesn't explicitly appear 
      //to throw exceptions so it would be harder to see the problem.
      throw new RuntimeException();
    } finally {
      return;
    }
  }

从http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

在1.5中增加了for-each循环结构。我<3它。

// For each Object, instantiated as foo, in myCollection
for(Object foo: myCollection) {
  System.out.println(foo.toString());
}

并且可以在嵌套实例中使用:

for (Suit suit : suits)
  for (Rank rank : ranks)
    sortedDeck.add(new Card(suit, rank));

for-each结构也适用于数组，它隐藏了索引变量而不是迭代器。下面的方法返回int数组中所有值的和:

// Returns the sum of the elements of a
int sum(int[] a) {
  int result = 0;
  for (int i : a)
    result += i;
  return result;
}

链接到Sun文档

"const"是一个关键字，但你不能使用它。

int const = 1;   // "not a statement"
const int i = 1; // "illegal start of expression"

我猜编译器的作者认为将来可能会用到它，他们最好保留它。

这并不是一个真正的功能，而是我最近在一些网页上发现的一个有趣的技巧:

class Example
{
  public static void main(String[] args)
  {
    System.out.println("Hello World!");
    http://Phi.Lho.free.fr

    System.exit(0);
  }
}

是一个有效的Java程序(尽管它会生成警告)。 如果你不明白为什么，请看格雷戈里的回答!;-)好吧，这里的语法高亮也给了一个提示!

我最喜欢的:转储所有线程堆栈跟踪到标准输出。

在你的java cmd/控制台窗口中按CTRL-Break键

unix: kill -3 PID

The power you can have over the garbage collector and how it manages object collection is very powerful, especially for long-running and time-sensitive applications. It starts with weak, soft, and phantom references in the java.lang.ref package. Take a look at those, especially for building caches (there is a java.util.WeakHashMap already). Now dig a little deeper into the ReferenceQueue and you'll start having even more control. Finally grab the docs on the garbage collector itself and you'll be able to control how often it runs, sizes of different collection areas, and the types of algorithms used (for Java 5 see http://java.sun.com/docs/hotspot/gc5.0/gc_tuning_5.html).

使用此关键字从内部类访问包含类的字段/方法。在下面的例子中，我们希望使用匿名内部类的容器类的sortAscending字段。使用ContainerClass.this.sortAscending代替this。sortAscending就是这样。

import java.util.Comparator;

public class ContainerClass {
boolean sortAscending;
public Comparator createComparator(final boolean sortAscending){
    Comparator comparator = new Comparator<Integer>() {

        public int compare(Integer o1, Integer o2) {
            if (sortAscending || ContainerClass.this.sortAscending) {
                return o1 - o2;
            } else {
                return o2 - o1;
            }
        }

    };
    return comparator;
}
}

这不是真正的“隐藏功能”，也不是很有用，但在某些情况下可能非常有趣: sun.misc.Unsafe类——允许你在Java中实现直接的内存管理(如果你尝试了很多，你甚至可以用它来编写自修改的Java代码):

public class UnsafeUtil {

    public static Unsafe unsafe;
    private static long fieldOffset;
    private static UnsafeUtil instance = new UnsafeUtil();

    private Object obj;

    static {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);

            unsafe = (Unsafe)f.get(null);
            fieldOffset = unsafe.objectFieldOffset(UnsafeUtil.class.getDeclaredField("obj"));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
}

因为还没有人说过(我认为)我最喜欢的功能是自动装箱!

public class Example
{
    public static void main(String[] Args)
    {
         int a = 5;
         Integer b = a; // Box!
         System.out.println("A : " + a);
         System.out.println("B : " + b);
    }
}

您选择的编码中的属性文件如何?过去，当你加载你的属性，你提供了一个InputStream和load()方法解码为ISO-8859-1。你实际上可以用其他编码来存储文件，但你必须在加载后使用像这样令人作呕的黑客来正确解码数据:

String realProp = new String(prop.getBytes("ISO-8859-1"), "UTF-8");

但是，从JDK 1.6开始，有一个load()方法接受Reader而不是InputStream，这意味着您可以从一开始就使用正确的编码(还有一个store()方法接受Writer)。对我来说，这似乎是一件相当大的事情，但它似乎是悄无声息地潜入JDK的。我几周前才偶然发现它，快速搜索谷歌，只发现了一个提及。

如果你做了很多JavaBean开发，并且使用了属性更改支持，你通常会写很多这样的setter:

public void setFoo(Foo aFoo){
  Foo old = this.foo;
  this.foo = aFoo;
  changeSupport.firePropertyChange("foo", old, aFoo);
}

我最近无意中发现了一篇博客，它提出了一个更简洁的实现，使代码更容易编写:

public void setFoo(Foo aFoo){
  changeSupport.firePropertyChange("foo", this.foo, this.foo = aFoo);
}

它实际上简化了事情，以至于我能够在Eclipse中调整setter模板，从而自动创建方法。

字符串参数化类工厂。

Class.forName( className ).newInstance();

从部署jar文件中加载资源(属性文件，xml, xslt，图像等)。

this.getClass().getClassLoader().getResourceAsStream( ... ) ;

真正让我吃惊的是自定义序列化机制。

而这些方法是私有的!!，它们会在对象序列化期间被JVM“神秘地”调用。

private void writeObject(ObjectOutputStream out) throws IOException;
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;

通过这种方式，您可以创建自己的自定义序列化，使其更加“随便”(安全、快速、罕见、简单等)。

如果大量信息必须通过节点传递，这是真正应该考虑的事情。序列化机制可以更改为发送数据的一半。很多时候，瓶颈并不在平台上，而是在通过线路发送的数量上，这可能会为您节省数千个硬件dll。

这是一篇文章。 http://java.sun.com/developer/technicalArticles/Programming/serialization/

你可以在方法中声明一个类:

public Foo foo(String in) {
    class FooFormat extends Format {
        public Object parse(String s, ParsePosition pp) { // parse stuff }
    }
    return (Foo) new FooFormat().parse(in);

}

来自Java 6的注释处理API看起来非常适合代码生成和静态代码验证。

最终初始化可以推迟。

它确保即使使用复杂的逻辑流也始终设置返回值。很容易错过一个case并意外返回null。它并不是不可能返回null，只是很明显它是故意的:

public Object getElementAt(int index) {
    final Object element;
    if (index == 0) {
         element = "Result 1";
    } else if (index == 1) {
         element = "Result 2";
    } else {
         element = "Result 3";
    }
    return element;
}

几年前，当我必须做Java (1.4.x)时，我想要一个eval()方法，而太阳javac是(是?)用Java编写的，所以它只是链接tools.jar，并使用它周围的一些胶水代码。

如果不使用默认初始化式，Java处理在变量定义上做了一个巧妙的技巧。

{
   int x;

   if(whatever)
      x=1;

   if(x == 1)
      ...
}

这将在编译时给您一个错误，即您有一个X未正确定义的路径。这帮助了我几次，我已经开始考虑默认的初始化，像这样:

int x=0;
String s=null;

这是一个不好的模式，因为它阻碍了这种有用的检查。

也就是说，有时很难解决这个问题——当它作为默认值有意义时，我不得不回去编辑=null，但我再也没有在第一次传递时把它放在里面了。

你可以在局部类的初始化块和方法中访问最终的局部变量和参数。考虑一下:

    final String foo = "42";
    new Thread() {
        public void run() {
             dowhatever(foo);
        }
    }.start();

有点像个了结，不是吗?

值:

new URL("http://www.yahoo.com").equals(new URL("http://209.191.93.52"))

是真的。

(摘自Java Puzzlers)

一些人已经发布了关于实例初始化器的文章，下面是它的一个很好的用法:

Map map = new HashMap() {{
    put("a key", "a value");
    put("another key", "another value");
}};

是初始化映射的快速方法，如果你只是做一些快速简单的事情。

或者用它来创建一个快速摆动框架原型:

JFrame frame = new JFrame();

JPanel panel = new JPanel(); 

panel.add( new JLabel("Hey there"){{ 
    setBackground(Color.black);
    setForeground( Color.white);
}});

panel.add( new JButton("Ok"){{
    addActionListener( new ActionListener(){
        public void actionPerformed( ActionEvent ae ){
            System.out.println("Button pushed");
        }
     });
 }});


 frame.add( panel );

当然，它也可能被滥用:

    JFrame frame = new JFrame(){{
         add( new JPanel(){{
               add( new JLabel("Hey there"){{ 
                    setBackground(Color.black);
                    setForeground( Color.white);
                }});

                add( new JButton("Ok"){{
                    addActionListener( new ActionListener(){
                        public void actionPerformed( ActionEvent ae ){
                            System.out.println("Button pushed");
                        }
                     });
                 }});
        }});
    }};

从Java 1.5开始，Java现在有了更清晰的语法来编写变量函数。不只是传递一个数组，现在您可以执行以下操作

public void foo(String... bars) {
   for (String bar: bars)
      System.out.println(bar);
}

Bars自动转换为指定类型的数组。这不是一个巨大的胜利，但仍然是一场胜利。

Javadoc——在正确编写的情况下(不幸的是，一些开发人员并不总是这样)，它会为您提供一个清晰、连贯的描述，说明代码应该做什么，而不是它实际做什么。然后可以将其转换为一组不错的可浏览的HTML文档。如果你使用持续集成等方法，它可以定期生成，这样所有开发者都可以看到最新的更新。

SwingWorker用于轻松管理后台线程的用户界面回调。

同一个类的实例可以访问其他实例的私有成员:

class Thing {
  private int x;

  public int addThings(Thing t2) {
    return this.x + t2.x;  // Can access t2's private value!
  }
}

显然，在一些调试版本中，有一个从HotSpot: http://weblogs.java.net/blog/kohsuke/archive/2008/03/deep_dive_into.html转储本机(JIT)程序集代码的选项

不幸的是，我无法通过那篇文章中的链接找到构建，如果有人能找到一个更精确的URL，我很乐意使用它。

我投票给java.util.concurrent，因为它的并发集合和灵活的执行器允许线程池、计划任务和协调任务。DelayQueue是我个人最喜欢的，其中元素在指定的延迟后才可用。

timer和TimerTask可以安全地休息了。

而且，它不是完全隐藏的，而是在与日期和时间相关的其他类不同的包中。timeunit在纳秒、微秒、毫秒和秒之间转换时很有用。

它比通常的someValue * 1000或someValue / 1000读起来要好得多。

strictfp关键字。(但我从未见过它在实际应用中使用:)

你可以使用下面的符号来获取基元类型的类: float.class等等。在做反射的时候非常有用。

Final数组可用于从匿名内部类中“返回”值(警告，下面的示例无用):

final boolean[] result = new boolean[1];
SwingUtilities.invokeAndWait(new Runnable() {
  public void run() { result[0] = true; }
});

还没有人提到instanceof的实现方式是不需要检查null的。

而不是:

if( null != aObject && aObject instanceof String )
{
    ...
}

只使用:

if( aObject instanceof String )
{
    ...
}

我喜欢

Javadoc的taglet和doclet使我们能够自定义Javadoc输出。 JDK工具:jstat, jstack等。

在Java 1.6 Update 10及以后版本中发现的下一代Java插件有一些非常简洁的特性:

传递java_arguments参数，将参数传递给创建的JVM。这允许您控制给予applet的内存量。 为每个applet创建单独的类装入器，甚至单独的JVM。 指定要使用的JVM版本。 在只需要完整Java库功能的一个子集的情况下，安装部分Java内核。 更好的Vista支持。 支持(实验性)将applet拖出浏览器，并在导航离开时让它继续运行。

这里记录了许多其他事情:http://jdk6.dev.java.net/plugin2/

更多信息请访问:http://jdk6.dev.java.net/6u10ea.html

您可以使用string .format()构建sprintf样式的字符串。

String w = "world";
String s = String.format("Hello %s %d", w, 3);

当然，您也可以使用特殊的说明符来修改输出。

更多信息请点击:http://java.sun.com/j2se/1.5.0/docs/api/java/util/Formatter.html#syntax

使用静态导入，你可以做一些很酷的事情，比如:

List<String> myList = list("foo", "bar");
Set<String> mySet = set("foo", "bar");
Map<String, String> myMap = map(v("foo", "2"), v("bar", "3"));

我喜欢方法的静态导入。

例如，创建以下util类:

package package.name;

public class util {

     private static void doStuff1(){
        //the end
     }

     private static String doStuff2(){
        return "the end";
     }

}

然后像这样使用它。

import static package.name.util.*;

public class main{

     public static void main(String[] args){
          doStuff1(); // wee no more typing util.doStuff1()
          System.out.print(doStuff2()); // or util.doStuff2()
     }

}

静态导入适用于任何类，甚至数学…

import static java.lang.Math.*;
import static java.lang.System.out;
public class HelloWorld {
    public static void main(String[] args) {
        out.println("Hello World!");
        out.println("Considering a circle with a diameter of 5 cm, it has:");
        out.println("A circumference of " + (PI * 5) + "cm");
        out.println("And an area of " + (PI * pow(5,2)) + "sq. cm");
    }
}

列表。subblist返回原始列表的视图

一个有文献记载但鲜为人知的列表特征。这允许您使用反映在原始列表中的更改来处理列表的部分。

列出子列表(int fromIndex, int toIndex)

这种方法消除了显式范围操作的需要(通常存在于数组的那种操作)。任何需要一个列表的操作都可以通过传递一个subblist视图而不是整个列表来用作范围操作。例如，下面的习惯用法从列表中移除一系列元素: 列表。分表(,).clear (); 类似的习惯用法可以用于indexOf和lastIndexOf, Collections类中的所有算法都可以应用于子列表。”

我个人很晚才发现java.lang.Void——结合泛型提高了代码的可读性，例如Callable<Void>

可以使用枚举来实现接口。

public interface Room {
   public Room north();
   public Room south();
   public Room east();
   public Room west();
}

public enum Rooms implements Room {
   FIRST {
      public Room north() {
         return SECOND;
      }
   },
   SECOND {
      public Room south() {
         return FIRST;
      }
   }

   public Room north() { return null; }
   public Room south() { return null; }
   public Room east() { return null; }
   public Room west() { return null; }
}

编辑:多年后....

我在这里使用了这个特性

public enum AffinityStrategies implements AffinityStrategy {

https://github.com/peter-lawrey/Java-Thread-Affinity/blob/master/src/main/java/vanilla/java/affinity/AffinityStrategies.java

通过使用接口，开发人员可以定义自己的策略。使用枚举意味着我可以定义一个内置在一个中的集合(五个)。

交集类型允许您(有点)执行具有继承层次结构的枚举。您不能继承实现，但可以将其委托给助手类。

enum Foo1 implements Bar {}
enum Foo2 implements Bar {}

class HelperClass {
   static <T extends Enum<T> & Bar> void fooBar(T the enum) {}
}

当您有许多实现某种模式的不同枚举时，这很有用。例如，许多具有父子关系的枚举对。

enum PrimaryColor {Red, Green, Blue;}
enum PastelColor {Pink, HotPink, Rockmelon, SkyBlue, BabyBlue;}

enum TransportMedium {Land, Sea, Air;}
enum Vehicle {Car, Truck, BigBoat, LittleBoat, JetFighter, HotAirBaloon;}

你可以编写泛型方法，说“好的，给定一个枚举值，它是其他一些枚举值的父枚举值，所有可能的子枚举的子类型中有多少百分比是这个特定的父值作为它们的父?”，并让它都是类型安全的，并且没有强制转换。(例如:“海洋”是所有可能的车辆的33%，“绿色”是所有可能的粉彩的20%)。

代码是这样的。这很糟糕，但有办法让它变得更好。特别要注意的是，“叶子”类本身非常整洁——泛型类的声明非常丑陋，但您只编写一次。一旦有了泛型类，使用它们就很容易了。

import java.util.EnumSet;

import javax.swing.JComponent;

public class zz extends JComponent {

    public static void main(String[] args) {
        System.out.println(PrimaryColor.Green + " " + ParentUtil.pctOf(PrimaryColor.Green) + "%");
        System.out.println(TransportMedium.Air + " " + ParentUtil.pctOf(TransportMedium.Air) + "%");
    }


}

class ParentUtil {
    private ParentUtil(){}
    static <P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> //
    float pctOf(P parent) {
        return (float) parent.getChildren().size() / //
                (float) EnumSet.allOf(parent.getChildClass()).size() //
                * 100f;
    }
    public static <P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> //
    EnumSet<C> loadChildrenOf(P p) {
        EnumSet<C> cc = EnumSet.noneOf(p.getChildClass());
        for(C c: EnumSet.allOf(p.getChildClass())) {
            if(c.getParent() == p) {
                cc.add(c);
            }
        }
        return cc;
    }
}

interface Parent<P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> {
    Class<C> getChildClass();

    EnumSet<C> getChildren();
}

interface Child<P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> {
    Class<P> getParentClass();

    P getParent();
}

enum PrimaryColor implements Parent<PrimaryColor, PastelColor> {
    Red, Green, Blue;

    private EnumSet<PastelColor>    children;

    public Class<PastelColor> getChildClass() {
        return PastelColor.class;
    }

    public EnumSet<PastelColor> getChildren() {
        if(children == null) children=ParentUtil.loadChildrenOf(this);
        return children;
    }
}

enum PastelColor implements Child<PrimaryColor, PastelColor> {
    Pink(PrimaryColor.Red), HotPink(PrimaryColor.Red), //
    Rockmelon(PrimaryColor.Green), //
    SkyBlue(PrimaryColor.Blue), BabyBlue(PrimaryColor.Blue);

    final PrimaryColor  parent;

    private PastelColor(PrimaryColor parent) {
        this.parent = parent;
    }

    public Class<PrimaryColor> getParentClass() {
        return PrimaryColor.class;
    }

    public PrimaryColor getParent() {
        return parent;
    }
}

enum TransportMedium implements Parent<TransportMedium, Vehicle> {
    Land, Sea, Air;

    private EnumSet<Vehicle>    children;

    public Class<Vehicle> getChildClass() {
        return Vehicle.class;
    }

    public EnumSet<Vehicle> getChildren() {
        if(children == null) children=ParentUtil.loadChildrenOf(this);
        return children;
    }
}

enum Vehicle implements Child<TransportMedium, Vehicle> {
    Car(TransportMedium.Land), Truck(TransportMedium.Land), //
    BigBoat(TransportMedium.Sea), LittleBoat(TransportMedium.Sea), //
    JetFighter(TransportMedium.Air), HotAirBaloon(TransportMedium.Air);

    private final TransportMedium   parent;

    private Vehicle(TransportMedium parent) {
        this.parent = parent;
    }

    public Class<TransportMedium> getParentClass() {
        return TransportMedium.class;
    }

    public TransportMedium getParent() {
        return parent;
    }
}

阅读约书亚·布洛赫的《爪哇谜题》，你会受到启发，也会感到恐惧。

源代码url。例如，这是一些合法的java源代码:

http://google.com

(是的，这是在Java Puzzlers中。我笑了…)

当人们意识到可以使用反射调用私有方法并访问/更改私有字段时，他们有时会有点惊讶……

考虑下面的类:

public class Foo {
    private int bar;

    public Foo() {
        setBar(17);
    }

    private void setBar(int bar) {
        this.bar=bar;
    }

    public int getBar() {
        return bar;
    }

    public String toString() {
        return "Foo[bar="+bar+"]";
    }
}

执行这个程序…

import java.lang.reflect.*;

public class AccessibleExample {
    public static void main(String[] args)
        throws NoSuchMethodException,IllegalAccessException, InvocationTargetException, NoSuchFieldException {
        Foo foo=new Foo();
        System.out.println(foo);

        Method method=Foo.class.getDeclaredMethod("setBar", int.class);
        method.setAccessible(true);
        method.invoke(foo, 42);

        System.out.println(foo);
        Field field=Foo.class.getDeclaredField("bar");
        field.setAccessible(true);
        field.set(foo, 23);
        System.out.println(foo);
    }
}

.．.将产生以下输出:

Foo[bar=17]
Foo[bar=42]
Foo[bar=23]

部分功能，部分麻烦:Java的String处理使其“看起来”是原生类型(使用运算符，+，+=)

能写的:

String s = "A";
s += " String"; // so s == "A String"

非常方便，但只是语法糖(即被编译为):

String s = new String("A");
s = new StringBuffer(s).append(" String").toString();

因此，一个对象实例化和2个方法调用一个简单的连接。想象一下以这种方式在循环中构建一个长字符串!?并且StringBuffer的所有方法都声明为同步的。谢天谢地，在Java 5中，他们引入了StringBuilder，它与StringBuffer是一样的，只是没有同步。

这样的循环:

String s = "";
for (int i = 0 ; i < 1000 ; ++i)
  s += " " + i; // Really an Object instantiation & 3 method invocations!

可以(应该)在你的代码中重写为:

StringBuilder buf = new StringBuilder(); // Empty buffer
for (int i = 0 ; i < 1000 ; ++i)
  buf.append(' ').append(i); // Cut out the object instantiation & reduce to 2 method invocations
String s = buf.toString();

并将运行大约80+%比原来的循环! (在我运行的一些基准测试中高达180%)

也许最令人惊讶的隐藏特性是sun.misc.Unsafe类。

http://www.docjar.com/html/api/ClassLib/Common/sun/misc/Unsafe.java.html

你可以;

Create an object without calling a constructor. Throw any exception even Exception without worrying about throws clauses on methods. (There are other way to do this I know) Get/set randomly accessed fields in an object without using reflection. allocate/free/copy/resize a block of memory which can be long (64-bit) in size. Obtain the location of fields in an object or static fields in a class. independently lock and unlock an object lock. (like synchronize without a block) define a class from provided byte codes. Rather than the classloader determining what the byte code should be. (You can do this with reflection as well)

BTW:不正确地使用这个类会杀死JVM。我不知道哪个jvm支持这个类，所以它不能移植。

您可以定义一个匿名子类，并直接调用它上的方法，即使它没有实现接口。

new Object() {
  void foo(String s) {
    System.out.println(s);
  }
}.foo("Hello");

一个优化技巧，使您的代码更容易维护，更不容易受到并发性错误的影响。

public class Slow {
  /** Loop counter; initialized to 0. */
  private long i;

  public static void main( String args[] ) {
    Slow slow = new Slow();

    slow.run();
  }

  private void run() {
    while( i++ < 10000000000L )
      ;
  }
}

$ time java慢 真正的0 m15.397s $ time java慢 真正的0 m20.012s $ time java慢 真正的0 m18.645s

平均:18.018秒

public class Fast {
  /** Loop counter; initialized to 0. */
  private long i;

  public static void main( String args[] ) {
    Fast fast = new Fast();

    fast.run();
  }

  private void run() {
    long i = getI();

    while( i++ < 10000000000L )
      ;

    setI( i );
  }

  private long setI( long i ) {
    this.i = i;
  }

  private long getI() {
    return this.i;
  }
}

$ time java快速 真正的0 m12.003s $ time java快速 真正的0 m9.840s $ time java快速 真正的0 m9.686s

平均:10.509秒

引用类作用域变量比引用方法作用域变量需要更多的字节码。在关键循环之前添加方法调用几乎不会增加开销(而且编译器可能会内联调用)。

这种技术(总是使用访问器)的另一个优点是它消除了Slow类中的潜在错误。如果第二个线程要不断地将i的值重置为0(通过调用slow. xml)。setI(0)，例如)，Slow类永远不能结束它的循环。调用访问器并使用局部变量消除了这种可能性。

在Linux 2.6.27-14上使用J2SE 1.6.0_13进行测试。

javabean属性访问器方法不必以“get”和“set”开头。

甚至Josh Bloch在《Effective Java》中也犯了这个错误。

我今天才(重新)了解到$是Java中方法或变量的合法名称。与静态导入相结合，可以生成一些可读性稍强的代码，这取决于你对可读的看法:

http://garbagecollected.org/2008/04/06/dollarmaps/

前面已经提到，final数组可用于将变量传递给匿名内部类。

另一种更好、更简洁的方法是使用java.util.concurrent.atomic包中的AtomicReference(或AtomicBoolean/AtomicInteger/…)类。

这样做的好处之一是，这些类还提供了compareAndSet这样的方法，如果要创建几个可以修改同一个变量的线程，这个方法可能很有用。

另一个有用的相关模式:

final AtomicBoolean dataMsgReceived = new AtomicBoolean(false);
final AtomicReference<Message> message = new AtomicReference<Message>();
withMessageHandler(new MessageHandler() {
    public void handleMessage(Message msg) {
         if (msg.isData()) {
             synchronized (dataMsgReceived) {
                 message.set(msg);
                 dataMsgReceived.set(true);
                 dataMsgReceived.notifyAll();
             }
         }
    }
}, new Interruptible() {
    public void run() throws InterruptedException {
        synchronized (dataMsgReceived) {
            while (!dataMsgReceived.get()) {
                dataMsgReceived.wait();
            }
        }
    }
});

在这个特殊的例子中，我们可以简单地等待message变成非空，但是null通常是一个有效值，然后你需要使用一个单独的标志来完成等待。

上面的waitMessageHandler(…)是另一个有用的模式:它在某个地方设置了一个处理程序，然后开始执行可能抛出异常的Interruptible，然后在finally块中删除该处理程序，如下所示:

private final AtomicReference<MessageHandler> messageHandler = new AtomicReference<MessageHandler>();
public void withMessageHandler(MessageHandler handler, Interruptible logic) throws InterruptedException {
    synchronized (messageHandler) {
        try {
            messageHandler.set(handler);
            logic.run();
        } finally {
            messageHandler.set(null);
        }
    }
}

这里我假设messageHandler的handleMessage(…)方法在接收到消息时被另一个线程调用。messageHandler不能简单地为messageHandler类型:这样您将同步一个正在变化的变量，这显然是一个错误。

当然，它不需要是InterruptedException，它可以是IOException之类的东西，或者在特定代码段中有意义的任何东西。

逗号和数组。字符串s[] = { “123”, “234”, };

大多数人不知道他们可以克隆一个数组。

int[] arr = {1, 2, 3};
int[] arr2 = arr.clone();

当你不需要StringBuilder中包含的同步管理时，使用StringBuilder代替StringBuffer。它将提高应用程序的性能。

Java 7的改进甚至比任何隐藏的Java特性都要好:

菱形语法:Link

不要在实例化时使用那些infinite <>语法:

Map<String, List<String>> anagrams = new HashMap<String, List<String>>();

// Can now be replaced with this:

Map<String, List<String>> anagrams = new HashMap<>();

switch中的字符串:Link

在switch中使用String，而不是old-C int:

String s = "something";
switch(s) {
 case "quux":
    processQuux(s);
    // fall-through

  case "foo":
  case "bar":
    processFooOrBar(s);
    break;

  case "baz":
     processBaz(s);
    // fall-through

  default:
    processDefault(s);
    break;
}

自动资源管理Link

这段旧代码:

static void copy(String src, String dest) throws IOException {
    InputStream in = new FileInputStream(src);
    try {
        OutputStream out = new FileOutputStream(dest);
        try {
            byte[] buf = new byte[8 * 1024];
            int n;
            while ((n = in.read(buf)) >= 0)
                out.write(buf, 0, n);
        } finally {
            out.close();
        }
    } finally {
        in.close();
    }
}

现在可以用更简单的代码代替:

static void copy(String src, String dest) throws IOException {
    try (InputStream in = new FileInputStream(src);
            OutputStream out = new FileOutputStream(dest)) {
        byte[] buf = new byte[8192];
        int n;
        while ((n = in.read(buf)) >= 0)
            out.write(buf, 0, n);
    }
}

您可以在枚举类的方法定义中切换(此)。当我发现这个方法真的有效时，我大声喊了一声“什么!”

实际上，我喜欢Java的原因是它很少有隐藏的技巧。这是一种非常明显的语言。以至于15年过去了，我能想到的几乎每一个都已经列在这几页纸上了。

也许大多数人都知道Collections.synchronizedList()将同步添加到列表中。除非阅读文档，否则您不可能知道的是，您可以通过同步列表对象本身来安全地迭代该列表的元素。

有些人可能不知道CopyOnWriteArrayList，而Future表示一种抽象多线程结果访问的有趣方法。

您可以通过各种管理、代理和附加api连接到虚拟机(本地或远程)，获取关于GC活动、内存使用、文件描述符甚至对象大小的信息。

虽然TimeUnit可能比long更好，但我更喜欢Wicket的Duration类。

我差点忘了这个小宝贝。在任何正在运行的java进程上尝试这个:

jmap -histo:活动PID

您将得到给定VM中活动堆对象的直方图。作为一种快速计算某些类型的内存泄漏的宝贵方法。我使用的另一种技术是创建和使用所有集合类的有大小限制的子类。这将导致容易识别的失控集合出现快速故障。

一种可以为基于Java控制台的应用程序显示启动画面的功能。

使用带有-splash选项的命令行工具java或javaw

eg:

java -splash:C:\myfolder\myimage.png -classpath myjarfile.jar com.my.package.MyClass

C:\myfolder\myimage.png的内容将显示在你的屏幕中央，每当你执行类"com.my.package.MyClass"

在Swing中工作时，我喜欢隐藏的Ctrl - Shift - F1特性。

它转储当前窗口的组件树。 (假设您没有将该击键绑定到其他内容。)

一个接口可以扩展多个接口，但一个类只能扩展一个类，这让我感到惊讶。

Java 6以来的类路径通配符。

java -classpath ./lib/* so.Main

而不是

java -classpath ./lib/log4j.jar:./lib/commons-codec.jar:./lib/commons-httpclient.jar:./lib/commons-collections.jar:./lib/myApp.jar so.Main

参见http://java.sun.com/javase/6/docs/technotes/tools/windows/classpath.html

关闭钩子。这允许注册一个线程，该线程将立即创建，但仅在JVM结束时启动!因此，它是某种“全局jvm终结器”，您可以在这个线程中做一些有用的事情(例如关闭java资源，如嵌入式hsqldb服务器)。这适用于System.exit()，或CTRL-C / kill -15(当然，在unix上不适用kill -9)。

此外，它很容易设置。

            Runtime.getRuntime().addShutdownHook(new Thread() {
                  public void run() {
                      endApp();
                  }
            });;

标识符可以包含外文字符，比如变音:

而不是写:

String title="";

有人可以这样写:

String Überschrift="";

Java 6(来自Sun)带有嵌入式javascript解释器。

http://java.sun.com/javase/6/docs/technotes/guides/scripting/programmer_guide/index.html#jsengine

没读到过

Integer a = 1;
Integer b = 1;
Integer c = new Integer(1);
Integer d = new Integer(1);

Integer e = 128;
Integer f = 128;

assertTrue (a == b);   // again: this is true!
assertFalse(e == f); // again: this is false!
assertFalse(c == d);   // again: this is false!

通过搜索java的整数池(内部“缓存”从-128到127用于自动装箱)或查看integer . valueof来了解更多信息

您可以重写一个方法，并让超类构造函数调用它(这可能会让c++程序员感到惊讶)。

例子

这是我的清单。

我最喜欢的(也是最可怕的)隐藏特性是，您可以从没有声明抛出任何东西的方法中抛出检查异常。

import java.rmi.RemoteException;

class Thrower {
    public static void spit(final Throwable exception) {
        class EvilThrower<T extends Throwable> {
            @SuppressWarnings("unchecked")
            private void sneakyThrow(Throwable exception) throws T {
                throw (T) exception;
            }
        }
        new EvilThrower<RuntimeException>().sneakyThrow(exception);
    }
}

public class ThrowerSample {
    public static void main( String[] args ) {
        Thrower.spit(new RemoteException("go unchecked!"));
    }
}

此外，你可能想知道你可以抛出'null'…

public static void main(String[] args) {
     throw null;
}

猜猜这打印了什么:

Long value = new Long(0);
System.out.println(value.equals(0));

猜猜这返回什么:

public int returnSomething() {
    try {
        throw new RuntimeException("foo!");
    } finally {
        return 0;
    }
}

优秀的开发人员不应该对上述情况感到惊讶。

在Java中，你可以用以下几种有效的方式来声明数组:

String[] strings = new String[] { "foo", "bar" };
// the above is equivalent to the following:
String[] strings = { "foo", "bar" };

所以下面的Java代码是完全有效的:

public class Foo {
    public void doSomething(String[] arg) {}

    public void example() {
        String[] strings = { "foo", "bar" };
        doSomething(strings);
    }
}

是否有任何有效的理由说明下面的代码不应该是有效的?

public class Foo {

    public void doSomething(String[] arg) {}

    public void example() {
        doSomething({ "foo", "bar" });
    }
}

我认为，上述语法可以有效地替代Java 5中引入的可变参数。并且，与之前允许的数组声明更加一致。

每个类文件都以十六进制值0xCAFEBABE开始，以标识它是有效的JVM字节码。

(解释)

您可以使用Class<T>对象添加泛型类型的运行时检查，当在某个配置文件中创建类且无法为类的泛型类型添加编译时检查时，这非常方便。你不希望类在运行时爆炸，如果应用程序碰巧配置错误，你不希望所有的类都充满了检查的实例。

public interface SomeInterface {
  void doSomething(Object o);
}
public abstract class RuntimeCheckingTemplate<T> {
  private Class<T> clazz;
  protected RuntimeChecking(Class<T> clazz) {
    this.clazz = clazz;
  }

  public void doSomething(Object o) {
    if (clazz.isInstance(o)) {
      doSomethingWithGeneric(clazz.cast(o));
    } else {
      // log it, do something by default, throw an exception, etc.
    }
  }

  protected abstract void doSomethingWithGeneric(T t);
}

public class ClassThatWorksWithStrings extends RuntimeCheckingTemplate<String> {
  public ClassThatWorksWithStrings() {
     super(String.class);
  }

  protected abstract void doSomethingWithGeneric(T t) {
    // Do something with the generic and know that a runtime exception won't occur 
    // because of a wrong type
  }
}

当我第一次注意到三元运算符等于一个简单的if-then-else语句时，我很惊讶:

minVal = (a < b) ? a : b;

我可以添加扫描仪对象。它是解析的最佳选择。

String input = "1 fish 2 fish red fish blue fish";
Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
System.out.println(s.nextInt());
System.out.println(s.nextInt());
System.out.println(s.next());
System.out.println(s.next());
s.close();

可以在匿名内部类上定义和调用方法。

其实它们并没有那么隐藏，但是很少有人知道它们可以用来定义一个类中的新方法，并像这样调用它:

(new Object() {
    public String someMethod(){ 
        return "some value";
    }
}).someMethod();

可能不是很常见，因为它也不是很有用，你只能在定义方法时调用它(或通过反射)

这并不是一个真正的隐藏功能，但当我看到这个编译好的时候，它确实给了我一个很大的惊喜:

public int aMethod(){
    http://www.google.com
    return 1;
}

它被编译的原因是编译器将http://www.google.com行“http:”部分视为标签，而该行的其余部分是注释。

所以，如果你想写一些奇怪的代码(或模糊的代码)，只要在那里放很多http地址。: -)

c风格的printf():)

System.out.printf("%d %f %.4f", 3,Math.E,Math.E);

输出: 3 2.718282 2.7183

二分搜索(以及它的返回值)

int[] q = new int[] { 1,3,4,5};
int position = Arrays.binarySearch(q, 2);

类似于c#，如果在数组中没有找到'2'，它会返回一个负值，但如果你对返回值取1的补，你实际上会得到'2'可以插入的位置。

在上面的例子中，position = -2， ~position = 1，这是2应该插入的位置…它还允许您找到数组中“最接近”的匹配项。

我认为它很漂亮……：）

不那么隐蔽，但很有趣。

你可以有一个没有main方法的"Hello, world"(它会抛出NoSuchMethodError思想)

最初由RusselW在最奇怪的语言功能上发布

public class WithoutMain {
    static {
        System.out.println("Look ma, no main!!");
        System.exit(0);
    }
}

$ java WithoutMain
Look ma, no main!!