【java筑基】深入不可变类——谈谈String与包装类的底层实现

public class Address {
	private final String detail;
	private final String postCode;
	public Address() {
		detail="";
		postCode="";
	}
	public Address(String detail, String postCode) {
		super();
		this.detail = detail;
		this.postCode = postCode;
	}
	public String getDetail() {
		return detail;
	}
	public String getPostCode() {
		return postCode;
	}
	
	public boolean equals(Object obj){
		if(this==obj) return true;
		if(obj!=null&&(obj.getClass()==Address.class)){
			Address ad=(Address)obj;
			if(ad.getDetail().equals(this.getDetail())&&ad.getPostCode().equals(this.getPostCode())){
				return true;
			}
		}
		return false;
	}
	
	public int hashcode(){
		return detail.hashCode()+postCode.hashCode()*31;
	}
}

class Name {
	private String firstName;
	private String lastName;

	public Name() {
	}

	public Name(String firstName, String lastName) {
		super();
		this.firstName = firstName;
		this.lastName = lastName;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

}

public class Person {
	private final Name name;

	public Name getName() {
		return name;
	}

	public Person(Name name) {
		super();
		this.name = name;
	}

	public static void main(String[] args) {
		Name name = new Name("悟空", "孙");
		Person p = new Person(name);
		// 输出悟空
		System.out.println(p.getName().getFirstName());
		name.setFirstName("八戒");
		// 输出八戒
		System.out.println(p.getName().getFirstName());
	}
}

public class Person {
	private final Name name;

	public Name getName() {
		// 返回一个成员变量name的副本
		return new Name(name.getFirstName(), name.getFirstName());
	}

	public Person(Name name) {
		super();
		// 创建一个新的name副本，使其与形参name的FirstName,lastName值相同
		this.name = new Name(name.getFirstName(), name.getFirstName());
	}
}

ublic class CacheImmutale {
	private static int MAX_SIZE = 10;
	private static CacheImmutale[] Cache = new CacheImmutale[MAX_SIZE];
	// 用来记录实例在缓存中的位置，CacheImmutale[pos-1]为最新的缓存实例
	private static int pos = 0;
	private final String name;

	public String getName() {
		return name;
	}

	private CacheImmutale(String name) {
		super();
		this.name = name;
	}

	public static CacheImmutale valueof(String name) {
		// 如果存在该实例，则返回该实例
		for (int i = 0; i < MAX_SIZE; i++) {
			if (Cache[i] != null && Cache[i].getName().equals(name)) {
				return Cache[i];
			}
		}
		// 如果缓冲池满了，则把实例放入缓冲池数组最开始,pos置1
		if (pos == MAX_SIZE) {
			Cache[0] = new CacheImmutale(name);
			pos = 1;
		}
		// 创建实例加入缓冲池,pos加1
		else {
			Cache[pos++] = new CacheImmutale(name);
		}
		return Cache[pos - 1];
	}
	@Override
	public int hashCode() {
		return name.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj != null && (obj.getClass() == CacheImmutale.class)) {
			CacheImmutale cache = (CacheImmutale) obj;
			if (cache.getName().equals(this.getName())) {
				return true;
			}
		}
		return false;
	}

	public static void main(String[] args) {
		CacheImmutale c1 = CacheImmutale.valueof("张三");
		CacheImmutale c2 = CacheImmutale.valueof("张三");
		//输出true
		System.out.println(c1 == c2);
	}
}

public class WrapClassCompare {
	public static void main(String[] args) {
		Integer it1 = new Integer(5);
		// 基本数据类型和包装类型进行比较,比较值,顺利进行,true
		System.out.println(it1 == 5);

		Integer it2 = new Integer(5);
		// 两个引用类型数据,比较的是地址，false
		System.out.println(it1 == it2);

		// 通过自动装箱把基本类型数据赋值给引用类型数据
		Integer it3 = 5;
		Integer it4 = 5;
		// 输出true，这是因为-128~127的Integer类型数据自动装箱数据时，会直接引用Integer[]类型的cache数组中元素
		System.out.println(it3 == it4);

		Integer it5 = 128;
		Integer it6 = 128;
		//输出false,Integer的cache数组存放容量有限，只存放-128~127
		System.out.println(it5 == it6);
	}
}