Java完美equals()方法的实现

本文源码已过时，最终版本请前往https://github.com/LitnhJacuzzi/Clone-and-Equals

有了完美克隆（参考https://blog.csdn.net/LitnhJacuzzi/article/details/118835020）的实现经验，与之相生的完美equals()方法应该也能比较容易地实现。但两者其实略有不同，具体请看下面的源码解析：

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;

import clone.PerfectClone;

public class PerfectEquals 
{
	private static IArrayList comparedObjects = new IArrayList();
	
	public static <T, U> boolean equals(T o1, U o2) {
		if(o1 == null || o2 == null) return (o1 == o2);
		
		if(o1.getClass() != o2.getClass()) return false;
		
		if(canDirectlyCompare(o1.getClass())) return (o1 == o2);
		
		if(isPackagingClass(o1.getClass())) 
			return o1.equals(o2);
		
		if(o1.getClass() == Object.class) return true;
		
		if(comparedObjects.indexOf(o1) != -1) return true;
		
		if(o1.getClass().isArray()) {
			if(Array.getLength(o1) != Array.getLength(o2)) return false;
			
			comparedObjects.add(o1);
			
			for(int i = 0; i < Array.getLength(o1); i++) {
				if(!equals(Array.get(o1, i), Array.get(o2, i))) return false;
			}
			
			return true;
		}
		
		comparedObjects.add(o1);
		
		ArrayList<Field> fields = new ArrayList<Field>();
		Class<?> iterator = o1.getClass();
		hackPackage(iterator);
		do {
			hackPackage(iterator);
			fields.addAll(Arrays.asList(iterator.getDeclaredFields()));
		}while((iterator = iterator.getSuperclass()) != Object.class);
		
		for(Field field : fields) {
			try {
				if(!Modifier.isStatic(field.getModifiers())) {
					field.setAccessible(true);
					if(!equals(field.get(o1), field.get(o2))) return false;
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		return true;
	}
	
	private static boolean canDirectlyCompare(Class<?> targetClass) {
		if(targetClass.isPrimitive() || (targetClass == String.class) || (targetClass == Class.class) ||
				(targetClass.isEnum()))
			return true;
		return false;
	}
	
	private static boolean isPackagingClass(Class<?> targetClass) {
		if((targetClass == Character.class) ||
				(targetClass == Boolean.class) || (targetClass == Byte.class) ||
				(targetClass == Integer.class) || (targetClass == Long.class) ||
				(targetClass == Float.class) || (targetClass == Double.class))
			return true;
		return false;
	}
	
	private static void hackPackage(Class<?> targetClass) {
		try {
			Method addOpens = Module.class.getDeclaredMethod("implAddExportsOrOpens", 
					String.class, Module.class, boolean.class, boolean.class);
			addOpens.setAccessible(true);
			addOpens.invoke(targetClass.getModule(), targetClass.getPackageName(), PerfectClone.class.getModule(), true, true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	private static class IArrayList extends ArrayList<Object>
	{
		/**
		 * 
		 */
		private static final long serialVersionUID = 962042845135067366L;

		@Override
		public int indexOf(Object o) {
			for(int i = 0 ; i < size(); i++) {
				if(o == get(i)) {
					return i;
				}
			}
			return -1;
		}
	}
}

从源码中不难看出，完美equals()方法的基本逻辑与完美克隆是一致的，只不过将对象克隆的操作转化为了真假判断。不过，细心观察可以发现，与完美克隆中canDirectlyClone()方法对应的canDirectlyCompare()方法被分离出了一部分变成isPackagingClass()方法，这么做的原因是虽然包装类型能直接浅克隆（实际上是由于包装类所包装的基本类型是final字段，正常情况下直接克隆不会有任何影响），但是比较包装类对象时，由于包装类本身是引用类型，大多数情况下会直接返回false，这显然不符合我们的要求。这时，包装类中重写的equals()方法可以直接满足要求，于是直接单独判定。