Singleton / 不可变类 / 缓存不可变类 的实现

Singleton（单例类）

单例类用的地方很多，如果一个类始终只能创建一个实例，则这个类被称为单例类。

以下程序是创建一个单例类：

public class SingletonTest {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
        s1.setName("Singleton1");
        System.out.println("s1 = " + s1.getName());
        System.out.println("s2 = " + s2.getName());
        s2.setName("Singleton2");
        System.out.println("s1 = " + s1.getName());
        System.out.println("s2 = " + s2.getName());
    }
}
class Singleton {
    private String name;
    private static Singleton singleton = new Singleton("default");
    private Singleton(String name) {
        this.name = name;
    }
    public static Singleton getInstance() {
        return singleton;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
}

不可变类

不可变类就是在创建该类的实例后不能更改该类的属性。Java提供的8个包装类和java.lang.String都是不可变类。

创建不可变类的几个规则：

• 使用private 和 final 修饰符修饰属性；
• 提供带参数的构建起，用于初始化属性值；
• 只提供getter方法；
• 重写hashCode 和 equlas方法；

/**
 * Person 类是一个不可变类
 * @author wangmin
 *
 */
public class Person {
    private final String name;
    private final int age;
    public Person() {
        this.name = "";
        this.age = 0;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return this.name;
    }
    public int getAge() {
        return this.age;
    }
    public boolean equlas (Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj != null && obj.getClass() == this.getClass()) {
            Person p = (Person)obj;
            if (this.getName().equals(p.getName()) && this.age == p.getAge()) {
                return true;
            }
        }
        return false;
    }
    public int hasCode() {
        return name.hashCode() + age;
    }
}

缓存不可变类

如果程序经常需要使用相同的不可变类实例，则应该考虑缓存这种不可变类。下面是简单的使用数组的方式实现一个不可变类。

/**
 * 使用数组的方式来缓解Person
 * 1. 定义数组大小，并且使用private static 修饰
 * 2. 定义valueOf方法获取对象，但是其中存在以下几种情况：
 *  2.1 循环遍历整个缓存数组的大小，然后比较，如果已经被缓存则直接取出。（注意数组元素可能为null）
 *  2.2 由2.1的结果可知，如果数组中没有则新创建。
 *  2.3 首次判断pos是否已满，如果已满则将新的对象创建到数组0的位置，并且将pos设置为0，并返回。
 *  2.4 如果没有满则根据pos的位置创建，并返回。
 * @author wangmin
 *
 */
public class CachePerson {
    private static int MAX_SIZE = 10;
    private static CachePerson[] cp = new CachePerson[MAX_SIZE];
    private String name;
    private static int pos = 0;
    
    public CachePerson() {
        
    }
    public CachePerson(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public static CachePerson valueOf(String name) {
        for (int i = 0; i < MAX_SIZE; i++) {
            if (cp[i] != null && cp[i].getName().equals(name)) {
                return cp[i];
            }
        }
        if (pos == MAX_SIZE) {
            cp[0] = new CachePerson(name);
            pos = 1;
        } else {
            cp[pos++] = new CachePerson(name);
        }
        return cp[pos-1];
    }
    public boolean equlas (Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj != null && obj.getClass() == this.getClass()) {
            CachePerson cp = (CachePerson)obj;
            if (cp.getName().equals(this.getName())) {
                return true;
            }
        }
        return false;
    }
    public int hasCode() {
        return name.hashCode();
    }
}