Java的隐藏功能

看完C＃的隐藏功能后，我想知道Java的一些隐藏功能是什么？

几个月前，Double Brace Initialization使我惊讶，以前从未听说过它。

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

由于JDK 1.5 Java除了锁以外，还具有非常好的实现和健壮的并发工具，因此它们位于java.util.concurrent中，一个特别有趣的示例是java.util.concurrent.atomic子包，其中包含实现比较的线程安全原语。-and-swap操作，并且可以映射到这些操作的实际本机硬件支持的版本。

类型参数方差的联合并集：

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

例如，如果您想使用一个同时为Comparable和Collection的参数：

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的方法。

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

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");
}};

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

自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

对于大多数人来说，我在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;
            }
        }
    }
}

谁说过gotoJava只是关键字？:)

从JDK 1.5开始，协变量返回类型如何？由于它不是很性感，所以它的宣传很少，但是据我所知，它是泛型工作必不可少的。

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

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

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

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

在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

尚未见任何人提到instanceof以不需要检查null的方式实现。

代替：

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

只需使用：

if( aObject instanceof String )
{
    ...
}

枚举中允许方法和构造函数令我惊讶。例如：

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

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

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

更多文档在这里。

泛型方法的类型参数可以如下明确指定：

Collections.<String,Integer>emptyMap()

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

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方法，我可以定义一个内置的（五个）集合。

从Java 1.5开始，Java现在具有更简洁的语法来编写可变arity函数。因此，现在您不仅可以传递数组，还可以执行以下操作

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

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

我的最爱：将所有线程堆栈跟踪转储到标准输出。

Windows：CTRL-Break在您的Java cmd /控制台窗口中

Unix： kill -3 PID

有人发布了有关实例初始化程序的信息，这是一个很好的用法：

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");
                        }
                     });
                 }});
        }});
    }};

动态代理（在1.3中添加）允许您在运行时定义符合接口的新类型。它派上用场了很多次。

最终的初始化可以推迟。

它确保即使在逻辑流程复杂的情况下，也始终会设置返回值。遗漏案例并意外返回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的另一个“被忽略”功能是JVM本身。它可能是最好的虚拟机。它支持许多有趣且有用的语言（Jython，JRuby，Scala，Groovy）。所有这些语言都可以轻松无缝地协作。

如果您设计一种新的语言（例如在scala案例中），您将立即拥有所有现有的库，因此您的语言从一开始就是“有用的”。

所有这些语言都使用HotSpot优化。VM非常易于监视和调试。

您可以定义一个匿名子类并直接在其上调用方法，即使该类未实现任何接口。

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

中的asList方法java.util.Arrays可以很好地结合使用varargs，通用方法和自动装箱：

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

使用这个关键字从内部类访问包含类的字段/方法。在下面的示例中，我们想要使用匿名内部类中容器类的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;
}
}

并不是真正的功能，而是我最近在某些网页中发现的有趣技巧：

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

    System.exit(0);
  }
}

是有效的Java程序（尽管会生成警告）。如果您不明白为什么，请参阅格雷戈里的答案！;-)好吧，这里的语法高亮也给出了提示！

这并不是完全“隐藏的功能”，也不是很有用，但是在某些情况下可能非常有趣：
类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);
        }
    };
}

当在Swing我喜欢隐藏的工作Ctrl- Shift- F1功能。

它转储当前窗口的组件树。
（假设您尚未将该按键绑定到其他东西。）

每个类文件均以十六进制值0xCAFEBABE开头以将其标识为有效的JVM字节码。

（说明）

我的投票投给java.util.concurrent及其并发集合和灵活的执行程序，其中包括线程池，计划任务和协调任务。DelayQueue是我个人的最爱，其中元素在指定的延迟后可用。

java.util.Timer和TimerTask可以安全地停下来。

另外，不是完全隐藏，而是与其他与日期和时间相关的类位于不同的包中。在纳秒，微秒，毫秒和秒之间进行转换时，java.util.concurrent.TimeUnit非常有用。

它的读取结果比通常的someValue * 1000或someValue / 1000好得多。

语言级别的assert关键字。

Sun的JDK附带的javap反汇编程序并不是Java语言的真正组成部分，尚未广为人知或使用。

在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文档

我个人发现java.lang.Void得很晚-与泛型一起提高了代码的可读性，例如Callable<Void>