博客

深入学习java源码之Objects.deepEquals()与Objects.nonNull()

不定长度参数

如果一个方法的参数定为不定参数的话，这个参数可以根据参数个数动态生成一个数组，然后传入方法执行。 
不过，不定参数有两个规定：第一，方法的参数列表中最多只有一个不定长度的参数；第二，就是不定长度的数组的位置必须是最后一个参数。不然不能通过编译。 

    public static void main(String[] args) {  
        test("aaa");  
        test("aaa", "bbb");  
        test("aaa", "bbb", "ccc");  
    }  

    public static void test(String arg, String... args) {  
        System.out.println(arg);  
        System.out.println("----------------");  
        for (String s : args) {  
            System.out.println(s);  
        }  
    } 

supplier函数式接口

supplier也是是用来创建对象的，但是不同于传统的创建对象语法：new，看下面代码

public class TestSupplier {
	private int age;
	
	TestSupplier(){
		System.out.println(age);
	}
	public static void main(String[] args) {
		//创建Supplier容器，声明为TestSupplier类型，此时并不会调用对象的构造方法，即不会创建对象
		Supplier<TestSupplier> sup= TestSupplier::new;
		System.out.println("--------");
		//调用get()方法，此时会调用对象的构造方法，即获得到真正对象
		sup.get();
		//每次get都会调用构造方法，即获取的对象不同
		sup.get();
	}

--------
0
0

Supplier<TestSupplier> sup= TestSupplier::new;每次调用get()方法时才创建对象，且返回的对象不一样

java源码

package java.util;

import java.util.function.Supplier;

public final class Objects {
    private Objects() {
        throw new AssertionError("No java.util.Objects instances for you!");
    }
	
    public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }	
	
    public static boolean deepEquals(Object a, Object b) {
        if (a == b)
            return true;
        else if (a == null || b == null)
            return false;
        else
            return Arrays.deepEquals0(a, b);
    }	
	
    public static int hashCode(Object o) {
        return o != null ? o.hashCode() : 0;
    }	
	
    public static int hash(Object... values) {
        return Arrays.hashCode(values);
    }	
	
    public static String toString(Object o) {
        return String.valueOf(o);
    }	
	
    public static String toString(Object o, String nullDefault) {
        return (o != null) ? o.toString() : nullDefault;
    }	
	
    public static <T> int compare(T a, T b, Comparator<? super T> c) {
        return (a == b) ? 0 :  c.compare(a, b);
    }	
	
    public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

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

    public static boolean isNull(Object obj) {
        return obj == null;
    }

    public static boolean nonNull(Object obj) {
        return obj != null;
    }

    public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) {
        if (obj == null)
            throw new NullPointerException(messageSupplier.get());
        return obj;
    }
}	

package java.util.function;

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}