不良代码示例和优良代码示例

package com.hisuper.richTextChat.view
{


	import avmplus.getQualifiedClassName;
	
	import com.hisuper.richTextChat.inter.impl.BaseChatSyncOpImpl;
	import com.hisuper.richTextChat.manager.BaseOpChatManager;
	import com.hisuper.richTextChat.manager.BaseSyncManager;
	import com.hisuper.richTextChat.object.ChatUser;
	import com.hisuper.richTextChat.util.BaseChatUtil;
	
	import components.BaseChatSkin;
	
	import flash.display.DisplayObject;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.MouseEvent;
	import flash.system.ApplicationDomain;
	import flash.utils.clearInterval;
	import flash.utils.getDefinitionByName;
	import flash.utils.setInterval;
	
	import mx.containers.Canvas;
	import mx.containers.VDividedBox;
	import mx.controls.Alert;
	import mx.core.FlexGlobals;
	import mx.events.FlexEvent;
	import mx.managers.PopUpManager;
	
	import spark.components.Group;
	import spark.components.NavigatorContent;
	import spark.components.SkinnableContainer;
	import spark.components.VGroup;

	public class BaseChat extends NavigatorContent
	{	
	
		
		[SkinPart(required= "false")]
		public var chatGroup:*;
		
		protected var vd:VGroup;
		
		public var chatInput:BaseChatInput;
		
		public var chatContent:BaseChatContent;
		
		protected var _opManagerChange:Boolean=false;
		
		
		protected var   _opManager:BaseOpChatManager;
		
		protected var _syncManagerChange:Boolean=false;
		
		
		protected var   _syncManager:BaseSyncManager;
		
		protected var _createUser:Object;
		
		protected var _syncUser:Object;
		
		protected  var _queueMsgs:Array=[];
		
		protected var _roomId:String;
		
		//是否处理未发送信息
		protected var _isDoNotSend:Boolean=false;
		
		protected var createFlag:Boolean=false;
		
		protected var _addToStage:Boolean=false;
		
		public var lastMsg:Object;
		
		public function BaseChat()
		{	
			super();
			
			this.addEventListener(FlexEvent.CREATION_COMPLETE,createHandler);
				
			setSkin();
		
			this.addEventListener(FlexEvent.ADD,addToStageHandler);
			
			createFlag=true;
			
			this.invalidateProperties();
			
			//this.addEventListener(Event.REMOVED_FROM_STAGE,removeToStageHandler);
		}
		
		public function get isDoNotSend()
		{
			return _isDoNotSend;
		}

		public function set isDoNotSend(value):void
		{
			_isDoNotSend = value;
		}

		/**
		 * 可覆盖,像骚亢的就不是openfire 
		 * @return 
		 * 
		 */		
		public var connIsActiveFun:Function;
		public function connIsActive():Boolean
		{	
			if(!_isDoNotSend)return true;
			
			var flag:Boolean=true;
			if(connIsActiveFun&&connIsActiveFun())
			{
				flag=true;
			}
			else if(connIsActiveFun)
			{
				flag=false;
			}
			return flag;
		}

		public function get roomId():String
		{
			return _roomId;
		}

		public function set roomId(value:String):void
		{
			if(_roomId == value)return;
			this._roomId=value;
			this.invalidateProperties();
		}

		protected function removeToStageHandler(event:Event=null):void
		{
			
			_addToStage=false;
			clearChatContent();
		}
		
		protected function addToStageHandler(event:FlexEvent=null):void
		{
		
			_addToStage=true;
			
		}
		
		protected function setSkin():void
		{
			this.setStyle("skinClass",BaseChatSkin); 
			
		}
		
		public function get syncManager():BaseSyncManager
		{
			return _syncManager;
		}

		public function set syncManager(value:BaseSyncManager):void
		{
			if(_syncManager != value){
				if(_syncManager)
				{
					_syncManager.doClear();
				}
				_syncManagerChange=true;
				this._syncManager=value;
				this.invalidateProperties();
			}
		}

		public function get opManager():BaseOpChatManager
		{
			return _opManager;
		}
		
		
		public function set opManager(value:BaseOpChatManager):void
		{	
			
			if(_opManager!=value)
			{	
				if(_opManager)
				{
					_opManager.doClear();
				}
				_opManager = value;
				_opManagerChange=true;
				this.invalidateProperties();
			}
		}

		protected function createHandler(event:FlexEvent):void
		{	
			
			if(syncUser)
			{
				this.name="chat"+syncUser.userId;
			}
			else if(roomId)
			{
				this.name=roomId;
			}
			
			
		}
		
		
		
		
		public  function addMsg(_obj:Object,_localChange:Boolean=true):void
		{	
			
			lastMsg=_obj;
			
			_obj.localChange=_localChange;
			_queueMsgs.push(_obj);
			
			this.invalidateProperties();
		}
		
		
		private var _syncUserChange:Boolean=false;
		public function get syncUser():Object
		{
			return _syncUser;
		}

		public function set syncUser(value:Object):void
		{	
			_syncUserChange=true;
			_syncUser = value;
			this.invalidateProperties();
			
			
		}

		public function get createUser():Object
		{	
			
			return _createUser;
		}
		private var _createUserChange:Boolean=false;
		
		public function set createUser(value:Object):void
		{	
			_createUserChange=true;
			_createUser = value;
			this.invalidateProperties();
			
		}

		override protected function partAdded(partName:String, instance:Object):void
		{
			super.partAdded(partName, instance);
		
			if(instance==chatGroup)
			{
				initChatGroup();
			}
			
			
		}
		
		private function doChatGroup_other():void
		{
			
			
		}
		
		
		
		private function doUserInfoGroup():void
		{	
		}
		
		
		
		
		protected function initChatGroup():void
		{
			if(!vd&&chatGroup)
			{
				vd=new VGroup();
			
				vd.percentHeight=100;
				vd.percentWidth=100;
				
				chatGroup.addElement(vd);
			}
			
			createChatInput();
			
			createChatContent();
			
			vd.addElement(chatContent);
			vd.addElement(chatInput);
			initOpManager();
			initSyncManager();
		}
		
		protected function createChatContent():void
		{
			if(!chatContent)
			{
				chatContent=new BaseChatContent(this); 
				chatContent.percentHeight=100;
				chatContent.percentWidth=100;
				
			}
			
		}
		
		protected function createChatInput():void
		{
			if(!chatInput)
			{
				chatInput=new BaseChatInput(this);
				
				chatInput.height=100;
				chatInput.percentWidth=100;
				
			}
			
		}
		
		
		protected function initOpManager():void
		{
			opManager=new BaseOpChatManager(chatInput,chatContent);
			opManager.createUser=createUser;
			
		}
		
		protected function initSyncManager():void{
		
			syncManager=new BaseSyncManager(chatInput,chatContent);
			syncManager.createUser=createUser;
			syncManager.syncUser=syncUser;
			
			syncManager.roomId=roomId; 
			
			
			syncManager.syncOp=new BaseChatSyncOpImpl();
			
		
		
				
					
		}
		override protected function commitProperties():void
		{	
			try{
				super.commitProperties();
			}
			catch(e:Error)
			{
				trace(e.getStackTrace());
			}
			if(syncManager&&_syncManagerChange)
			{	
				_syncManagerChange=false;;
				
			}
			
			if(_createUserChange&&syncManager&&opManager)
			{
				_createUserChange=false;
				syncManager.createUser=createUser;
				opManager.createUser=createUser;
			}
			if(_syncUserChange&&syncManager )
			{
				_syncUserChange=false;
				syncManager.syncUser=syncUser;
			}
			
			
			if(opManager&&_opManagerChange)
			{	
				_opManagerChange=true;
			}
			
			if(chatInput)
			{
				chatInput.invalidateProperties();
			}
			
			while(createFlag&&_queueMsgs.length>0)
			{	
				if(opManager&&chatContent)
				{	
					var msg:Object=_queueMsgs.shift();
					
					var op:Object=BaseChatSyncOpImpl;
					doMsg(msg,op);
					
				}
			}
			
		}
		
		protected function doMsg(msg:Object,SyncOpImpl:Object):void
		{
			//var SyncOpImpl:*=null;
			//SyncOpImpl=getDefinitionByName(getQualifiedClassName(syncManager.syncOp));
			
			 
			if(msg&&msg.actionType&&SyncOpImpl.chatSyncs(msg.actionType).convertMsgObject)
			{	
				if(msg&&!msg.hasOwnProperty("eventUpdate"))
				{
					msg.eventUpdate=new EventDispatcher();
				}
				if(msg&&msg.eventUpdate)
				{
					msg.eventUpdate.addEventListener("updateFlag",updateFlagHandler);
				}
				function updateFlagHandler(event:Event):void{
				
					opManager.addMsgToContent(msg,msg.localChange);
				}
				if(syncUser)
				{
					opManager.addMsgToContent(SyncOpImpl.chatSyncs(msg.actionType).convertMsgObject(msg,"1"),msg.localChange); 
				}
				else if(roomId)
				{
					opManager.addMsgToContent(SyncOpImpl.chatSyncs(msg.actionType).convertMsgObject(msg,"3"),msg.localChange); 
				}
				else
				{
					opManager.addMsgToContent(SyncOpImpl.chatSyncs(msg.actionType).convertMsgObject(msg),msg.localChange); 
				}
			}
				
			else
			{
				opManager.addMsgToContent(msg,msg.localChange);
			}
			
		}
		
		
		public function doClear():void{
			
			try{
				removeToStageHandler();
				
			}
			catch(e:Error)
			{
				
			}
		}
		
		public function clearChatContent():void{
		
			opManager.clearChatContent();
		}
		
		public function get isShow():Boolean{
		
			return true;
		}
	}
}



package com.hisuper.richTextChat.view
{
	
	import com.hisuper.richTextChat.inter.BaseChatContentInter;
	import com.hisuper.richTextChat.manager.BaseOpChatManager;
	
	import components.BaseChatContentSkin;
	
	import flash.display.Loader;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.MouseEvent;
	import flash.geom.Point;
	import flash.net.URLRequest;
	import flash.utils.Dictionary;
	import flash.utils.clearInterval;
	import flash.utils.setInterval;
	
	import flashx.textLayout.conversion.ConversionType;
	import flashx.textLayout.conversion.TextConverter;
	import flashx.textLayout.elements.FlowLeafElement;
	import flashx.textLayout.elements.InlineGraphicElement;
	import flashx.textLayout.elements.ParagraphElement;
	import flashx.textLayout.elements.SpanElement;
	import flashx.textLayout.elements.TextFlow;
	import flashx.textLayout.events.SelectionEvent;
	import flashx.textLayout.events.StatusChangeEvent;
	import flashx.textLayout.events.UpdateCompleteEvent;
	
	import mx.controls.Label;
	import mx.core.FlexGlobals;
	import mx.events.FlexEvent;
	import mx.utils.ObjectUtil;
	import mx.utils.StringUtil;
	
	import spark.components.Button;
	import spark.components.Group;
	import spark.components.HGroup;
	import spark.components.Scroller;
	import spark.components.SkinnableContainer;
	import spark.components.TextArea;
	import spark.components.TitleWindow;

	public class BaseChatContent extends  SkinnableContainer implements  BaseChatContentInter
	{	
	
		
		[SkinPart(required= "true")]
		public var chatContentCoreGroup:*;
		[SkinPart(required= "true")]
		public var chatContentCoreScroller:Scroller;
		[SkinPart(required= "true")]
		public var tipGroup:Group;
		
		protected var chatContentCoreHeight:Number=20;
		
		protected var tipWindow:BaseChatTip;
		
		private var _isShowTipWindow:Boolean=true;
		
		
		protected var currentChatContentCore:BaseChatContentCore;
		
		private var it:int;
		
		protected var chat:BaseChat;
		
		private var _orderType:String;
		
		public function BaseChatContent(chat:BaseChat=null)
		{
			super();
			this.chat=chat;
			this.addEventListener(FlexEvent.CREATION_COMPLETE,createCompleteHandler);
			setSkin();
		
		}
		
		protected function setSkin():void
		{
			this.setStyle("skinClass",BaseChatContentSkin);
			
		}
		
		public function get orderType():String
		{
			return _orderType;
		}

		public function set orderType(value:String):void
		{
			if(_orderType!=value)
			{
				
				_orderType = value;
				
				this.invalidateProperties();
			}
		}

		public function get isShowTipWindow():Boolean
		{
			return _isShowTipWindow;
		}

		public function set isShowTipWindow(value:Boolean):void
		{
			if(_isShowTipWindow != value){
			
				this._isShowTipWindow=value;
				this.invalidateProperties();
			}
		
		}

		protected function createCompleteHandler(event:FlexEvent):void
		{	
			
		}
		
		override protected function partAdded(partName:String, instance:Object):void
		{
			super.partAdded(partName, instance);
		
			if(instance==chatContentCoreGroup)
			{
				doChatContentCoreGroup();
			}
			else if(instance==chatContentCoreScroller)
			{
				doChatContentCoreScroller();
			}
			
			else if(instance==tipGroup)
			{
				doTipGroup();
			}
			
		}
		
		protected function doTipGroup():void
		{	
			if(isShowTipWindow)
			{
				tipWindow=new BaseChatTip();
				tipWindow.percentWidth=100;
				tipGroup.addElement(tipWindow);
				tipWindow.setSampleTip("请勿非法聊天");
			}
		}
		
		private function doChatContentCoreScroller():void
		{	
			if(orderType=="top")
			{
				
			}
			else
			{
				chatContentCoreScroller.addEventListener(FlexEvent.UPDATE_COMPLETE,chatContentCoreScroller_updateCompleteHandler);
			}
		}
		
		protected function chatContentCoreScroller_updateCompleteHandler(event:FlexEvent):void
		{	
			if(chatContentCoreScroller.height<chatContentCoreScroller.measuredHeight)
			{
				chatContentCoreScroller.viewport.verticalScrollPosition=chatContentCoreScroller.measuredHeight-chatContentCoreScroller.height;
			}
		}
		public var isWeel:Boolean=true;
		
		private function doChatContentCoreGroup():void
		{	
			if(isWeel)
			{
				chatContentCoreGroup.addEventListener(MouseEvent.MOUSE_DOWN,chatContentCoreGroup_mouseDownHandler);
				systemManager.getSandboxRoot().addEventListener(
					MouseEvent.MOUSE_UP,chatContentCoreGroup_mouseUpHandler, false, 0, true);
			}
			
		}		
		
		protected function chatContentCoreGroup_mouseDownHandler(event:MouseEvent):void
		{
			isMouseDown=true
		}
		
		protected function chatContentCoreGroup_mouseUpHandler(event:Event):void
		{
			isMouseDown=false;
			clearInterval(it);
		}
		private var isMouseDown:Boolean;
		protected function chatContentCore_selectChangeHandler(event:SelectionEvent=null):void
		{
			clearInterval(it);
			
			if(!isMouseDown)return;
			
			if(!chatContentCoreScroller)return;
			
			var point:Point=new Point();
			
			chatContentCoreGroup.localToGlobal(point);
			
			if(FlexGlobals.topLevelApplication.mouseY<chatContentCoreScroller.localToGlobal(point).y)
			{
				it=setInterval(function s():void{
					if(isMouseDown){
						if(chatContentCoreScroller.verticalScrollBar)
						{
							chatContentCoreScroller.verticalScrollBar.value-=35;
							if(chatContentCoreScroller.verticalScrollBar.value<0)
							{
								clearInterval(it);
							}
						}
					}
				},100);
			}
			else if(FlexGlobals.topLevelApplication.mouseY>chatContentCoreScroller.localToGlobal(point).y+chatContentCoreScroller.height){
				
				it=setInterval(function s():void{
					if(isMouseDown){
						if(chatContentCoreScroller.verticalScrollBar)
						{
							chatContentCoreScroller.verticalScrollBar.value+=35;
							if(chatContentCoreScroller.verticalScrollBar.value>chatContentCoreScroller.verticalScrollBar.maximum)
							{
								clearInterval(it);
							}
						}
					}
				},100);
			}
			
		}
		
		protected function chatContentCore_creationCompleteHandler(event:FlexEvent):void
		{	
			
			if(isWeel)
			{
				systemManager.getSandboxRoot().removeEventListener(
					MouseEvent.MOUSE_MOVE,globle_mouseMoveHandler);
				systemManager.getSandboxRoot().addEventListener(
					MouseEvent.MOUSE_MOVE,globle_mouseMoveHandler, false, 0, true);
			}
			//baseChatContentCore.textFlow.addEventListener(SelectionEvent.SELECTION_CHANGE,chatContentCore_selectChangeHandler);
		}
		
		protected function graphicChangeHandler(event:StatusChangeEvent):void
		{	
			try{
			
				textFlow.flowComposer.updateAllControllers();	
				var imgElem:InlineGraphicElement=event.element as InlineGraphicElement;
				var md5:String;
				var md5_index:int=event.element.id.indexOf("md5=");
				if(md5_index!=-1)
				{	
					md5=event.element.id.split("=")[1];
					graphicChangeHandler2.apply(null,[event,md5]);
					
				}
			
				
			}
			catch(e:Error)
			{
				trace(e.toString())
			}
		}
		private var imgElems:Dictionary=new Dictionary();
		private function graphicChangeHandler2(event:StatusChangeEvent,md5:String):void
		{	
			var imgElem:InlineGraphicElement=event.element as InlineGraphicElement;
			
			var loader:Loader=new Loader();
			imgElems[loader]=imgElem;
			loader.contentLoaderInfo.addEventListener(Event.COMPLETE, function getBitmapData(e:Event):void{
				
				var _loader:Loader=e.currentTarget.loader;
				var _imgElem:InlineGraphicElement=imgElems[_loader];
				var content:* = _loader.content;  
				var md5_index:int=event.element.id.indexOf("md5=");
				if(md5_index!=-1)
				{	
					md5=_imgElem.id.split("=")[1];
					_imgElem.id="md5_view="+md5;
				}
				else
				{
					_imgElem.id="";
				}
			
				_imgElem.source = content;
				
				if(isNaN(_imgElem.width))
				{
					_imgElem.width =content.width;
				}
				else
				{	
					content.width=_imgElem.width;
					imgElem.width =content.width;
				}
				if(isNaN(_imgElem.height))
				{
					_imgElem.height =content.height;
				}
				else
				{	
					content.height=_imgElem.height;
					imgElem.height =content.height;
				}
				
				textFlow.flowComposer.updateAllControllers();	
				loader=null;
				delete imgElems[loader];
				
			});  
			
			//loader.load(new URLRequest("http://localhost:8080/jeecms6/fileDownLoad?md5="+md5));
		}

		protected function globle_mouseMoveHandler(event:Event):void
		{
			if(!isMouseDown)return;
			chatContentCore_selectChangeHandler();
		}
		
		
		public function addMsg(xml:XML,isHead:Boolean=false,_localChange:Boolean=true):Boolean{
			
			if(!xml)return false;
			
			var textFlow:TextFlow=TextConverter.importToFlow(xml,TextConverter.TEXT_LAYOUT_FORMAT) as TextFlow;
			
			return addTextFlow(textFlow,isHead);
			
		}
		public function addMsgTxt(txt:String,_localChange:Boolean=true):Boolean{
			
			var tf:TextFlow = TextConverter.importToFlow(txt, TextConverter.PLAIN_TEXT_FORMAT);
			return addTextFlow(tf);
		}
		private var queues:Array=[];
		protected var _createChatContentCoreFlag:Boolean=true;
		public function addUI(UI:*,localChange:Boolean=true):Boolean{
		
			var hg:HGroup=new HGroup();
			hg.verticalAlign="center";
			hg.addElement(UI);
			if(localChange&&!chat.connIsActive()&&chat.isDoNotSend)
			{
				
				
			}
			
			chatContentCoreGroup.addElement(hg);
			_createChatContentCoreFlag=true;
			
			//baseChatContentCore=null;
			return true;
		}
		
		public function addImage(_source:Object):Boolean{
			
			var img:InlineGraphicElement = new InlineGraphicElement();
			img.source = _source;
			var anchor:int = currentChatContentCore.selectionAnchorPosition;
			anchor = (anchor == -1) ? 0 : anchor;
			var leaf:FlowLeafElement = currentParagraphElement.findLeaf(anchor);	
			leaf.splitAtPosition(anchor - leaf.getAbsoluteStart());	
			var index:int = currentParagraphElement.getChildIndex(leaf);			
			currentParagraphElement.addChildAt(index+1, img);
			return true;
		}
	
		protected function createChatContentCore(_isHead:Boolean=false):void
		{
			if(_createChatContentCoreFlag)
			{	
				_createChatContentCoreFlag=false;
				
				var baseChatContentCore:BaseChatContentCore=getChatContent(_isHead);
				
				baseChatContentCore.chat=chat;
				
				baseChatContentCore.addEventListener(FlexEvent.CREATION_COMPLETE,chatContentCore_creationCompleteHandler);
				
				baseChatContentCore.textFlow.addEventListener(StatusChangeEvent.INLINE_GRAPHIC_STATUS_CHANGE, graphicChangeHandler);
				
				currentChatContentCore=baseChatContentCore;
				
				setChatContentCore(baseChatContentCore,_isHead);
			}
			
		}
		
		protected function getChatContent(_isHead:Boolean=false):BaseChatContentCore
		{
			var baseChatContentCore:BaseChatContentCore=new BaseChatContentCore();
			
			baseChatContentCore.editable=false;
			
			baseChatContentCore.percentWidth=100;
			
			return baseChatContentCore;
		}
		
		protected function setChatContentCore(_baseChatContentCore:BaseChatContentCore,isHead:Boolean=false):void
		{
			
			_baseChatContentCore.height=chatContentCoreHeight;
			
			chatContentCoreGroup.minHeight=_baseChatContentCore.height;
			
			chatContentCoreGroup.addElement(_baseChatContentCore);
			
		}
		public function get currentParagraphElement():ParagraphElement{
			
			return currentChatContentCore.textFlow.getChildAt(0) as ParagraphElement;
		}
		public function addTextFlow(textFlow:TextFlow,isHead:Boolean=false,_localChange:Boolean=true):Boolean{

			createChatContentCore(isHead);
			
			if(textFlow)
			{
				var total:int= textFlow.numChildren;
				for(var i:int=0;i<total;i++)
				{	
					try{
						var add:*=textFlow.getChildAt(i).deepCopy();
						if(add)
						{
							this.currentChatContentCore.textFlow.addChild(add);
						}
					}
					catch(e:Error)
					{
						trace(e.toString())
					}
				}
			}
			this.currentChatContentCore.invalidateDisplayList();
			this.invalidateDisplayList();
			return true;
		}
		
		public function get textFlow():TextFlow{
			return currentChatContentCore.textFlow;
		}
		
		public function get chatXML():XML{
			var xml:XML=TextConverter.export( currentChatContentCore.textFlow,TextConverter.TEXT_LAYOUT_FORMAT,ConversionType.XML_TYPE) as XML;
			
			return xml;
		}
		private var _opChatManager:BaseOpChatManager;
		
		public function get opChatManager():BaseOpChatManager{
		
			if(chat)
			{
				return chat.opManager;
			}
				
			
			if(!_opChatManager)
			{
				_opChatManager=new BaseOpChatManager(null,this);
			}
			
			return _opChatManager;
		}
		
		public function clearChatContent():void
		{
			chatContentCoreGroup.removeAllElements();
			currentChatContentCore=null;
			_createChatContentCoreFlag=true;
		}
		
		override protected function commitProperties():void
		{
			super.commitProperties();
			
			if(orderType=="top"&&chatContentCoreScroller)
			{
				chatContentCoreScroller.removeEventListener(FlexEvent.UPDATE_COMPLETE,chatContentCoreScroller_updateCompleteHandler);
			}
		}
	}
}
良好的代码规范：
package com.hisuperlib.sets
{
	import flash.utils.Dictionary;

	/**
	 * 轻量级map字典集合实现
	 * @date:2009-09-11
	 * @author:liugongjun
	 * */
	public final class Map 
	{
		private var pool:Dictionary=null;

		/**
		 * 构造函数
		 * @param value true 弱应用 当垃圾回收时不被引用的对象会被清掉，false 不会被清掉
		 *
		 */
		public function Map(value:Boolean=true)
		{
			this.pool=new Dictionary(value);
		}

		/**
		 * 设置键值
		 * @param key 键
		 * @param value 值
		 *
		 */
		public function put(key:Object, value:Object):void
		{
			if (key != null)
			{
				this.pool[key]=value;
			}
		}

		public function puts(keys:Array, values:Array):Map
		{
			for (var i:int=0, j:int=keys.length; i < j; i++)
			{
				this.pool[keys[i]]=values[i];
			}
			return this;
		}

		/**
		 * 移除键值
		 * @param key 键值
		 *
		 */
		public function remove(key:Object):void
		{
			delete this.pool[key];
		}

		/**
		 * 判断是否存在键值
		 * @param key 建
		 * @return 返回布尔值 true 存在，false 不存在
		 *
		 */
		public function containsKey(key:Object):Boolean
		{
			return this.pool.hasOwnProperty(key);
		}

		/**
		 * 移除符合值的键值对
		 * @param value 值
		 * */
		public function removeValue(value:Object):void
		{
			for (var s:Object in this.pool)
			{
				if (this.pool[s] == value)
				{
					this.remove(s);
				}
			}
		}

		/**
		 * 判断是否存存在值
		 * @param v 值
		 * @return 返回布尔值 true 值存在,false 不存在
		 *
		 */
		public function containsValue(v:Object):Boolean
		{
			for each (var obj:Object in this.pool)
			{
				if (v == obj)
				{
					return true;
				}
			}
			return false;
		}

		/**
		 * 获取键集合
		 * @return 返回键集合
		 *
		 */
		public function get keys():Array
		{
			var t:Array=[];
			for (var s:Object in this.pool)
			{
				t.push(s);
			}
			return t;
		}

		/**
		 * 获取值
		 * @param key 键
		 * @return 返回值
		 *
		 */
		public function getValue(key:Object):Object
		{
			return this.pool[key];
		}

		/**
		 * 获取大小
		 * @return 返回大小
		 *
		 */
		public function get size():uint
		{
			return this.keys.length;
		}

		/**
		 * 是否为空
		 * @return 判断当前集合是否为空，true 为空, false 不为空
		 *
		 */
		public function get isEmpty():Boolean
		{
			return this.size <= 0;
		}

		/**
		 * 资源回收
		 *
		 */
		public function clear():void
		{
			var arr:Array=this.keys;
			for each (var s:Object in arr)
			{
				this.remove(s);
			}
		}
	}
}