Java学习笔记20

Objects是Java 7新增的一个工具类，它提供了一些工具方法来操作对象，这些工具方法大多是“空指针”安全的。

Objects实现的方法如下：

关于compare(T,T,Comparator)方法在源码中是如何定义的：

 public static  int compare(T a, T b, Comparator c) {
        return (a == b) ? 0 :  c.compare(a, b);
    }

以上使用 定义了一个泛型方法，关于和类型形参 T的说明在后续讲解泛型时会提到。

在这里传入两个对象a和b，并创建一个Comparator接口实现类的对象，其中Comparator接口定义了以下方法：

int compare(T o1, T o2);

boolean equals(Object obj);

因此compare方法中先是判断对象a和对象b是否相等，如果相等的话，返回0，不相等时，通过Comparator接口实现

compare(a,b)方法。

我们来看看在实际生活中是如何定义的：

class User {
	
    public String name;
    public int age;
    
    public User(String name,int age){
    	this.name=name;
    	this.age=age;
    }
    
    protected String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
    	return "name="+name+"\nage="+age;
    }
    


}
public class Main {
	public User user1,user2;
	
	public static void main(String[] args) {
		new Main().init();
	}
	
	public void init(){
		User user1=new User("Aill", 25); 
		User user2=new User("Cill", 24);  
		int compare=Objects.compare(user1, user2,new Comparator () {
			
			@Override
			public int compare(User o1, User o2) {
				
				return o1.name.compareToIgnoreCase(o2.name);
			}
			
		
		});
		System.out.println(compare);
	}
}

输出：

-2

在上面的程序中，实现了compare(a,b)方法，因此，我们可以在此方法中，自定义一些判断两个对象大小的方法，以

上是通过o1和o2的name来比较，compareToIgnoreCase(String str)方法是java.lang.String类下的方法，作用是按字

典顺序比较两个字符串，不考虑大小写。

String类也实现了Comparable接口：

public final class String
    implements java.io.Serializable, Comparable, CharSequence 

在String类中compareToIgnoreCase(String str)方法：

 public int compareToIgnoreCase(String str) {
        return CASE_INSENSITIVE_ORDER.compare(this, str);
    }

public static final Comparator CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    private static class CaseInsensitiveComparator
            implements Comparator, java.io.Serializable {
        // use serialVersionUID from JDK 1.2.2 for interoperability
        private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(i);
                char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }

        /** Replaces the de-serialized object. */
        private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
    }

以上定义了一个静态内部类CaseInsensitiveComparator并实现了 Comparable接口中的compare(String s1,

 String s2)方法，Math.min(n1, n2)是将两个int值较小的那个返回。通过for循环，根据charAt(int index)方法获取指定

索引处的char值。最后通过Character.toUpperCase和Character.toLowerCase将char转换成大写和小写后再判断是否

相等，如果还不相等，就返回它们两个ASCII码相减后的值，否则两个char值相等，返回0。

转载请注明出处：http://blog.csdn.net/hai_qing_xu_kong/article/details/43940265   情绪控_