java享元模式（Flyweight）-结构型

最新推荐文章于 2024-09-03 07:00:00 发布

nogos

最新推荐文章于 2024-09-03 07:00:00 发布

阅读量624

点赞数

分类专栏：设计模式文章标签： Java享元模式 Java Flyweight设计模式

本文链接：https://blog.csdn.net/sunxianghuang/article/details/51833670

版权

设计模式专栏收录该内容

17 篇文章 2 订阅

订阅专栏

本文深入探讨了享元模式的设计理念，介绍了如何通过区分内在状态和外在状态来减少对象数量，进而降低内存开销。文章提供了享元模式的类图与角色定义，展示了具体的Java代码实现案例，并详细解释了享元模式在Java String类型中的应用。

摘要由CSDN通过智能技术生成

意图

运用共享技术有效地支持大量细粒度的对象。

享元对象能做到共享的关键是区分内在状态和外在状态。一个内在状态是存储在享元对象内部的，并且是不会随环境改变而改变，内在状态可以被共享。一个外在状态是随环境改变而改变的，不可以共享的状态。

类图与角色

享元接口(Flyweight)：所有具体享元需要实现的接口。那些需要外在状态（External State）的操作可以通过参数的形式传入外在状态。

具体享元(Concrete Flyweight)：实现享元接口。如果有内在状态(Internal State)的话，必须负责为内在状态提供存储空间。内在状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统中共享。

享元工厂(Flyweight Factory) ：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。

实例

比如说一个文本系统，我们需要将每个英文单词或每个中文词组当做一个Word对象。如果有一个10 M的文本，如果每遇到一个单词或词组都定义一个新的Word对象，那么需要消耗大量的内存。如果将相同的单词共享一个Word对象，那么就大大节约了资源。

//享元接口
interface Word{
    public void operation(int weight);
}
//具体享元
class ChinaWord implements Word{
    private String value=null;
    public ChinaWord(String value){
        this.value=value;
    }
    @Override 
    public void operation(int weight){
        System.out.println("词汇："+value);
        System.out.println("权重："+weight);
    }
}
class EnglishWord implements Word{
    private String value=null;
    public EnglishWord(String value){
        this.value=value;
    }
    @Override 
    public void operation(int weight){
        System.out.println("词汇："+value);
        System.out.println("权重："+weight);
    }
}
//享元工厂
class Directory{
    private Map<String,Word> wordMap=new HashMap<String,Word>();
    public Word getWord(String value){
        if(wordMap.containsKey(value)){
            return (Word)wordMap.get(value);
        }else{
            Word w=null;
            if(value.charAt(0)>='a'&&value.charAt(0)<='z')
                w=new EnglishWord(value);
            else
                w=new ChinaWord(value);
            wordMap.put(value,w);
            return w;
        }
    }
    public int getSize(){
        return wordMap.size();
    }
}

//客户端代码
class test  {
	public static void main (String[] args) throws java.lang.Exception{
		Directory directory=new Directory();
		String[] words={"this","is","a","dog","this","is","a","cat","这","是","一个","小猫","这","是","一个","小狗"};
		List<Word> ws=new ArrayList<Word>();
		for(String s:words){
		    ws.add(directory.getWord(s));
		}
		System.out.println(directory.getSize());
		ws.get(0).operation(6);
	}
}

适用场景

当一个应用中使用了大量的对象，这些对象造成了很大的存储开销，而对象的大部分状态或参数都是相同（内部状态）的时候，可以考虑使用享元模式，使用享元模式可以使这些对象引用都共享相同的实例，降低存储开销，而对象之间的不同的状态参数(外部状态)则使用外部参数传入来实现。

享元模式的优缺点

优点在于它大幅度地降低内存中对象的数量。但是，它做到这一点所付出的代价也很高：1、为了使得对象能够共享，需要将一个状态外部化，这使得程序的逻辑复杂化。2、享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。

享元模式的应用

在Java语言中，String类型就使用了享元模式。

1. 首先String不属于8种基本数据类型，String是一个对象。

因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。
2. new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；
3. String str=”kvill”;String str=new String (“kvill”);的区别

在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

	    String a="abcd";
	    String b="abcd";
	    String c="ab"+"cd";
		System.out.println(a==b);
		System.out.println(a==c);

输出：

true

用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

首先，我们要知道Java会确保一个字符串常量只有一个拷贝。因为例子中的a和b中的”abcd”都是字符串常量，它们在编译期就被确定了，所以a==b为true；而”ab”和”cd”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以c也同样在编译期就被解析为一个字符串常量，所以c也是常量池中”abcd”的一个引用。

	    String a="abcd";
	    String b=new String("abcd");
	    String c="ab"+new String("cd");
		System.out.println(a==b);
		System.out.println(a==c);
		System.out.println(b==c);

输出：

false

a还是常量池中”abcd”的引用，b因为无法在编译期确定，所以是运行时创建的新对象”abcd”的引用，c因为有后半部分new String(“cd”)所以也无法在编译期确定，所以也是一个新创建对象”abcd”的应用;明白了这些也就知道为何得出此结果了。
4. String.intern()：
再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；

	    String a="abcd";
	    String b=new String("abcd");
	    String c=new String("abcd");
		System.out.println(a==b);
		b.intern();
		c=c.intern();//把常量池中“abcd”的引用赋给c
		System.out.println(a==b);
		System.out.println(a==b.intern());
		System.out.println(a==c);

输出：

false

false//虽然执行了b.intern(),但它的返回值没有赋给b

true//说明b.intern()返回的是常量池中”abcd”的引用

true

5. 关于equals()和==:
这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。
6. 关于String是不可变的
这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”; 就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” “ 生成 ”kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的。

true