java中Final关键字和Immutable Class以及Guava的不可变对象

最新推荐文章于 2022-06-14 21:59:38 发布

weixin_33676492

最新推荐文章于 2022-06-14 21:59:38 发布

阅读量195

点赞数

文章标签： java python

原文链接：https://my.oschina.net/lianlupeng/blog/510409

版权

2019独角兽企业重金招聘Python工程师标准>>>

大纲

写这篇文章的起因
java中Final关键字
如何构建不可变对象
Guava中不可变对象和Collections工具类的unmodifiableSet/List/Map/etc的区别
实验代码

写这篇文章的起因

java项目在使用FindBugs扫描的时候报了一个不能使用可变对象，记得报的是类似如下的信息：

MS: Field is a mutable collection (MS_MUTABLE_COLLECTION)
官方解释：
A mutable collection instance is assigned to a final static field, thus can be changed by malicious code or by accident from another package. Consider wrapping this field into Collections.unmodifiableSet/List/Map/etc. to avoid this vulnerability.

参考FindBugs的描述：http://findbugs.sourceforge.net/bugDescriptions.html

由于最近学习的东西较多，对有些基本的概念略有生疏，所以又温故了一下，顺便提供下上面问题的解决方案，仅供参考。

java中Final关键字

Final是java的一个关键字，可以修饰：变量、方法、类，大致用法，我写了一个测试类，注释也比较多。

package org.unrulylianzi.basis.javass.finalkeyword;


/**
 * java final 基本用法
 * <li>variable</li>
 * <li>method</li>
 * <li>class</li>
 * */
public class JavaFinalKeyWord {
	/**
	 * 基本类型
	 * */
	private final int a=3;
	
	private final int b;//must be initialized at the time of declaration or inside constructor or block

	
	{
		//a=4;不能重复对final的变量赋值
		System.out.println(a);
		b=4;
	}

	/**
	 * 引用类型
	 * */
	private final Person person = new Person("unrulylianzi");//must be initialized at the time of declaration or inside constructor
	
	{
		//person = new Person("unrulylianzi_change_final");//不能重复对final的变量赋值
		System.out.println(person);
		
		person.setName("unrulylianzi_change_value_not_reference");//可以修改引用类型的值，但是不能赋予新的Person对象
		
		System.out.println(person);
	}
	/**
	 * method
	 * */
	
	public  final String finalMethod(){
		return "unrulylianzi_final";
	}
	
	/**
	 * method not final
	 * */
	
	public  String notFinalMethod(){
		return "unrulylianzi_notfinal";
	}
}

final class  SubClass extends JavaFinalKeyWord {

	@Override
	public String notFinalMethod() {
		// TODO Auto-generated method stub
		return super.notFinalMethod();
	}
	
	/**
	 * final method can not be  overridden in Java
	   final的方法不能被继承
	@Override
	public String finalMethod() {
		// TODO Auto-generated method stub
		return super.finalMethod();
	}
	*/
	
}

/**
 *
 *Final class can not be inheritable in Java.
 Final修饰的类不能被继承

class ExtendsFinalClass extends SubClass {
	
}

*/

其中Person类是一个简单的bean
public class Person {
	private String name;
	//getter&setter
}

当然Final对性能也有很多好处，这次不会讲到。

如何构建不可变对象

这个问题貌似没太在意过，也没深入思考过Final关键字和Immutable对象之间的关系。不可变对象就是对象一旦创建就是不能被改变的。下面列一下创建不可变类的步骤

声明class为Final，以免class被子类继承，关于多态的概念就不讲啦。
把所有类的属性声明成private，并且不提供set方法。
把所有可变的变量声明为Final，使得这些变量只能初始化一次。
暴露给外部的构造函数，在赋值的时候，要使用深拷贝。
在变量对应的get方法的时候要提供引用类型变量的clone，而不是直接返回。

我创建的一个不可变对象的示例代码如下：

package org.unrulylianzi.basis.javass.immutable;

import java.util.HashMap;
import java.util.Iterator;

/**
 * 不变对象
 * <li>1:Declare the class as final so it can’t be extended.</li>
 * <li>2:Make all fields private so that direct access is not allowed.</li>
 * <li>3:Don’t provide setter methods for variables</li>
 * <li>4:Make all mutable fields final so that it’s value can be assigned only once.</li>
 * <li>5:Initialize all the fields via a constructor performing deep copy.</li>
 * <li>6:Perform cloning of objects in the getter methods to return a copy rather than returning the actual object reference.</li>
 * */

public final class ImmutableClass {
	
	
	private final int age;
	private final String name;
	
	private final HashMap<String,String> testMap;

	/**
	 * shallow copy
	 * */
//	public ImmutableClass(int age, String name, HashMap<String, String> testMap) {
//		super();
//		this.age = age;
//		this.name = name;
//		this.testMap = testMap;
//	}
	
	/**
	 * deep copy
	 * */
	public ImmutableClass(int age, String name, HashMap<String, String> testMap) {
		super();
		this.age=age;
		this.name=name;
		HashMap<String,String> tempMap=new HashMap<String,String>();
		String key;
		Iterator<String> it = testMap.keySet().iterator();
		while(it.hasNext()){
			key=it.next();
			tempMap.put(key, testMap.get(key));
		}
		this.testMap=tempMap;
	}

	/**
	 * @return the age
	 */
	public int getAge() {
		return age;
	}

	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}

	public HashMap<String, String> getTestMap() {
		//return testMap
		return (HashMap<String, String>) testMap.clone();
	}
	
}

可见Final关键字是创建不可变对象的基础。

Guava中不可变对象和Collections工具类的unmodifiableSet/List/Map/etc的区别

guava是google的一个库，弥补了java语言的很多方面的不足，很多在java8中已有实现，暂时不展开。Collections是jdk提供的一个工具类。两者之间的区别：

当Collections创建的不可变集合的wrapper类改变的时候，不可变集合也会改变，而Guava的Immutable集合保证确实是不可变的。

测试代码如下：

//guava的实现
public static final List<String> immutableList;

	static {
		immutableList = ImmutableList.of("a");
	}

	/**
	 * 改变immutableList
	 * 
	 */
	public static void immutableListGuavaChange() {

		try {
			System.out.println("Try adding more elements to ImmutableList");
			/**
			 * 改变immutableList已存在元素的值，添加新的元素，都会报错，抛出异常
			 */
			immutableList.set(0, "b");
			// immutableList.add("b");
		} catch (UnsupportedOperationException e) {
			System.out.println(
					"Throws UnsupportedOperationException, ImmutableList is immutable, won't allow adding elements");
		}
	}

Collections工具类的实现：

/**
 * Collections工具类实现的不可变list的示例
 */
public class ImmutableListCollections {

	public static final Collection unmodifiableList;
	public static final List list;

	static {
		list = Arrays.asList("Once", "upon", "time", "there", "used", "to", "be", "king");
		unmodifiableList = Collections.unmodifiableCollection(list);
	}

	/**
	 * 改变immutableList
	 * 
	 */
	public static void immutableListCollectionsChange() {

		System.out.println("Try adding more elements to ImmutableList");
		/**
		 * 改变unmodifiableList已存在元素的值，添加新的元素，都会报错，抛出异常
		 */
		list.set(0, "b");
		System.out.println("###修改wrapper类###" + unmodifiableList);
		// immutableList.add("b");

	}
}

Guava和Collections实现原理(只为说明不可变，未深入)

查看Guava和Collections的实现，发现add方法是如下设计的：

public final void add(int index, E element) {
  throw new UnsupportedOperationException();
}

1、定义Final，防止子类改变父类的行为。

2、执行修改操作的时候，直接抛异常。

实验代码

转载于:https://my.oschina.net/lianlupeng/blog/510409