`
peterwei
  • 浏览: 250360 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

设计模式之不变模式(Immutable Pattern)分析

设计模式多线程BeanGoSpring 
阅读更多
最近老有人问我不变模式，我其实也理解得不深，于是花了一些时间进行学习总结，分析了一下不变模式(immutable pattern)，和大家一起分享。说得不对的地方欢迎拍砖，谢绝谩骂。姐妹篇：精通有状态vs无状态(Stateful vs Stateless).http://www.iteye.com/topic/960532
不变模式（immutable pattern）

一个类的内部状态创建后，在整个生命期间都不会发生变化时，就是不变类。这种使用不变类的做法叫做不变模式。

不变模式有两种形式：一种是弱不变模式，另一种是强不变模式。

弱不变模式：
一个类的实例的状态是不可变化的，但是这个类的引用的实例具有可能会变化的状态。这样的类符合弱不变模式的定义。要实现弱不变模式，一个类必须满足如下条件：

    第一，对象没有任何方法会修改对象的状态，当对象的构造函数对对象的状态初始化之后，对象的状态便不再改变。

    第二，所有的属性都应当是私有的，以防客户端对象直接修改任何的内部状态。

    第三，这个对象所引用的对象如果是可变对象的话，必须设法限制外界对这个对象的访问，以防止对这些对象的修改。如果可能应该尽量在不变对象的内部来初始化。

    弱不变模式的缺点是：
一个弱不变对象引用的实例变量可以是可变对象，可能会通过外界修改父对象的状态，这是一个显著的缺点。可以在初始化可变对象时，先进行clone。

代码演示： 
/**
 * @author Peter Wei
 * 
 */
public class User {

	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

/**
 * 弱不变模式
 * 
 * @author Peter Wei
 * 
 */
public class WeakImmutable {

	// 属性私有，满足条件2
	private int state;
	// 属性私有，满足条件2
	private User user;

	private Integer age;

	public WeakImmutable(int state, User user, Integer age) {
		this.state = state;
		this.user = user;
		this.age = age;
	}

	public int getState() {
		return this.state;
	}

	public User getUser() {
		return this.user;
	}

	public Integer getAge() {
		return this.age;
	}

	public void setState() {
		// 对象没有任何方法修改对象的状态,满足条件1
		// do nothing.
	}

	public static void main(String[] args) {
		int state = 0;
		User u = new User();
		Integer age = 100;
		u.setName("yes");
		WeakImmutable weak = new WeakImmutable(state, u, age);
		System.out.println("原始值：" + weak.getState() + ","
				+ weak.getUser().getName() + "," + weak.getAge());
		// 修改引用后
		state = 5;
		// User由于是可变对象引用，所以有影响
		u.setName("no");
		age = 200;
		System.out.println("修改引用后：" + weak.getState() + ","
				+ weak.getUser().getName() + "," + weak.getAge());
	}
}
结果：可以看到user的名字会改变。
原始值：0,yes,100
修改引用后：0,no,100

我们再引伸一个不可变类的例子:
在时间截止时，我们需要一一检查队列成员是不是vip,如果是可以去USA.假设是多线程环境,并且users数组是多线程共享,那么另外的线程通过users去修改users[n],这时就会把users[n]绕过时间检查而去USA. 

/**
 * 不变模式之clone
 * 
 * @author Peter Wei
 * 
 */
public class WeakImmutableClone {

	public static void main(String[] args) {

		User[] users = new User[3];
		users[0] = new User();
		users[0].setName("peterwei");
		users[1] = new User();
		users[1].setName("Tomssssss");
		users[2] = new User();
		users[2].setName("peterwei88");

		time4Check();
		/*
		 * 时间到，我们需要一一检查队列成员是不是vip,如果是可以去USA.假设是多线程环境,并且users数组是多线程共享,
		 * 那么另外的线程通过users去修改users[n],这时就会把users[n]绕过时间检查而去USA.
		 */
		goUSA(users);

	}

	public static void goUSA(User[] users) {

		// User[] tmp = new User[users.length];
		// System.arraycopy(users, 0, tmp, 0, users.length);

		for (User u : users) {
			if (checkVip(u)) {
				System.out.println("You can go!");
			} else {
				System.out.println("go away!");
			}

		}
	}

	public static boolean checkVip(User user) {
		if (user.getName().startsWith("peterwei")) {
			return true;
		}
		return false;
	}

	public static void time4Check() {
		// 假设时间期限到，要检查上万人以上的队列。
	}
}

解决方法：
在事务处理及数据大批量入库的多线程环境中，应该也会有类似的问题。所以对于这样的传入参数及上例中的不变对象引用可变对象,我们可以将其在相关构造函数及方法中复制为本地变量(数组),及使用它的深度clone,阻止相关数据与外部线程的联系。 

	public static void goUSA(User[] users) {

		User[] tmp = new User[users.length];
		System.arraycopy(users, 0, tmp, 0, users.length);

		for (User u : tmp) {
			if (checkVip(u)) {
				System.out.println("You can go!");
			} else {
				System.out.println("go away!");
			}

		}
	}

强不变模式：

    一个类的实例的状态不会改变，同时它的子类的实例也具有不可变化的状态。这样的类符合强不变模式。要实现强不变模式，一个类必须首先满足弱不变模式所要求的所有条件，并且还要满足下面条件之一：
    第一，所考虑的类所有的方法都应当是final，这样这个类的子类不能够置换掉此类的方法。
    第二，这个类本身就是final的，那么这个类就不可能会有子类，从而也就不可能有被子类修改的问题。

不变模式在Java中的应用
如String类 
		String a = "123" ;
		String a1 = "123" ;
		String a2 = "123" ;
		String a3 = "1234" ;

java虚拟机只会创建一个字符串实例，a,a1,a2对象共享一个值。遇到不同的字符串，java虚拟机会再创建一个String对象，如a3。如果程序所处理的字串有频繁的内容变化，就不宜使用String类型，而应当使用StringBuffer类型，如果需要对字串做大量的循环查询，也不宜使用String类型，应当考虑使用byte或char数组.

其它不变类：
The Integer,String, Float, Double, Byte, Long, Short, Boolean, and Character classes are all examples of an immutable class. By definition, you may not alter the value of an immutable object after its construction.In Java, a class such as Integer acts as a simple wrapper around its primitive counterpart -- in this case, int. The wrappers found in java.lang allow us to treat the primitives as if they were objects. So, for example, you could not put an int into a Vector without wrapping it。

优缺点：
不变模式可增强对象的健壮性。不变模式允许多个对象共享某一对象，降低了对该对象进行并发访问时的同步化开销。唯一缺点是一旦需要修改一个不变对象的状态，就只好创建一个新的同类对象，在需要频繁修改不变对象的环境里，会有大量的不变对象作为中间结果被创建出来，再被Java的垃圾收集器收走，这是一种资源的浪费。

总结：
不变模式的核心就是对象不变，从而引伸出对象复用共享的思想。如无状态的单例模式，享元(Flyweight)模式及原型模式(Prototype)都可以认为是不变模式的应用。其它如线程池，缓存等的实现也一定程度上是使用不变模式。还有EJB的Stateless Session Bean(无状态会话bean),Spring对Service层、Dao层bean的默认单例实现，我认为都是沿用了不变模式中共享的思想。
分享到：
| UML用例图之泛化(generalization)、扩展(e ...
评论
16 楼 peterwei 2011-03-17  
nianien 写道
peterwei 写道
nianien 写道
gtssgtss 写道
private 一反射一下就被X了，怎么不变

你这真是强词夺理,按你那么说,我还可以动态改变JAVA CODE 去掉它的final属性,甚至类的定义,懂一点点反射,显摆啥啊

我的意思不是说反射。
我是说如果只是private,那么只是弱不变类。 
    public static void main(String[] args) {   
        int state = 0;   
        User u = new User();   
        Integer age = 100;   
        u.setName("yes");   
        WeakImmutable weak = new WeakImmutable(state, u, age);   
        System.out.println("原始值：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());   
        // 修改引用后   
        state = 5;   
        // User由于是可变对象引用，所以有影响   
        u.setName("no");   
        age = 200;   
        System.out.println("修改引用后：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());   
    }


结果：可以看到user的名字会改变。
原始值：0,yes,100
修改引用后：0,no,100

user在外部改变时，WeakImmutable里的private user属性因为是引用对实例对象，所以也跟着改变了。

我说的只读和你的不变类型一样有两成意思
这里,你对外开放的接口不要是User getUser(),而是改为String getUserName(){return user.getName()},这样不就可以了
我理解你的意思,只读的引用对象,其属性是可以改变的,而我的意思是,如果是引用对象,那么你就返回他的不可变的属性,而不要直接把对象返回

你占这个牛角尖干嘛呢。现在这个例子是弱不变类，我要想改成强不变类，我直接加上final不就完事了嘛。哪还要再加一个方法。你所说的对外再给一个普通属性的获取方法再封一层方法，这本来就不符合设计和重构的原则。
15 楼 gtssgtss 2011-03-17  
nianien 写道
peterwei 写道
nianien 写道
gtssgtss 写道
private 一反射一下就被X了，怎么不变

你这真是强词夺理,按你那么说,我还可以动态改变JAVA CODE 去掉它的final属性,甚至类的定义,懂一点点反射,显摆啥啊

我的意思不是说反射。
我是说如果只是private,那么只是弱不变类。 
    public static void main(String[] args) {   
        int state = 0;   
        User u = new User();   
        Integer age = 100;   
        u.setName("yes");   
        WeakImmutable weak = new WeakImmutable(state, u, age);   
        System.out.println("原始值：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());   
        // 修改引用后   
        state = 5;   
        // User由于是可变对象引用，所以有影响   
        u.setName("no");   
        age = 200;   
        System.out.println("修改引用后：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());   
    }


结果：可以看到user的名字会改变。
原始值：0,yes,100
修改引用后：0,no,100

user在外部改变时，WeakImmutable里的private user属性因为是引用对实例对象，所以也跟着改变了。

我说的只读和你的不变类型一样有两成意思
这里,你对外开放的接口不要是User getUser(),而是改为String getUserName(){return user.getName()},这样不就可以了
我理解你的意思,只读的引用对象,其属性是可以改变的,而我的意思是,如果是引用对象,那么你就返回他的不可变的属性,而不要直接把对象返回


传入的时候，把参数clone，然后clone的对象赋值给field
传出的时候，再clone一次对象，这样就可以了。
14 楼 nianien 2011-03-17  
peterwei 写道
nianien 写道
gtssgtss 写道
private 一反射一下就被X了，怎么不变

你这真是强词夺理,按你那么说,我还可以动态改变JAVA CODE 去掉它的final属性,甚至类的定义,懂一点点反射,显摆啥啊

我的意思不是说反射。
我是说如果只是private,那么只是弱不变类。 
    public static void main(String[] args) {   
        int state = 0;   
        User u = new User();   
        Integer age = 100;   
        u.setName("yes");   
        WeakImmutable weak = new WeakImmutable(state, u, age);   
        System.out.println("原始值：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());   
        // 修改引用后   
        state = 5;   
        // User由于是可变对象引用，所以有影响   
        u.setName("no");   
        age = 200;   
        System.out.println("修改引用后：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());   
    }


结果：可以看到user的名字会改变。
原始值：0,yes,100
修改引用后：0,no,100

user在外部改变时，WeakImmutable里的private user属性因为是引用对实例对象，所以也跟着改变了。

我说的只读和你的不变类型一样有两成意思
这里,你对外开放的接口不要是User getUser(),而是改为String getUserName(){return user.getName()},这样不就可以了
我理解你的意思,只读的引用对象,其属性是可以改变的,而我的意思是,如果是引用对象,那么你就返回他的不可变的属性,而不要直接把对象返回
13 楼 peterwei 2011-03-16  
nianien 写道
gtssgtss 写道
private 一反射一下就被X了，怎么不变

你这真是强词夺理,按你那么说,我还可以动态改变JAVA CODE 去掉它的final属性,甚至类的定义,懂一点点反射,显摆啥啊

我的意思不是说反射。
我是说如果只是private,那么只是弱不变类。 
    public static void main(String[] args) {   
        int state = 0;   
        User u = new User();   
        Integer age = 100;   
        u.setName("yes");   
        WeakImmutable weak = new WeakImmutable(state, u, age);   
        System.out.println("原始值：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());   
        // 修改引用后   
        state = 5;   
        // User由于是可变对象引用，所以有影响   
        u.setName("no");   
        age = 200;   
        System.out.println("修改引用后：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());   
    }


结果：可以看到user的名字会改变。
原始值：0,yes,100
修改引用后：0,no,100

user在外部改变时，WeakImmutable里的private user属性因为是引用对实例对象，所以也跟着改变了。
12 楼 nianien 2011-03-16  
gtssgtss 写道
private 一反射一下就被X了，怎么不变

你这真是强词夺理,按你那么说,我还可以动态改变JAVA CODE 去掉它的final属性,甚至类的定义,懂一点点反射,显摆啥啊
11 楼 EyejavaLi 2011-03-15  
nianien 写道
peterwei 写道
    一个类的实例的状态不会改变，同时它的子类的实例也具有不可变化的状态。这样的类符合强不变模式。要实现强不变模式，一个类必须首先满足弱不变模式所要求的所有条件，并且还要满足下面条件之一：
    第一，所考虑的类所有的方法都应当是final，这样这个类的子类不能够置换掉此类的方法。
    第二，这个类本身就是final的，那么这个类就不可能会有子类，从而也就不可能有被子类修改的问题。

为什么必须是final呢?私有属性,只读方法不也可以么?



只读有可能因为其他状态的改变，对应的也会变，比如说人的年龄的只读的，但是随着时间变化它是会变的
10 楼 ilrxx 2011-03-15  
在多线程设计模式中，对该模式有全面的讲解
9 楼 gtssgtss 2011-03-15  
private 一反射一下就被X了，怎么不变
8 楼 nianien 2011-03-15  
peterwei 写道
nianien 写道
peterwei 写道
    一个类的实例的状态不会改变，同时它的子类的实例也具有不可变化的状态。这样的类符合强不变模式。要实现强不变模式，一个类必须首先满足弱不变模式所要求的所有条件，并且还要满足下面条件之一：
    第一，所考虑的类所有的方法都应当是final，这样这个类的子类不能够置换掉此类的方法。
    第二，这个类本身就是final的，那么这个类就不可能会有子类，从而也就不可能有被子类修改的问题。

为什么必须是final呢?私有属性,只读方法不也可以么?

就像上面说的那样呀。如果只是private,那么只是弱不变类。上面有分析的。

我觉得你的定义本身就不对,是否是强/弱不变类型,不应该定义具体的实现规则,而是定义表现行为
比如如下定义:

只要一个类的成员不变,那么就符合弱不变类型
一个弱不变类型,如果它的成员状态也不变化,那么它就是强不变类型
7 楼 sunheavenvan 2011-03-14  
其实不变模式，在scala上有很好的应用。个人认为这是一种逻辑哲学中的一种观点，认为对象是过眼云霄的。其实回到DDD上，这不变性的概念，有点类似ValueObject，不过ValueObject是你所说到的弱不变性，但因为值对象只能套值对象，不能套有状态的实体，所以不存在其内部子实体可改变一事，也就达到强不变了。

个人认为实体状态是不变性的表现，实体是可变性的表现。看到EntityForm就看到的是状态，而非实体。回归自然，是切合实际的想法。

以上个人观点，仅作交流。
6 楼 peterwei 2011-03-14  
nianien 写道
peterwei 写道
    一个类的实例的状态不会改变，同时它的子类的实例也具有不可变化的状态。这样的类符合强不变模式。要实现强不变模式，一个类必须首先满足弱不变模式所要求的所有条件，并且还要满足下面条件之一：
    第一，所考虑的类所有的方法都应当是final，这样这个类的子类不能够置换掉此类的方法。
    第二，这个类本身就是final的，那么这个类就不可能会有子类，从而也就不可能有被子类修改的问题。

为什么必须是final呢?私有属性,只读方法不也可以么?

就像上面说的那样呀。如果只是private,那么只是弱不变类。上面有分析的。 
    public static void main(String[] args) {   
        int state = 0;   
        User u = new User();   
        Integer age = 100;   
        u.setName("yes");   
        WeakImmutable weak = new WeakImmutable(state, u, age);   
        System.out.println("原始值：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());   
        // 修改引用后   
        state = 5;   
        // User由于是可变对象引用，所以有影响   
        u.setName("no");   
        age = 200;   
        System.out.println("修改引用后：" + weak.getState() + ","  
                + weak.getUser().getName() + "," + weak.getAge());   
    }


user在外部改变时，WeakImmutable里的private user属性也跟着改变了。
5 楼 peterwei 2011-03-14  
marmot 写道
解决方法：
在事务处理及数据大批量入库的多线程环境中，应该也会有类似的问题。所以对于这样的传入参数及上例中的不变对象引用可变对象,我们可以将其在相关构造函数及方法中复制为本地变量(数组),及使用它的深度clone,阻止相关数据与外部线程的联系。

Java代码  收藏代码

   1. public static void goUSA(User[] users) { 
   2.  
   3.     User[] tmp = new User[users.length]; 
   4.     System.arraycopy(users, 0, tmp, 0, users.length);  // 这样做的用意？
   5.  
   6.     for (User u : users) { 
   7.         if (checkVip(u)) { 
   8.             System.out.println("You can go!"); 
   9.         } else { 
  10.             System.out.println("go away!"); 
  11.         } 
  12.  
  13.     } 
  14. } 

复制出一个临时数组,却没有使用它,这是为什么呢,望赐教

没检查，是手误！哈哈。
4 楼 qingwaxw1980 2011-03-14  
模式的分析，似乎应该强调应用的场景。不能这样简单的说明吧。
3 楼 marmot 2011-03-14  
解决方法：
在事务处理及数据大批量入库的多线程环境中，应该也会有类似的问题。所以对于这样的传入参数及上例中的不变对象引用可变对象,我们可以将其在相关构造函数及方法中复制为本地变量(数组),及使用它的深度clone,阻止相关数据与外部线程的联系。

Java代码  收藏代码

   1. public static void goUSA(User[] users) { 
   2.  
   3.     User[] tmp = new User[users.length]; 
   4.     System.arraycopy(users, 0, tmp, 0, users.length);  // 这样做的用意？
   5.  
   6.     for (User u : users) { 
   7.         if (checkVip(u)) { 
   8.             System.out.println("You can go!"); 
   9.         } else { 
  10.             System.out.println("go away!"); 
  11.         } 
  12.  
  13.     } 
  14. } 

复制出一个临时数组,却没有使用它,这是为什么呢,望赐教
2 楼 nianien 2011-03-14  
peterwei 写道
    一个类的实例的状态不会改变，同时它的子类的实例也具有不可变化的状态。这样的类符合强不变模式。要实现强不变模式，一个类必须首先满足弱不变模式所要求的所有条件，并且还要满足下面条件之一：
    第一，所考虑的类所有的方法都应当是final，这样这个类的子类不能够置换掉此类的方法。
    第二，这个类本身就是final的，那么这个类就不可能会有子类，从而也就不可能有被子类修改的问题。

为什么必须是final呢?私有属性,只读方法不也可以么?
1 楼 horse88sky 2011-03-13  
immutable模式应该是多线程设计模式之一吧。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java多线程设计模式详解(PDF及源码)

    本书浅显易懂的介绍了JAVA线程相关的设计模式，通过程序范例和UML图示来一一解说，书中代码的重要部分加了标注以使读者更加容易理解，再加上图文并茂，对于初学者还是程序设计高手来说，这都是一本学习和认识JAVA...

    源码：阎宏设计模式光盘

    com.javapatterns.immutable 不变模式 com.javapatterns.interfaces Java接口 com.javapatterns.interpreter 解释器模式 com.javapatterns.isp 接口隔离原则 com.javapatterns.iterator 迭代子模式 ...

    Immutable详解及React中实践.pdf

    Immutable 的实现原理是 Persistent Data Structure（持久化数据结构），即使用旧数据创建新数据时，要保证旧数据同时可用且不变。同时，Immutable 使用了 StructuralSharing（结构共享），即如果对象树中一个节点...

    技术分享之immutable.js.pptx

    简单介绍Immutable.js的一个ppt，主要用于技术分享，内容为imuutabe常用的数据类型和常用的基础api，还有immutable的原理、优缺点的分析。

    Android设计模式原型模式应用简单Demo

    原型模式（Prototype Pattern）作为GOF设计模式之一，是一种创建型模式，它提供了一种复制已有对象而不必知道其具体类别的方法。在这个“Android设计模式原型模式应用简单Demo”中，我们将探讨如何在Android环境中...

    82丨开源实战三（中）：剖析GoogleGuava中用到的几种设计模式1

    在本篇中，我们将深入探讨Guava中使用的三种设计模式：Builder模式、Wrapper模式以及Immutable模式。 ### 1. Builder模式 Builder模式在Guava中主要用来构建复杂对象，例如在`...

    前端开源库-immutable-core

    Immutable.js 是一个著名的实现不可变数据结构的库，但“immutable-core”则更专注于提供核心的不变数据操作功能。 **二、为什么使用Immutable-core？** 1. **性能提升**：通过减少不必要的对象复制，immutable-...

    Docker and Immutable Infrastructure

    1.Overview of Docker the company and growth 2.Overview of Docker the latest stuff (DCUS announcements) & CaaS;...4.Docker and Immutable infrastructure/Microservices working together.

    前端开源库-immutable-ai

    2. **提高性能**：通过利用共享数据结构（如尾递归优化和 Map 的键值对引用不变性），Immutable.js 可以实现高效的浅层拷贝和对比，减少不必要的对象复制。 3. **时间旅行与状态管理**：在 Redux 或其他状态管理库...

    druid 源码分析 逐层详解

    分析源码时，我们可以看到各种设计模式的影子，理解这些模式是如何帮助开发者构建高效、可维护的代码库。 依赖注入也是Druid源码分析中不可或缺的一个知识点。在Druid的实现中，我们看到了Guice这一依赖注入框架的...

    java多线程设计模式 (PDF中文版, 附源码)

    目录： 漫谈UML Introduction 1 Java语言的线程 Introduction 2 多线程...总结 多线程程序设计的模式语言 附录A 练习问题的解答 附录B Java的内存模型 附录C Java线程的优先级 附录D 线程相关的主要API 附录E 参考文献

    Mastering Immutable.js epub

    Mastering Immutable.js 英文epub 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或csdn删除

    ImmutableArray原型方法Per方法包的集合

    通常，阅读源码可以帮助开发者了解如何在自己的项目中实现类似的功能，或者学习作者的编程技巧和设计模式。 总结来说，`ImmutableArray`的`Per`方法是用于生成不可变数组的所有可能排列的工具，这在需要探索所有...

    immutabilityutil一个开源immutabledata的轮子

    3. `merge`：合并两个或更多的对象，返回一个新的合并后的对象，原对象保持不变。 4. `push`、`pop`、`unshift`、`shift`：这些方法用于操作数组，就像它们在原生JavaScript数组上那样，但它们会返回一个新的数组，...

    21-C-ImmutableObject-Code.zip

    在编程领域，不可变对象（Immutable Object）是一种重要的设计模式，尤其在多线程和并发环境中，它提供了安全性和性能优化。在这个初学者教程中，我们将深入探讨C#中的不可变对象，包括“内部不变性”和“观察不变性...

    Android代码-kotlinx.collections.immutable

    Immutable Collections Library for Kotlin Immutable collection interfaces and implementation prototypes for Kotlin. For further details see the proposal. Prototype implementation is based on ...

    Node.js-immutable-Javascript不可变的持久化数据集合

    `immutable.js`的设计深受函数式编程理念影响，它鼓励使用纯函数，即没有副作用、仅依赖于输入参数的函数。通过这种方式，可以避免共享状态和并发问题，提高代码的可测试性和可维护性。 **性能优化** 虽然创建新的...

    kotlinx.collections.immutable,Kotlin的不可变集合原型.zip

    `kotlinx.collections.immutable`库中的实现通常基于“持久化数据结构”（Persistent Data Structure），这是一种特殊的数据结构设计，即使在进行修改操作时也能保持旧版本的引用。这种设计保证了高效性能，因为...

    前端开源库-redux-immutable

    本文将深入探讨“前端开源库-redux-immutable”，这是一个专为Redux设计的库，旨在解决在处理状态时的不变性问题。 Redux 是一个流行的状态管理库，它在JavaScript应用中扮演着中央数据仓库的角色，负责存储所有的...

Magicbox
Global site tag (gtag.js) - Google Analytics