正文

享元模式（FlyWeight Pattern）及其在java自动拆箱、自动装箱中的运用

IP云
IP云V管理员/0 阅读
09/20
小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

本文主要从三个方面着手，第一：简要介绍享元模式。第二：享元模式在基本类型封装类中的运用以Integer为例进行阐述。第三：根据第一、第二的介绍，进而推出java是如何实现自动拆箱与装箱的。

第一：简要介绍享元模式。

享元模式的角色：抽象享元类（FlyWeight）、具体享元类（ConcreteFlyWeight）、享元工厂类（FlyWeightFactory）、客户类（Client，相当于一个测试类）

至于FlyWeight pattern如果直接翻译应译为： 蝇量级模式。从蝇量级我们可以知道共享的对象是非常小的。在Integer中共享的数字范围为[-128,127]。老外是不是从共享的对象太小的角度，所以称它为FlyWeight Pattern呢？。

我国人是从FlyWeight Pattern的用途（FlyWeight Pattern 的用途就是共享对象。元，也就是最小的意思。享元就是共享最小对象。）上进行翻译的。

下面给出各个角色的代码：

FlyWeight的代码如下：

package com.qls.flyWeight2;public interface FlyWeight {
//以外蕴状态【external state】为参数的商业方法。这里假设外蕴状态是String类型的。
void operation(String externalState);
}

ConcreteFlyWeight的代码如下：

package com.qls.flyWeight2; public class ConcreteFlyWeight implements FlyWeight {
//内蕴状态的私有字段[internal state]
private Character internalState;
//构造一个以内蕴状态为参数的构造方法
public ConcreteFlyWeight(Character internalState) {
this.internalState = internalState;
}
@Override
public void operation(String externalState) {
// TODO Auto-generated method stub
System.out.println("internalState="+internalState+" externalState="+externalState);
} }

FlyWeightFactory的代码如下：

package com.qls.flyWeight2; import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry; public class FlyWeightFactory {
Map<Character,FlyWeight> files=new HashMap<Character,FlyWeight>();
//构造方法
public FlyWeightFactory() {
// TODO Auto-generated constructor stub
}
//写一个以内蕴状态的工厂方法，以生产FlyWeight对象。
public FlyWeight factory(Character internalState){
if(files.containsKey(internalState)){
return files.get(internalState);
}else{
FlyWeight flyWeight = new ConcreteFlyWeight(internalState);
//把对象保存到Map集合中。
files.put(internalState, flyWeight);
return flyWeight;
}
}
public void checkFlyWeight(){
//打印出FlyWeight对象，以及享元对象。
for(Entry<Character, FlyWeight> en:files.entrySet()){
System.out.println(en.getKey()+"="+en.getValue());
}
}
}

Client的代码如下：

package com.qls.flyWeight2; public class Client { public static void main(String[] args) {
// TODO Auto-generated method stub
//创建一个享元工厂对象
FlyWeightFactory flyWeightFactory = new FlyWeightFactory();
//向享元工厂对象请求一个内蕴状态为'a'的享元对象
FlyWeight factory = flyWeightFactory.factory(new Character('a'));
//以参量方式传入一个外蕴状态。
factory.operation("ouyangfeng");
//向享元工厂对象请求一个内蕴状态为'b'的享元对象
FlyWeight factory2 = flyWeightFactory.factory(new Character('b'));
//以参量方式传入一个外蕴状态。
factory.operation("sixi");
//向享元工厂对象请求一个内蕴状态为'a'的享元对象
FlyWeight factory3 = flyWeightFactory.factory(new Character('a'));
//以参量方式传入一个外蕴状态。
factory.operation("wallow");
System.out.println(factory==factory3);//返回结果为true。由此可以确定'a'确实做到了享元（共享元数据）
/**
* 打印出享元对象。以及内蕴状态。目的是证明对相同的内蕴状态只创建一个对象。
* 下面语句的输出结果是：
* b=com.qls.flyWeight2.ConcreteFlyWeight@21780f30
a=com.qls.flyWeight2.ConcreteFlyWeight@512d297a
这个输出结果证明了：factory==factory3.
*/
flyWeightFactory.checkFlyWeight();
} }

第二：享元模式在基本类型封装类中的运用以Integer为例进行阐述。

首先概述一下：在Integer类中享元对象是保存在一个IntegerCache.cache[]这个数组里面的这个数组存放的内容是：[-128,127]之间的数字，这个范围中的Integer，对象只创建一次。

所以你要测验：Integer a=-128; Integer b=-128 ; System.out.println(a==b);输出结果为true. 而Integer c=-129; Integer b=-129 ; System.out.println(a==b);输出结果为false.

要想说清楚这个问题只需看一看private static class IntegerCache 、 public static Integer valueOf(int i)、 public int intValue() 这三个类的源码即可。

private static class IntegerCache的源码如下：（注：在这个源码中我添加了，对这个源码的一些解释）

private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
//静态代码块保证了，Integer cache[]在IntegerCache加载时就会被赋值。赋值的结果见第22行
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
}
high = h; cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);//这个循环语句等价于Integer[] cache={new Integer(-128),new Integer(-127),new Integer(-126).........new Integer(126),new Integer(127)}共127+128+1=256个数字。
}//当我们在Integer a=f;直接从这个cache[]数组中进行搜索如果f在[-128,127]之间（例如Integer a=1）不需要new Integer(1)了，而是在这个cache[]数组中等于1的值直接赋值。反之如果 f不在[-128,127]之间则会new Integer(f);这个源代码见下面的valueOf
//即可豁然开朗。同时这也体现了享元模式的运用。在享元模式示例中用HashMap存放对象，对同一个对象只创建一次。这里用的是数组存放对象，对同一个对象也只创建一次。
private IntegerCache() {}
}

valueOf的源代码如下：

public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}

public static Integer valueOf(int i)这个方法用于把int转换为Integer，它是编译器用于自动装箱的核心方法。由编译器根据代码的实际情况，决定是否调用这个方法。一句话在把int变为Integer时，编译器会自动调用这个方法。
intValue()的源代码如下：

public int intValue() {
return value;
}

public int intValue()这个方法用于把Integer转换为int的。

，它是编译器用于自动拆箱的核心方法。由编译器根据代码的实际情况，决定是否调用这个方法。一句话在把Integer变为int时，编译器会自动调用这个方法。

下面这个例子说明在一下三种情况编译器是如何工作的：三种情况是：int 与Integer Integer与Integer int 与int

package com.qls.gateway; public class Test6 { public static void main(String[] args) {
// TODO Auto-generated method stub
int g=1;
int a=1;
int f=189;
//b与c在[-128,127]这个范围内。
Integer b=1;
Integer c=1;
//d和e不在[-128,-127]这个范围内。
Integer d=189;
Integer e=189;
System.out.println(a==g);//true【这个是int 与int的比较】
/**
* 从这两个输出语句System.out.println(f==d);
System.out.println(a==b);得出一个结论当int 与Integer比较时，编译器会把Integer自动拆箱。
证明如下：假设当int 与Integer比较时，编译器会把int自动装箱。那么int f=189.自动装箱过后变为
new Integer(189)相当于用创建了一个对象所以与Integer d=189。不可能是同一个对象，那么f==d也就为
false了，但是输出结果为true。所以假设不成立。
所以当int 与Integer比较时，编译器会把Integer自动拆箱。
*/
System.out.println(f==d);
System.out.println(a==b);
/**
* Integer与Integer比较时：只需看Integer的范围是否在[-128,127]如果在直接从cache[]数组中取，
* 则必然是同一个对象，反之如果不在，则会创建一个对象。
*/
System.out.println(d==e);//输出false
System.out.println(b==c);//输出true.
} }