重新认识不可变对象String

    我们在最初学习时，在Java中，String被列为复合性数据类型，但现在来看，其实他真正的是一个不可变类，而与之属于一类的还有Integer,Long,Double,Float,Boolean等对象。所有这些类都有一个共同的特性，就是不可变性。一旦这个类被初始化，他的状态不再变化。这些类都被设计成final类型的，这些类只有一个构造方法。一旦被构造出来，就再也无法修改其内部状态。

   这些作为原始数据类型的封装类，可以直接参与一些集合类的运算，比如，可以直接在一个String的list里面，将某个string给remove掉，可以将两个list做差集等等，总之，这些基本的不可构建类，对于一些集合操作jdk都已经帮我们封装好。但是我们自己定义的类，却不能拿起做差集和随便remove。

比如下面的代码，可以正确运行：

 

public class App {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("abcdefg");
		list.add("higklmn");
		System.out.println("before remove:"+list.size());
		list.remove("higklmn");
		System.out.println("after remove:"+list.size());
	}
}

 我举上面的例子是说明，这些不可变类，通常已经重写了默认的equals方法及hashcode方法，例子可能不太恰当，但这估计是JDK中唯一一类重写了equals和hashcode的类。但是下面的代码，却不能正常运行：

 

 

public class App {
	public static void main(String[] args) {
		List<AObject> list = new ArrayList<AObject>();
		list.add(new AObject(1,2));
		list.add(new AObject(3,4));
		System.out.println("before remove:"+list.size());
		list.remove(new AObject(3,4));
		System.out.println("after remove:"+list.size());
	}
	static class AObject{
		private int a;
		private int b;
		public AObject(int a,int b){
			this.a = a;
			this.b = b;
		}
	}
}

 这就是我们在写Java的时候，不能使用两个Object的==或者equals来判断对象是否相同的原因。

 

同时，通过以上的用法，可以看出，String和int等基本数据类型相差比较的，相反，String是一个类，是一种特殊的类。

 

线程安全

不可变类除了具有以上特性外，最重要的莫过于线程安全了。Java并发编程实战中告诉我们，除非使用同步，否则尽可能的使用不可变对象。因为不可变对象即使不使用同步技术也不会出现线程安全的问题。根据我个人的理解，使用不可变对象时，Java总能保证对象在初始化完毕后，才将对象发布出去，这样就不会出现失效数据，不会出现对象处于一种不安全的发布装。

 

如果我们也要用到jdk的集合类，我们可能也要写一些不可变类，但有一个原则，就是对象一旦创建，不能在修改其状态或者方法的值。如何创建不可变类，这里有一遍文章比较好，大家可以参考：Java的可变类与不可变类

 

对这类话题感兴趣？欢迎发送邮件至[e-mail]

关于我：邯郸人，擅长Java，Javascript，Extjs，oracle sql。

更多我之前的文章，可以访问 我的空间

 

评论

10 楼 andyLee520 2013-07-12  

donlianli 写道

lijinhaiangel 写道

你举的例子就不对吧：list.remove(new AObject(3,4));这段代码相当于remove的一个新生成的对象，如果是这样的就OK啊： AObject aObject= new AObject(3,4); list.add(aObject);  list.remove(aObject);

	public static void main(String[] args) {
		List<Long> list = new ArrayList<Long>();
		list.add(new Long(1));
		list.add(new Long(3));
		System.out.println(list.size());;
		list.remove(new Long(3));
		System.out.println(list.size());;
	}

这段代码怎么解释？

因为这段代码使用的是 new Long 而源代码中Long是重写了equals方法的。

9 楼 andyLee520 2013-07-12  

详细请参见ArrayList源代码，remove(Object o) 方法，你就会明白为什么第二种remove会报错了。
总体来讲，楼主总结的很好！

8 楼 yixiandave 2013-07-11  

static class AObject{ 
        private int a; 
        private int b; 
        public AObject(int a,int b){ 
            this.a = a; 
            this.b = b; 
        } 
    }
这种对象无法被remove掉只因为你没有重写equals方法
你自己去查看ArrayList源码就会发现，remove方法实际上就是遍历数据，执行equals匹配成功的移除，和是否原数据封装类无关

7 楼 菜鸟java 2013-07-10  

学习了！楼主写的很好

6 楼 donlianli 2013-07-09  

mike.liu 写道

mike.liu 写道

donlianli 写道

lijinhaiangel 写道

你举的例子就不对吧：list.remove(new AObject(3,4));这段代码相当于remove的一个新生成的对象，如果是这样的就OK啊： AObject aObject= new AObject(3,4); list.add(aObject);  list.remove(aObject);

	public static void main(String[] args) {
		List<Long> list = new ArrayList<Long>();
		list.add(new Long(1));
		list.add(new Long(3));
		System.out.println(list.size());;
		list.remove(new Long(3));
		System.out.println(list.size());;
	}

这段代码怎么解释？

list.remove(Object obj)方法，是调用的obj.equals()进行判断。Long类型重载了equals()方法，因此虽然是两个不同的Long对象，只要值相同，则equals()返回true。AObject没有重载equals()方法，因此其默认实现是判断两个对象是否为同一个，即使用的==进行判断。

你只要正确地重载了AObject的equals()方法，则你的第二段代码也可以运行正确。
你举的例子，与final类完全无关。

你分析的很对，jdk对String,Long等不可变类都重写了这些方法，我的意思就是说明这些。我举得例子主要是说明Jdk自带的集合类对这些基础不可变对象可以进行一些基本的支持,比如像删除这样的操作，并不是说对final类的支持。要写自己定义的不可变类，需要把hashcode和equals等方法都重写的。

5 楼 mike.liu 2013-07-09  

mike.liu 写道

donlianli 写道

lijinhaiangel 写道

你举的例子就不对吧：list.remove(new AObject(3,4));这段代码相当于remove的一个新生成的对象，如果是这样的就OK啊： AObject aObject= new AObject(3,4); list.add(aObject);  list.remove(aObject);

	public static void main(String[] args) {
		List<Long> list = new ArrayList<Long>();
		list.add(new Long(1));
		list.add(new Long(3));
		System.out.println(list.size());;
		list.remove(new Long(3));
		System.out.println(list.size());;
	}

这段代码怎么解释？

list.remove(Object obj)方法，是调用的obj.equals()进行判断。Long类型重载了equals()方法，因此虽然是两个不同的Long对象，只要值相同，则equals()返回true。AObject没有重载equals()方法，因此其默认实现是判断两个对象是否为同一个，即使用的==进行判断。

你只要正确地重载了AObject的equals()方法，则你的第二段代码也可以运行正确。
你举的例子，与final类完全无关。

4 楼 mike.liu 2013-07-09  

donlianli 写道

lijinhaiangel 写道

你举的例子就不对吧：list.remove(new AObject(3,4));这段代码相当于remove的一个新生成的对象，如果是这样的就OK啊： AObject aObject= new AObject(3,4); list.add(aObject);  list.remove(aObject);

	public static void main(String[] args) {
		List<Long> list = new ArrayList<Long>();
		list.add(new Long(1));
		list.add(new Long(3));
		System.out.println(list.size());;
		list.remove(new Long(3));
		System.out.println(list.size());;
	}

这段代码怎么解释？

list.remove(Object obj)方法，是调用的obj.equals()进行判断。Long类型重载了equals()方法，因此虽然是两个不同的Long对象，只要值相同，则equals()返回true。AObject没有重载equals()方法，因此其默认实现是判断两个对象是否为同一个，即使用的==进行判断。

3 楼 donlianli 2013-07-09  

lijinhaiangel 写道

你举的例子就不对吧：list.remove(new AObject(3,4));这段代码相当于remove的一个新生成的对象，如果是这样的就OK啊： AObject aObject= new AObject(3,4); list.add(aObject);  list.remove(aObject);

	public static void main(String[] args) {
		List<Long> list = new ArrayList<Long>();
		list.add(new Long(1));
		list.add(new Long(3));
		System.out.println(list.size());;
		list.remove(new Long(3));
		System.out.println(list.size());;
	}

这段代码怎么解释？

2 楼 de6566088 2013-07-09  

AObject 需要重新定义hashcode才能判定出AObject传入相同的参数值时，其关系是否相等。

1 楼 lijinhaiangel 2013-07-09  

你举的例子就不对吧：list.remove(new AObject(3,4));这段代码相当于remove的一个新生成的对象，如果是这样的就OK啊： AObject aObject= new AObject(3,4); list.add(aObject);  list.remove(aObject);