一些我认为有用有趣的 JDK 方法

在学习JDK的源码过程中我遇到了一些有趣有用的方法，在此之前如果要使用这些工具方法，我首先会想到的是 commons - lang 和 guava 这样的 语言扩展包 ，但现在如果是写一些demo，使用原生即可达到目的。当然我们也不能否认它们的作用，在平时的工作项目中几乎都会引入这些 语言扩展包 ，直接使用他们也使得编程风格统一，而且还能够对低版本的JDK提供支持。

以下收集的代码片段可能会逐渐增加，也可能不会。

java.util.Objects

java . util . Objects 工具类，我觉得好用的几个方法：

    public static boolean equals(Object var0, Object var1) {
        return var0 == var1 || var0 != null && var0.equals(var1);
    }
    public static int hashCode(Object var0) {
        return var0 != null ? var0.hashCode() : 0;




    
    }
    public static <T> T requireNonNull(T var0) {
        if (var0 == null) {
            throw new NullPointerException();
        } else {
            return var0;
        }
    }
    public static <T> T requireNonNull(T var0, String var1) {
        if (var0 == null) {
            




    
throw new NullPointerException(var1);
        } else {
            return var0;
        }
    }        

除此之外还应该从 Objects 学习到编写工具类的正确的规范：

• 定义为final class

• 只定义一个无参的构造函数且抛出断言错误，防止被反射调用

• 工具方法都是静态方法

• 静态方法中只抛出unchecked异常

java.lang.System

这个最早应该是在Hello World程序中见到的，推荐它的一个方法：

    /**
     * Returns the same hash code for the given object as
     * would be returned by the default method hashCode(),
     * whether or not the given object's class overrides
     * hashCode().
     * The hash code for the null reference is zero.
     *
     * @param x object for which the hashCode is to be calculated
     * @return  the hashCode
     * @since   JDK1.1
     */
    public static 




    
native int identityHashCode(Object x);

注释写得很明白了，不管一个对象实例的class有没有覆盖Object的hashCode方法，都能使用这个方法获得hash值。

获取泛型类的类型参数

我们可以从以下代码获得提示，代码来自 HashMap ：

    /**
     * Returns x's Class if it is of the form "class C implements
     * Comparable", else null.
     */
    static Class> comparableClassFor(Object x) {
        if (x instanceof Comparable) {
            Class> c; Type[] ts, as; Type t; ParameterizedType p;
            if ((c = x.getClass()) == String.class) // bypass checks
                




    
return c;
            if ((ts = c.getGenericInterfaces()) != null) {
                for (int i = 0; i < ts.length; ++i) {
                    if (((t = ts[i]) instanceof ParameterizedType) &&
                        ((p = (ParameterizedType)t).getRawType() ==
                         Comparable.class) &&
                        (as = p.getActualTypeArguments()) != 




    
null &&
                        as.length == 1 && as[0] == c) // type arg is c
                        return c;
                }
            }
        }
        return null;
    }

这里的逻辑是获得类 C ，然后获取它实现的接口 Comparable < C > ，然后从这个 Comparable < C > 中获得类型参数 C ，然后比较这两个类型是否相等。虽然我们一直听说Java的泛型是类型擦除式，但是在这里我们是可以获得泛型的参数类型的。照例用一段demo测试一下：

public class ParameterApp {
    public static void main(




    
String[] args) {
        StringList list = new StringList();
        Class> clazz = getTypeArgument(list);
        System.out.println(clazz.getName());
    }
    static Class> getTypeArgument(Object x) {
        if (x instanceof Collection) {
            Class> c = x.getClass();
            Type[] ts, as; Type t; ParameterizedType p;




    
            if ((ts = c.getGenericInterfaces()) != null) {
                for (int i = 0; i < ts.length; ++i) {
                    if (((t = ts[i]) instanceof ParameterizedType) &&
                            ((as  = ((ParameterizedType)t).getActualTypeArguments()) != null)
                             &&
                            as.length == 1) // type arg is c
                        return (Class>)




    
 as[0];
                }
            }
        }
        return null;
    }
    static class StringList extends AbstractList<String> implements List<String> {
        @Override
        public String get(int i) {
            return null;
        }
        @Override
        




    
public int size() {
            return 0;
        }
    }
}

sun.reflect.Reflection

这个工具类是和反射相关的，让大家知道有这么一个方法：

    @CallerSensitive
    public static native Class> getCallerClass();

我第一次见到这个方法是在 java . sql . DriverManager 中的 getConnection 方法中见到的：

    @CallerSensitive
    public static Connection getConnection(String url,
        String user, String password) throws SQLException {
        java




    
.util.Properties info = new java.util.Properties();
        if (user != null) {
            info.put("user", user);
        }
        if (password != null) {
            info.put("password", password);
        }
        return (getConnection(url, info, Reflection.getCallerClass()));
    }

Reflection . getCallerClass () 是一个 native 方法，返回的是 Class > 类型，在 DriverManager 中使用它的目的是为了获得相应的 ClassLoader ，上面的代码是在Java 8中见到的。其中在Java 7中为获得 ClassLoader ， DriverManager 就直接提供了 native 的方法：

/* Returns the caller's class loader, or null if none */
private static native ClassLoader getCallerClassLoader();

我们用一段代码尝试调用这个方法：

public class CalleeApp {
    public void call() {
        Class> clazz = Reflection.getCallerClass();