[转]小小的字符串处理工具

http://bbs.9ria.com/viewthread.php?tid=80390&extra=page%3D1%26amp%3Borderby%3Ddateline%26amp%3Bfilter%3D2592000

今天闲的蛋疼，想到我一同事去面试，居然被面试官关于字符串处理的问题给难到了。我就想写一个小小的字符串处理工具类，不是很难，用起来还是很顺手的。有几个对外的方法。
isContains(os:string,cs:string):Boolean
检查字符串os中是否包含字符串cs；包含则返回true，否则返回false；对传入的字符串会检查是否为空；如果有一个为空则返回false；

showStringNum(os:string,cs:string):int
得到字符串cs在os中出现的次数。

insertString(os:string,cs:string,n:int):string
在字符串os下标为n的地方插入字符串cs；并返回新得到的字符串；（个人觉得这个功能还是很有用的）

stringIndexArr(os:string,cs:string):Array
找到字符串cs在os中的所有位置；并返回一个包含所有位置的数组；

delString(os:string,cs:string):string
删除字符串os中所有的cs；并返回删除后的字符串；

replaceString（os:string,ns:string,replace:string):string
在字符串os中，用replace替换所有的ns；并得到的新的字符串；


估计给那些对正则表达式还不是很熟悉的初学者应该还是有用的。

package  
{
        /**
         * @author wangyong
         */
        public class StringTools 
        {
                public static function get instance () : StringTools
                {
                        if(StringTools._stringTools)
                        {
                                return StringTools._stringTools;
                        }
                        else
                        {
                                StringTools._stringTools = new StringTools(new Single());
                                return StringTools._stringTools;
                        }
                }
                
                private static var _stringTools : StringTools;

                public function StringTools (s : Single)
                {
                        
                }

                
                //检查字符串是否包含一个特征字符串
                public function isContains (os : String,cs : String) : Boolean
                {
                        if(os.indexOf(cs) != - 1)
                        {
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                
                //某个字符串出现的次数
                public function showStringNum (os : String,cs : String) : int
                {
                        if(isContains(os, cs)&&checkStringLength(os)&&checkStringLength(cs))
                        {
                                return os.match(initRegExp(cs)).length;
                        }
                        else
                        return 0;
                }

                
                //在指定位置插入一个字符串
                public function insertString (os : String,cs : String,n : int) : String
                {
                        if(isContains(os, cs)&& n >=0 && n < os.length&&checkStringLength(os)&&checkStringLength(cs))
                        {
                                var strA : String = os.substring(0, n);
                                var strB : String = os.substring(n, os.length - 1);
                                return strA + cs + strB;
                        }
                        else
                        {
                                return null;
                        }
                }

                
                //在一个字符串中搜索特征字符串的所有下标（位置）
                public function stringIndexArr (os : String,cs : String) : Array
                {
                        if(isContains(os, cs)&&checkStringLength(os)&&checkStringLength(cs))
                        {
                                return checkString(os, cs);
                        }
                        else
                        {
                                return null;
                        }
                }

                
                //在一个字符串中删除特征字符串
                public function delString (os : String,cs : String) : String
                {
                        var arr:Array = os.split(initRegExp(cs));
                        var str:String;
                        for(var i:int = 0;i<arr.length;i++)
                        {
                                if(i==0)
                                {
                                        str = arr[i];
                                }else
                                {
                                        str += arr[i];
                                }
                        }
                        return str;
                }

                
                //替换字符串中所有的特征字符串
                public function replaceString (os : String,ns : String,replace:String) : String
                {
                        if(isContains(os, ns)&&checkStringLength(os)&&checkStringLength(ns)&&checkStringLength(replace))
                        return os.replace(initRegExp(ns), replace);
                        else 
                        return null;
                }

                //首先要检查一个传进来字符串的长度是否为零
                private function checkStringLength(os:String):Boolean
                {
                        if(os.length !=0)
                        {
                                return true;
                        }
                        else 
                        {
                                return false;
                        }
                }
                
                //初始化正则表达式，默认为全部搜索
                private function initRegExp (ns : String) : RegExp
                {
                        return new RegExp(ns, "g");
                }

                
                //特征字符在字符串里的下标。用了字符串匹配的一个算法
                private function checkString (os : String,ns : String) : Array
                {
                        var j : int = 0;
                        var arr : Array = new Array();
                        for(var i : int = 0;i < os.length;i++)
                        {
                                if(os.charAt(i) == ns.charAt(j))
                                {
                                        if(j == ns.length-1)
                                        {
                                                arr.push(i - ns.length + 1);
                                                j = 0;
                                        }
                                        else
                                        {
                                                j++;
                                        }
                                }
                                else
                                {
                                        j = 0;
                                }
                        }
                        
                        return arr;
                }
        }
}

class Single
{
}