如何通过设计模式来节省内存

相信大家日常开发过程中，一个优秀的程序猿写出的代码一定要节省空间的，比如节省内存，节省磁盘等等。那么如何通过设计模式来节省内存呢？
1、什么是享元模式？use sharing to support large numbers of fine-grained objects efficiently.
享元模式（flyweight pattern）：使用共享对象可有效地支持大量的细粒度的对象。
说人话：复用对象，节省内存。
2、享元模式定义
①、flyweight——抽象享元角色
是一个产品的抽象类，同时定义出对象的外部状态和内部状态的接口或实现。
一个对象信息可以分为内部状态和外部状态。
内部状态：对象可共享出来的信息，存储在享元对象内部并且不会随环境改变而改变，可以作为一个对象的动态附加信息，不必直接储存在具体某个对象中，属于可以共享的部分。
外部状态：对象得以依赖的一个标记，是随环境改变而改变的、不可以共享的状态。
②、concreteflyweight——具体享元角色
具体的一个产品类，实现抽象角色定义的业务。该角色中需要注意的是内部状态处理应该与环境无关，不应该出现一个操作改变了内部状态，同时修改了外部状态，这是绝对不允许的。
③、unsharedconcreteflyweight——不可共享的享元角色
不存在外部状态或者安全要求（如线程安全）不能够使用共享技术的对象，该对象一般不会出现在享元工厂中。
④、flyweightfactory——享元工厂
职责非常简单，就是构造一个池容器，同时提供从池中获得对象的方法。
3、享元模式通用代码/** * 抽象享元角色 */public abstract class flyweight { // 内部状态 private string instrinsic; // 外部状态通过 final 修改，防止修改 protected final string extrinsic; protected flyweight(string extrinsic) { this.extrinsic = extrinsic; } // 定义业务操作 public abstract void operate(); public string getinstrinsic() { return instrinsic; } public void setinstrinsic(string instrinsic) { this.instrinsic = instrinsic; }}/** * 具体享元角色1 */public class concreteflyweight1 extends flyweight{ protected concreteflyweight1(string extrinsic) { super(extrinsic); } @override public void operate() { system.out.println(具体享元角色1); }}/** * 具体享元角色2 */public class concreteflyweight2 extends flyweight{ protected concreteflyweight2(string extrinsic) { super(extrinsic); } @override public void operate() { system.out.println(具体享元角色2); }}public class flyweightfactory { // 定义一个池容器 private static hashmap pool = new hashmap(); // 享元工厂 public static flyweight getflyweight(string extrinsic){ // 需要返回的对象 flyweight flyweight = null; // 池中没有该对象 if(pool.containskey(extrinsic)){ flyweight = pool.get(extrinsic); }else{ // 根据外部状态创建享元对象 flyweight = new concreteflyweight1(extrinsic); // 放置到池中 pool.put(extrinsic,flyweight); } return flyweight; }}4、通过享元设计文本编辑器假设文本编辑器只包含文字编辑功能，而且只记录文字和格式两部分信息，其中格式包括文字的字体型号、大小、颜色等信息。
4.1 普通实现通常设计是把每个文字看成一个单独对象。
package com.itcoke.designpattern.flyweight.edittext;/** * 单个文字对象 */public class character { // 字符 private char c; // 字体型号 private string font; // 字体大小 private int size; // 字体颜色 private int colorrgb; public character(char c, string font, int size, int colorrgb){ this.c = c; this.font = font; this.size = size; this.colorrgb = colorrgb; } @override public string tostring() { return string.valueof(c); }}/** * 编辑器实现 */public class editor { private arraylist chars = new arraylist(); public void appendcharacter(char c, string font, int size, int colorrgb){ character character = new character(c,font,size,colorrgb); chars.add(character); } public void display(){ system.out.println(chars); }}客户端：
public class editorclient { public static void main(string[] args) { editor editor = new editor(); editor.appendcharacter('a',宋体,11,0xffb6c1); editor.appendcharacter('b',宋体,11,0xffb6c1); editor.appendcharacter('c',宋体,11,0xffb6c1); editor.display(); }}4.2 享元模式改写上面的问题很容易发现，每一个字符就会创建一个 character 对象，如果是几百万个字符，那内存中就会存在几百万的对象，那怎么去节省这些内存呢？
其实，分析一下，对于字体的格式，通常不会有很多，于是我们可以把字体格式设置为享元，也就是上面说的可以共享的内部状态。
内部状态（共享）：字体类型、大小、颜色
外部状态（不共享）：字符
于是代码改写如下：
public class characterstyle { // 字体型号 private string font; // 字体大小 private int size; // 字体颜色 private int colorrgb; public characterstyle(string font, int size, int colorrgb) { this.font = font; this.size = size; this.colorrgb = colorrgb; } @override public boolean equals(object o) { if (this == o) return true; if (o == null || getclass() != o.getclass()) return false; characterstyle that = (characterstyle) o; return size == that.size && colorrgb == that.colorrgb && objects.equals(font, that.font); } @override public int hashcode() { return objects.hash(font, size, colorrgb); }}public class characterstylefactory { private static final map mapstyles = new hashmap(); public static characterstyle getstyle(string font, int size, int colorrgb){ characterstyle newstyle = new characterstyle(font,size,colorrgb); if(mapstyles.containskey(newstyle)){ return mapstyles.get(newstyle); } mapstyles.put(newstyle,newstyle); return newstyle; }}public class character { private char c; private characterstyle style; public character(char c, characterstyle style) { this.c = c; this.style = style; } @override public string tostring() { return string.valueof(c); }}public class editor { private list chars = new arraylist(); public void appendcharacter(char c, string font, int size, int colorrgb){ character character = new character(c,characterstylefactory.getstyle(font,size,colorrgb)); chars.add(character); } public void display(){ system.out.println(chars); }}5、享元模式在 java.lang.integer 中应用看下面这段代码，打印结果是啥？
public class integertest { public static void main(string[] args) { integer i1 = 56; integer i2 = 56; integer i3 = 129; integer i4 = 129; system.out.println(i1 == i2); system.out.println(i3 == i4); }}
为什么是这种结果呢？
首先说一下 integer i = 59；底层执行了：integer i = integer.valueof(59); 这是自动装箱。
int j = i; 底层执行了：int j = i.intvalue(); 这是自动拆箱。
然后我们integer.valueof() 方法：
再看 integercache 源码：
private static class integercache { static final int low = -128; static final int high; static final integer cache[]; 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) { try { 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); } catch( numberformatexception nfe) { // if the property cannot be parsed into an int, ignore it. } } high = h; cache = new integer[(high - low) + 1]; int j = low; for(int k = 0; k = 127; } private integercache() {} }其实这就是我们前面说的享元对象的工厂类，缓存 -128 到 127 之间的整型值，这是最常用的一部分整型值，当然jdk 也提供了方法来让我们可以自定义缓存的最大值。
6、享元模式优点减少应用程序创建的对象，降低程序内存的占用，增强程序的性能。
但它同时也提高了系统复杂性，需要分离出外部状态和内部状态，而且外部状态具有固化特性，不应该随内部状态改变而改变，否则导致系统的逻辑混乱。
7、享元模式应用场景①、系统中存在大量的相似对象。
②、细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定身份。
③、需要缓冲池的场景。