/**
 *
 汉字转化为全拼
 *
 JDK版本:  1.4

public class CnToSpell {
    private static LinkedHashMap spellMap = null;

    static {
        if (spellMap == null) {
            spellMap = new LinkedHashMap(400);
        }
        initialize();
        System.out.println("Chinese transfer Spell Done.");
    }

    private CnToSpell() {
    }

    private static void spellPut(String spell, int ascii) {
        spellMap.put(spell, new Integer(ascii));
    }

    private static void initialize() {
        spellPut("a", -20319);
        spellPut("ai", -20317);
        spellPut("an", -20304);
        spellPut("ang", -20295);
        spellPut("ao", -20292);
        spellPut("ba", -20283);
        spellPut("bai", -20265);
        spellPut("ban", -20257);
        spellPut("bang", -20242);
        spellPut("bao", -20230);
        spellPut("bei", -20051);
        spellPut("ben", -20036);
        spellPut("beng", -20032);
        spellPut("bi", -20026);
        spellPut("bian", -20002);
        spellPut("biao", -19990);
        spellPut("bie", -19986);
        spellPut("bin", -19982);
        spellPut("bing", -19976);
        spellPut("bo", -19805);
        spellPut("bu", -19784);
        spellPut("ca", -19775);
        spellPut("cai", -19774);
        spellPut("can", -19763);
        spellPut("cang", -19756);
        spellPut("cao", -19751);
        spellPut("ce", -19746);
        spellPut("ceng", -19741);
        spellPut("cha", -19739);
        spellPut("chai", -19728);
        spellPut("chan", -19725);
        spellPut("chang", -19715);
        spellPut("chao", -19540);
        spellPut("che", -19531);
        spellPut("chen", -19525);
        spellPut("cheng", -19515);
        spellPut("chi", -19500);
        spellPut("chong", -19484);
        spellPut("chou", -19479);
        spellPut("chu", -19467);
        spellPut("chuai", -19289);
        spellPut("chuan", -19288);
        spellPut("chuang", -19281);
        spellPut("chui", -19275);
        spellPut("chun", -19270);
        spellPut("chuo", -19263);
        spellPut("ci", -19261);
        spellPut("cong", -19249);
        spellPut("cou", -19243);
        spellPut("cu", -19242);
        spellPut("cuan", -19238);
        spellPut("cui", -19235);
        spellPut("cun", -19227);
        spellPut("cuo", -19224);
        spellPut("da", -19218);
        spellPut("dai", -19212);
        spellPut("dan", -19038);
        spellPut("dang", -19023);
        spellPut("dao", -19018);
        spellPut("de", -19006);
        spellPut("deng", -19003);
        spellPut("di", -18996);
        spellPut("dian", -18977);
        spellPut("diao", -18961);
        spellPut("die", -18952);
        spellPut("ding", -18783);
        spellPut("diu", -18774);
        spellPut("dong", -18773);
        spellPut("dou", -18763);
        spellPut("du", -18756);
        spellPut("duan", -18741);
        spellPut("dui", -18735);
        spellPut("dun", -18731);
        spellPut("duo", -18722);
        spellPut("e", -18710);
        spellPut("en", -18697);
        spellPut("er", -18696);
        spellPut("fa", -18526);
        spellPut("fan", -18518);
        spellPut("fang", -18501);
        spellPut("fei", -18490);
        spellPut("fen", -18478);
        spellPut("feng", -18463);
        spellPut("fo", -18448);
        spellPut("fou", -18447);
        spellPut("fu", -18446);
        spellPut("ga", -18239);
        spellPut("gai", -18237);
        spellPut("gan", -18231);
        spellPut("gang", -18220);
        spellPut("gao", -18211);
        spellPut("ge", -18201);
        spellPut("gei", -18184);
        spellPut("gen", -18183);
        spellPut("geng", -18181);
        spellPut("gong", -18012);
        spellPut("gou", -17997);
        spellPut("gu", -17988);
        spellPut("gua", -17970);
        spellPut("guai", -17964);
        spellPut("guan", -17961);
        spellPut("guang", -17950);
        spellPut("gui", -17947);
        spellPut("gun", -17931);
        spellPut("guo", -17928);
        spellPut("ha", -17922);
        spellPut("hai", -17759);
        spellPut("han", -17752);
        spellPut("hang", -17733);
        spellPut("hao", -17730);
        spellPut("he", -17721);
        spellPut("hei", -17703);
        spellPut("hen", -17701);
        spellPut("heng", -17697);
        spellPut("hong", -17692);
        spellPut("hou", -17683);
        spellPut("hu", -17676);
        spellPut("hua", -17496);
        spellPut("huai", -17487);
        spellPut("huan", -17482);
        spellPut("huang", -17468);
        spellPut("hui", -17454);
        spellPut("hun", -17433);
        spellPut("huo", -17427);
        spellPut("ji", -17417);
        spellPut("jia", -17202);
        spellPut("jian", -17185);
        spellPut("jiang", -16983);
        spellPut("jiao", -16970);
        spellPut("jie", -16942);
        spellPut("jin", -16915);
        spellPut("jing", -16733);
        spellPut("jiong", -16708);
        spellPut("jiu", -16706);
        spellPut("ju", -16689);
        spellPut("juan", -16664);
        spellPut("jue", -16657);
        spellPut("jun", -16647);
        spellPut("ka", -16474);
        spellPut("kai", -16470);
        spellPut("kan", -16465);
        spellPut("kang", -16459);
        spellPut("kao", -16452);
        spellPut("ke", -16448);
        spellPut("ken", -16433);
        spellPut("keng", -16429);
        spellPut("kong", -16427);
        spellPut("kou", -16423);
        spellPut("ku", -16419);
        spellPut("kua", -16412);
        spellPut("kuai", -16407);
        spellPut("kuan", -16403);
        spellPut("kuang", -16401);
        spellPut("kui", -16393);
        spellPut("kun", -16220);
        spellPut("kuo", -16216);
        spellPut("la", -16212);
        spellPut("lai", -16205);
        spellPut("lan", -16202);
        spellPut("lang", -16187);
        spellPut("lao", -16180);
        spellPut("le", -16171);
        spellPut("lei", -16169);
        spellPut("leng", -16158);
        spellPut("li", -16155);
        spellPut("lia", -15959);
        spellPut("lian", -15958);
        spellPut("liang", -15944);
        spellPut("liao", -15933);
        spellPut("lie", -15920);
        spellPut("lin", -15915);
        spellPut("ling", -15903);
        spellPut("liu", -15889);
        spellPut("long", -15878);
        spellPut("lou", -15707);
        spellPut("lu", -15701);
        spellPut("lv", -15681);
        spellPut("luan", -15667);
        spellPut("lue", -15661);
        spellPut("lun", -15659);
        spellPut("luo", -15652);
        spellPut("ma", -15640);
        spellPut("mai", -15631);
        spellPut("man", -15625);
        spellPut("mang", -15454);
        spellPut("mao", -15448);
        spellPut("me", -15436);
        spellPut("mei", -15435);
        spellPut("men", -15419);
        spellPut("meng", -15416);
        spellPut("mi", -15408);
        spellPut("mian", -15394);
        spellPut("miao", -15385);
        spellPut("mie", -15377);
        spellPut("min", -15375);
        spellPut("ming", -15369);
        spellPut("miu", -15363);
        spellPut("mo", -15362);
        spellPut("mou", -15183);
        spellPut("mu", -15180);
        spellPut("na", -15165);
        spellPut("nai", -15158);
        spellPut("nan", -15153);
        spellPut("nang", -15150);
        spellPut("nao", -15149);
        spellPut("ne", -15144);
        spellPut("nei", -15143);
        spellPut("nen", -15141);
        spellPut("neng", -15140);
        spellPut("ni", -15139);
        spellPut("nian", -15128);
        spellPut("niang", -15121);
        spellPut("niao", -15119);
        spellPut("nie", -15117);
        spellPut("nin", -15110);
        spellPut("ning", -15109);
        spellPut("niu", -14941);
        spellPut("nong", -14937);
        spellPut("nu", -14933);
        spellPut("nv", -14930);
        spellPut("nuan", -14929);
        spellPut("nue", -14928);
        spellPut("nuo", -14926);
        spellPut("o", -14922);
        spellPut("ou", -14921);
        spellPut("pa", -14914);
        spellPut("pai", -14908);
        spellPut("pan", -14902);
        spellPut("pang", -14894);
        spellPut("pao", -14889);
        spellPut("pei", -14882);
        spellPut("pen", -14873);
        spellPut("peng", -14871);
        spellPut("pi", -14857);
        spellPut("pian", -14678);
        spellPut("piao", -14674);
        spellPut("pie", -14670);
        spellPut("pin", -14668);
        spellPut("ping", -14663);
        spellPut("po", -14654);
        spellPut("pu", -14645);
        spellPut("qi", -14630);
        spellPut("qia", -14594);
        spellPut("qian", -14429);
        spellPut("qiang", -14407);
        spellPut("qiao", -14399);
        spellPut("qie", -14384);
        spellPut("qin", -14379);
        spellPut("qing", -14368);
        spellPut("qiong", -14355);
        spellPut("qiu", -14353);
        spellPut("qu", -14345);
        spellPut("quan", -14170);
        spellPut("que", -14159);
        spellPut("qun", -14151);
        spellPut("ran", -14149);
        spellPut("rang", -14145);
        spellPut("rao", -14140);
        spellPut("re", -14137);
        spellPut("ren", -14135);
        spellPut("reng", -14125);
        spellPut("ri", -14123);
        spellPut("rong", -14122);
        spellPut("rou", -14112);
        spellPut("ru", -14109);
        spellPut("ruan", -14099);
        spellPut("rui", -14097);
        spellPut("run", -14094);
        spellPut("ruo", -14092);
        spellPut("sa", -14090);
        spellPut("sai", -14087);
        spellPut("san", -14083);
        spellPut("sang", -13917);
        spellPut("sao", -13914);
        spellPut("se", -13910);
        spellPut("sen", -13907);
        spellPut("seng", -13906);
        spellPut("sha", -13905);
        spellPut("shai", -13896);
        spellPut("shan", -13894);
        spellPut("shang", -13878);
        spellPut("shao", -13870);
        spellPut("she", -13859);
        spellPut("shen", -13847);
        spellPut("sheng", -13831);
        spellPut("shi", -13658);
        spellPut("shou", -13611);
        spellPut("shu", -13601);
        spellPut("shua", -13406);
        spellPut("shuai", -13404);
        spellPut("shuan", -13400);
        spellPut("shuang", -13398);
        spellPut("shui", -13395);
        spellPut("shun", -13391);
        spellPut("shuo", -13387);
        spellPut("si", -13383);
        spellPut("song", -13367);
        spellPut("sou", -13359);
        spellPut("su", -13356);
        spellPut("suan", -13343);
        spellPut("sui", -13340);
        spellPut("sun", -13329);
        spellPut("suo", -13326);
        spellPut("ta", -13318);
        spellPut("tai", -13147);
        spellPut("tan", -13138);
        spellPut("tang", -13120);
        spellPut("tao", -13107);
        spellPut("te", -13096);
        spellPut("teng", -13095);
        spellPut("ti", -13091);
        spellPut("tian", -13076);
        spellPut("tiao", -13068);
        spellPut("tie", -13063);
        spellPut("ting", -13060);
        spellPut("tong", -12888);
        spellPut("tou", -12875);
        spellPut("tu", -12871);
        spellPut("tuan", -12860);
        spellPut("tui", -12858);
        spellPut("tun", -12852);
        spellPut("tuo", -12849);
        spellPut("wa", -12838);
        spellPut("wai", -12831);
        spellPut("wan", -12829);
        spellPut("wang", -12812);
        spellPut("wei", -12802);
        spellPut("wen", -12607);
        spellPut("weng", -12597);
        spellPut("wo", -12594);
        spellPut("wu", -12585);
        spellPut("xi", -12556);
        spellPut("xia", -12359);
        spellPut("xian", -12346);
        spellPut("xiang", -12320);
        spellPut("xiao", -12300);
        spellPut("xie", -12120);
        spellPut("xin", -12099);
        spellPut("xing", -12089);
        spellPut("xiong", -12074);
        spellPut("xiu", -12067);
        spellPut("xu", -12058);
        spellPut("xuan", -12039);
        spellPut("xue", -11867);
        spellPut("xun", -11861);
        spellPut("ya", -11847);
        spellPut("yan", -11831);
        spellPut("yang", -11798);
        spellPut("yao", -11781);
        spellPut("ye", -11604);
        spellPut("yi", -11589);
        spellPut("yin", -11536);
        spellPut("ying", -11358);
        spellPut("yo", -11340);
        spellPut("yong", -11339);
        spellPut("you", -11324);
        spellPut("yu", -11303);
        spellPut("yuan", -11097);
        spellPut("yue", -11077);
        spellPut("yun", -11067);
        spellPut("za", -11055);
        spellPut("zai", -11052);
        spellPut("zan", -11045);
        spellPut("zang", -11041);
        spellPut("zao", -11038);
        spellPut("ze", -11024);
        spellPut("zei", -11020);
        spellPut("zen", -11019);
        spellPut("zeng", -11018);
        spellPut("zha", -11014);
        spellPut("zhai", -10838);
        spellPut("zhan", -10832);
        spellPut("zhang", -10815);
        spellPut("zhao", -10800);
        spellPut("zhe", -10790);
        spellPut("zhen", -10780);
        spellPut("zheng", -10764);
        spellPut("zhi", -10587);
        spellPut("zhong", -10544);
        spellPut("zhou", -10533);
        spellPut("zhu", -10519);
        spellPut("zhua", -10331);
        spellPut("zhuai", -10329);
        spellPut("zhuan", -10328);
        spellPut("zhuang", -10322);
        spellPut("zhui", -10315);
        spellPut("zhun", -10309);
        spellPut("zhuo", -10307);
        spellPut("zi", -10296);
        spellPut("zong", -10281);
        spellPut("zou", -10274);
        spellPut("zu", -10270);
        spellPut("zuan", -10262);
        spellPut("zui", -10260);
        spellPut("zun", -10256);
        spellPut("zuo", -10254);
    }

    /**
     * 获得单个汉字的Ascii.
     * @param cn char
     * 汉字字符
     * @return int
     * 错误返回 0,否则返回ascii
     */
    public static int getCnAscii(char cn) {
        byte[] bytes = (String.valueOf(cn)).getBytes();
        if (bytes == null || bytes.length > 2 || bytes.length <= 0) { //错误
            return 0;
        }
        if (bytes.length == 1) { //英文字符
            return bytes[0];
        }
        if (bytes.length == 2) { //中文字符
            int hightByte = 256 + bytes[0];
            int lowByte = 256 + bytes[1];

            int ascii = (256 * hightByte + lowByte) - 256 * 256;

//System.out.println("ASCII=" + ascii);

            return ascii;
        }

        return 0; //错误
    }

    /**
     * 根据ASCII码到SpellMap中查找对应的拼音
     * @param ascii int
     * 字符对应的ASCII
     * @return String
     * 拼音,首先判断ASCII是否>0&<160,如果是返回对应的字符,
     *
     否则到SpellMap中查找,如果没有找到拼音,则返回null,如果找到则返回拼音.
     */
    public static String getSpellByAscii(int ascii) {
        if (ascii > 0 && ascii < 160) { //单字符
            return String.valueOf((char) ascii);
        }

        if (ascii < -20319 || ascii > -10247) { //不知道的字符
            return null;
        }

        Set keySet = spellMap.keySet();
        Iterator it = keySet.iterator();

        String spell0 = null; ;
        String spell = null;

        int asciiRang0 = -20319;
        int asciiRang;
        while (it.hasNext()) {

            spell = (String) it.next();
            Object valObj = spellMap.get(spell);
            if (valObj instanceof Integer) {
                asciiRang = ((Integer) valObj).intValue();

                if (ascii >= asciiRang0 && ascii < asciiRang) { //区间找到
                    return (spell0 == null) ? spell : spell0;
                } else {
                    spell0 = spell;
                    asciiRang0 = asciiRang;
                }
            }
        }

        return null;

    }

    /**
     * 返回字符串的全拼,是汉字转化为全拼,其它字符不进行转换
     * @param cnStr String
     * 字符串
     * @return String
     * 转换成全拼后的字符串
     */
    public static String getFullSpell(String cnStr) {
        if (null == cnStr || "".equals(cnStr.trim())) {
            return cnStr;
        }

        char[] chars = cnStr.toCharArray();
        StringBuffer retuBuf = new StringBuffer();
        for (int i = 0, Len = chars.length; i < Len; i++) {
            int ascii = getCnAscii(chars[i]);
            if (ascii == 0) { //取ascii时出错
                retuBuf.append(chars[i]);
            } else {
                String spell = getSpellByAscii(ascii);
                if (spell == null) {
                    retuBuf.append(chars[i]);
                } else {
                    retuBuf.append(spell);
                } // end of if spell == null
            } // end of if ascii <= -20400
        } // end of for

        return retuBuf.toString();
    }

    public static String getFirstSpell(String cnStr) {
        return null;
    }

    public static void main(String[] args) {
        String str = null;
        str = "小红帽";
        System.out.println("Spell=" + CnToSpell.getFullSpell(str));   }
}

import java.lang.String.*;
import java.util.*;
import java.text.*;
import java.util.regex.*;
import sun.misc.BASE64Decoder;

public class StringOperate {

    String Error = new String("");  //As Err 代码
    /*
    功能：初始化
    输入参数：无输入参数
    返回值：无返回值
    */
    public StringOperate() {
        Error = "";
    }
    public static void main(String[] args){
     String temp="";
     StringOperate so=new StringOperate();
     temp=so.StringPlus1("aZ");
     System.out.print(temp);
    }
    /**
    * 功能：将原字符串修改为固定长度的字符串
    * （字数不足的，则在指定方向加入指定字符；字数超出的，则从左侧截取指定长度）
    * @param xstring 要进行处理的字符串
    * @param xlength 要修改的目标长度
    * @param xin 字数长度不够的时候，要增加的指定字符（字长1位）
    * @param xtarget 指定的方向(l=左，r=右)
    * @return 返回处理后的字符串，如果有错返回""
    */
    public String Make_Length(String xstring, int xlength, String xin, char xtarget) {
        String xxin,xinstr,xtempstr;
        int xxlength,i;
        xxlength = xlength;
        xxin = "";
        xinstr = "";
        xtempstr = "";

        if (xin.length()<1){
            xxin = "0"; //默认信息
        }
        else if(xin.length() > 1){
            xxin = xin.substring(0,1);
        }
        else{
            xxin = xin;
        }

        if (xstring.length() > xxlength) { //比预定字符串短，要截取
            if (xtarget == 'r'){
                xtempstr = xstring.substring(xstring.length()-xxlength, xstring.length()) ;
            }
            else { //默认为左侧
                xtempstr = xstring.substring(0, xxlength);
            }
        }
        else if (xstring.length() < xxlength){  //比预定字符串长，要增加指定字符
            xinstr = "";
            for (i = 1; i<= xxlength - xstring.length(); i++){
                xinstr = xinstr + xxin;
            }
            if (xtarget == 'r') {
                xtempstr = xstring + xinstr;
            }
            else { //默认为左侧
                xtempstr = xinstr + xstring;
            }
        }
        else {
            xtempstr = xstring;
        }

     return xtempstr;
    }

    /**
    * 功能：将文本格式的字符串转变为适合html页面浏览的字符串
    * @param xstring 要进行处理的字符串
    * @return 返回处理后的字符串，如果有错返回""
    */
    public String HtmlEncode(String xstring){
        String xtempstr;
        xtempstr = GetNoNull(xstring);

        xtempstr = xtempstr.replaceAll("&", "&amp;");
        //xtempstr = replace(xtempstr, "  ", "&nbsp; ")
        xtempstr = xtempstr.replaceAll("  ", "&nbsp;&nbsp;");
        xtempstr = xtempstr.replaceAll(Character.toString((char) 34), "&quot;"); //双引号
        xtempstr = xtempstr.replaceAll(Character.toString((char) 39), "&#39;"); //单引号
        xtempstr = xtempstr.replaceAll(">", "&gt;");
        xtempstr = xtempstr.replaceAll("<", "&lt;");
        xtempstr = xtempstr.replaceAll("\r\n", "<br>");
        xtempstr = xtempstr.replaceAll("\n", "<br>");

        return xtempstr;
    }

    /**
    * 功能：将文本格式的字符串转变为适合html页面TEXT文本框内浏览的字符串
    * @param xstring 要进行处理的字符串
    * @return 返回处理后的字符串，如果有错返回“”
    */
    public String HtmlEncodeText(String xstring){
        String xtempstr;
        xtempstr = GetNoNull(xstring);

        //xtempstr = xtempstr.replaceAll("  ", "&nbsp;&nbsp;");
        //xtempstr = replace(xtempstr, "  ", "&nbsp; ")
        xtempstr = xtempstr.replaceAll(">", "&gt;");
        xtempstr = xtempstr.replaceAll("<", "&lt;");
        //xtempstr = xtempstr.replaceAll("\n", "<br>");

        return xtempstr;
    }

    /**
    * 功能：将文本格式的字符串转变为适合wml页面浏览的字符串
    * @param xstring 要进行处理的字符串
    * @return 返回处理后的字符串，如果有错返回""
    */
    public String WmlEncode(String xstring){
        String xtempstr;
        xtempstr = GetNoNull(xstring);

        xtempstr = xtempstr.replaceAll("&", "&amp;");
        //xtempstr = replace(xtempstr, "  ", "&nbsp; ")
        xtempstr = xtempstr.replaceAll("  ", "&nbsp;&nbsp;");
        xtempstr = xtempstr.replaceAll(Character.toString((char) 34), "&quot;"); //双引号
        xtempstr = xtempstr.replaceAll(Character.toString((char) 39), "&#39;"); //单引号
        xtempstr = xtempstr.replaceAll(">", "&gt;");
        xtempstr = xtempstr.replaceAll("<", "&lt;");
        xtempstr = xtempstr.replaceAll("\r\n", "<br/>");
        xtempstr = xtempstr.replaceAll("\n", "<br/>");

        return xtempstr;
    }

    /**
    * 功能：将html页面浏览的字符串转变为文本格式的字符串 (与HtmlToText 函数对应并且匹配)，用于提交表单的数据还原
    * @param xstring 要进行处理的字符串
    * @return 返回处理后的字符串，如果有错返回""
    */
    public String unHtmlEncode(String xstring){
        String xtempstr;
        xtempstr = GetNoNull(xstring);

        xtempstr = xtempstr.replaceAll("&nbsp;", " ");
        xtempstr = xtempstr.replaceAll("&amp;", "&");
        xtempstr = xtempstr.replaceAll("&quot;", Character.toString((char) 34)); //双引号
        xtempstr = xtempstr.replaceAll( "&#39;", Character.toString((char) 39)); //单引号
        xtempstr = xtempstr.replaceAll("&gt;", ">");
        xtempstr = xtempstr.replaceAll("&lt;", "<");
        xtempstr = xtempstr.replaceAll("<br>", "\r\n");

        return xtempstr;
    }

    /**
    * 功能：整理日期变量为标准的 yyyy-MM-dd H:m:s 格式
    * @param xdate 需要处理的日期型变量
    * @param 返回整理后的规定格式日期字符串,如果为非法日期返回"",同时将传入参数xdate转变为规范格式
    */
   public String GetDate(String xdate){
      String xtempstr;
      SimpleDateFormat timeformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      xtempstr = GetNoNull(xdate);

      if (xtempstr.length() > 0) {
          if (toDate(xdate)!=null) {
              xtempstr = timeformat.format(toDate(xdate));
          }
          else{
              xtempstr = "";
          }

      }
      return xtempstr;
    }

    /**
    * 此类别内私用函数，功能：将标准 yyyy-MM-dd H:m:s 格式字符串转变为Date变量
    * @param xdate 需要处理的日期型变量
    * @return 返回整理后的日期型变量,如果为非法日期格式字符串返回null
    */
    public Date toDate(String xdate){

        java.text.SimpleDateFormat sdf=new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            java.util.Date d=sdf.parse(xdate);
            java.sql.Date d1=new java.sql.Date(d.getTime());
            return d1;
        }
        catch (Exception ex) {
            System.out.println("sms stringclass error:" + ex);
            return null;
        }

    }

    /**
    * 功能：求得xnum位的随机ID值
    * @param xnum 随机数的长度（位数）
    * @return xnum位数的随机数
    */
    public String MakeRnd(int xnum) {
        int i,j,k;
        String xx;
        xx = "";

        for (i = 1; i <= xnum; i++) {

            //取1-3的随机数
            j = ((int)((3 - 1 + 1) * java.lang.Math.random() + 1));
            if (j == 1) {
                //取1-26的随机数
                k = 96 + ((int)((26 - 1 + 1) * java.lang.Math.random() + 1)); //a -z
            }
            else if (j == 2) {
                //取1 - 26的随机数
                k = 64 + ((int)((26 - 1 + 1) * java.lang.Math.random() + 1)); //A -Z
            }
            else {
                //取1 - 10的随机数
                k = 47 + ((int)((10 - 1 + 1) * java.lang.Math.random() + 1)); //0 -9
            }
            xx = xx + (char) k;
        }

        return xx;

    }

    /**
   * 功能：求得xnum位的随机ID值---小写字符+数字
   * @param xnum 随机数的长度（位数）
   * @return xnum位数的随机数
   */
   public String MakePassWordRnd(int xnum) {
       int i,j,k;
       String xx;
       xx = "";
       for (i = 1; i <= xnum; i++) {
           j = ((int)((2 - 1 + 1) * java.lang.Math.random() + 1));
           //取1-2的随机数
           if (j == 1) {
               //取1-26的随机数
               k = 96 + ((int)((26 - 1 + 1) * java.lang.Math.random() + 1)); //a -z
           }
           else {
               //取1 - 10的随机数
               k = 47 + ((int)((10 - 1 + 1) * java.lang.Math.random() + 1)); //0 -9
           }
           xx = xx + (char) k;
       }
       return xx;

   }

    /**
    * 功能：输出文件扩展名
    * @param FileName 文件全名
    * @return 扩展名
    */
     public String GetExtendName(String FileName) {
         String ExtName;
         ExtName = FileName.toLowerCase();
         if (ExtName.lastIndexOf(".")>=0){
             ExtName = ExtName.substring(ExtName.lastIndexOf("."), ExtName.length());
         }
         else{
             ExtName = "";
         }

         return ExtName;
     }

     /**
     * 功能：输出字符串的长度，可区别中英文（中文字符将占2个长度）
     * @param xstring 需要测长的字符串
     * @return 纯英文字符串长度
     */
     public int CnLength(String xstring) {
        int p_len, xx, ascChr;
        char xchar;
        p_len = 0;
        xx = 0;
        if (xstring == null) {
            xx = 0;
        }
        else {
            for ( xx = 1; xx <= xstring.length(); xx++ ) {
                xchar = xstring.charAt(xx-1);
                ascChr = xchar + 0;

                if (ascChr > 128) {
                    p_len = p_len + 2;
                }
                else {
                    p_len = p_len + 1;
                }
            }
        }
        return p_len;
    }

    /**
    * 功能：控制输出字符串的长度，可区别中英文
    * 例如：strvalue("复请Email通知如果不填写则取注册Email",26)
    * 这里26是指26个英文字母，也就是13个汉字
    * @param xstring 需要检测的字符串
    * @return 被按照制定长度截取后的字符串（如果不够长则输出全部字符串）
    */
    public String CnLeft(String xstring, int lennum) {
       int p_num,i,xx,ascChr;
       String xtempstr;
       char xchar;

       if (CnLength(xstring) <= lennum ) {
           xtempstr = xstring;
       }
       else {
           p_num = 0;
           xx = 0;
           while (p_num < lennum) {
               xx = xx + 1;
               xchar = xstring.charAt(xx-1);
               ascChr = xchar + 0;
               if (ascChr > 128) {
                   p_num = p_num + 2;
                   if(p_num>lennum) {
                       xx = xx - 1;
                   }
               }
               else {
                   p_num = p_num + 1;
               }
           }
           xtempstr = xstring.substring(0,xx);
       }

       return xtempstr;
    }

    /**
    * 功能：将中文字符转变为Unicode为了wap页面使用
    * @param xinPara 需要转变的字符串
    * @return 转变编码后
    */
    public String toUnicode(String xinPara){
        char temChr;
        int ascChr, i;
        String rtStr = new String("");
        String inPara = GetNoNull(xinPara);

        for(i=0; i<inPara.length(); i++){
            temChr=inPara.charAt(i);
            ascChr=temChr+0;
            //System.out.println(ascChr);
            //System.out.println(Integer.toBinaryString(ascChr));
            if (ascChr > 128) {
                rtStr = rtStr + "&#x" + Integer.toHexString(ascChr) + ";";
            }
            else {
                rtStr = rtStr + temChr;
            }
        }
        return rtStr;
    }

    /**
   * 分割字串
   * @param source 原始字符
   * @param div 分割符
   * @return 字符串数组
   */
   public static String[] split(String source,String div){
       int arynum = 0,intIdx=0,intIdex=0,div_length = div.length();
       if(source.compareTo("")!=0){
           if(source.indexOf(div)!=-1){
               intIdx = source.indexOf(div);
               for(int intCount =1 ; ; intCount++){
                   if(source.indexOf(div,intIdx+div_length)!=-1){
                       intIdx= source.indexOf(div,intIdx+div_length);
                       arynum = intCount;
                   }
                   else {arynum+=2;break;}
               }
           }
           else arynum =1;
       }
       else arynum = 0;

       intIdx=0;
       intIdex=0;
       String[] returnStr = new String[arynum];

       if(source.compareTo("")!=0){
           if(source.indexOf(div)!=-1){
               intIdx = (int)source.indexOf(div);
               returnStr[0]= (String)source.substring(0,intIdx);
               for(int intCount =1 ; ; intCount++){
                   if(source.indexOf(div,intIdx+div_length)!=-1){
                       intIdex=(int)source.indexOf(div,intIdx+div_length);
                       returnStr[intCount] = (String)source.substring(intIdx+div_length,intIdex);
                       intIdx = (int)source.indexOf(div,intIdx+div_length);
                   }
                   else {
                       returnStr[intCount] = (String)source.substring(intIdx+div_length,source.length());
                       break;
                   }
               }
           }
           else {returnStr[0] = (String)source.substring(0,source.length());return returnStr;}
       }
       else {return returnStr;}
       return returnStr;
   }

     /**
     * 功能：将null的字符串变量变为""，以方便程序使用
     * @param xStr 字符串变量
     * @return 整理后的字符串
     */
     public String GetNoNull(String xStr) {
         String xstring;
         if (xStr == null){
             xstring = "";
         }
         else{
             xstring = xStr;
         }
         return xstring;
     }

     /**
     * 功能：将字符串加密
     * @param xStr 字符串变量
     * @return 加密后的字符串
     */
     public String toPassword(String xStr) {
         String xstring;
         xstring = GetNoNull(xStr);
         return xstring;
     }

     /**
     * 功能：将字符串解密
     * @param xStr 被加密的字符串变量
     * @return 解密后的字符串
     */
     public String unPassword(String xStr) {
         String xstring;
         xstring = GetNoNull(xStr);
         return xstring;
     }

     /**
      * 功能：判断字符串是否为正整数
      * @param xStr 需要被判断的字符串变量
      * @return 如果是正整数返回True，否则返回False
      */
     public boolean isNumber(String xStr) {
         char[] c = xStr.toCharArray();
         boolean xjudge = true;
         if(xStr.length()>0) {
             for (int i = 0; i < c.length; i++) {
                 char ch = c[i];
                 if (!Character.isDigit(ch)) {
                     xjudge = false;
                     i = c.length;
                 }
             }
         }
         else {
             xjudge = false;
         }
         return xjudge;
     }

     /**
      * 功能：将10进制数转变为36进制字符串
      * @param Number 需要转变的10进制数
      * @return 转变后的36进制字符串
      */
     public String get36Str(int Number) {
         String NewStr = "";
         if(Number==0) {
             NewStr = "0";
         }
         while (Number>0) {
             int iNumber;
             char cNumber;
             iNumber = Number % 36;
             if (iNumber > 9) {
                 cNumber = (char) (iNumber + 55);
             } else {
                 cNumber = (char) (iNumber + 48);
             }
             NewStr = cNumber + NewStr;
             Number = (Number - iNumber) / 36;
         }
         return NewStr;
     }

     /**
      * 功能：获取当前时间标准格式的字符串
      * @return 时间字符串
      */
     public String getNow() {
         String xNow;
         Date date01 = new Date();
         java.sql.Timestamp date02  = new java.sql.Timestamp(date01.getTime());
         xNow = date02.toString();
         return xNow;
     }

     /**
      * 功能：获取距离当前时间相差X秒时间标准格式的字符串
      * @param Second 相差秒数
      * @return 时间字符串
      */
     public String getNowS(int Second) {
         String xNow;
         //获取当前时间之前10秒的时间变量，用于调用需要重新处理的短信息
         Calendar tcal01 = Calendar.getInstance();
         tcal01.setTime(new Date());
         tcal01.add(Calendar.SECOND, Second);
         Date date01 = tcal01.getTime();
         java.sql.Timestamp date02  = new java.sql.Timestamp(date01.getTime());
         xNow = this.GetDate(date02.toString());
         return xNow;
     }
     /**
      * 功能：获取距离指定时间相差X秒时间标准格式的字符串
      * @param TargetDate 指定时间
      * @param Second 相差秒数
      * @return 时间字符串
      */
     public String getNowS(String TargetDate, int Second) {
         String xNow;
         //获取当前时间之前10秒的时间变量，用于调用需要重新处理的短信息
         Calendar tcal01 = Calendar.getInstance();
         tcal01.setTime(this.toDate(TargetDate));
         tcal01.add(Calendar.SECOND, Second);
         Date date01 = tcal01.getTime();
         java.sql.Timestamp date02  = new java.sql.Timestamp(date01.getTime());
         xNow = this.GetDate(date02.toString());
         return xNow;
     }
    
     public String getNowS(String xdate, String TimeType, int TimeNumber) {
      Calendar tcal01 = Calendar.getInstance();
      Date TargetDate = toDate(xdate);
      String xNow = null;
      if(TargetDate!=null) {
          tcal01.setTime(TargetDate);
          if(TimeType.equals("year")) {
           tcal01.add(Calendar.YEAR, TimeNumber);
          } else if(TimeType.equals("month")) {
           tcal01.add(Calendar.MONTH, TimeNumber);
          } else if(TimeType.equals("day")) {
           tcal01.add(Calendar.DAY_OF_MONTH, TimeNumber);
          } else if(TimeType.equals("hour")) {
           tcal01.add(Calendar.HOUR_OF_DAY, TimeNumber);
          } else if(TimeType.equals("minute")) {
           tcal01.add(Calendar.MINUTE, TimeNumber);
          } else if(TimeType.equals("second")) {
           tcal01.add(Calendar.SECOND, TimeNumber);
          }
         
          java.util.Date date01 = tcal01.getTime();
          SimpleDateFormat xDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
          xNow = xDateFormat.format(date01);
         }
         return xNow;
     }

     /**
      * 功能：获取从x到y的随机数（正整数）
      * @param xMin 最小值
      * @param xMax 最大值
      * @return 随机数值
      */
     public int getRnd01(int xMin, int xMax) {
         int xRnd;
         xRnd = 0;
         if(xMin>xMax) {
             xMin = xMin + xMax;
             xMax = xMin - xMax;
             xMin = xMin - xMax;
         }
         xRnd = (xMin) + ((int)((xMax-xMin+1) * java.lang.Math.random()));

         return xRnd;
     }

     /**
      * 功能：校验是否格式正确的手机号或电话号码
      * @param xNumber 电话号码
      * @return 随机数值
      */
     public boolean isPhone(String xNumber) {
         boolean judgeSign = false;

         Pattern p = Pattern.compile("^[1][3][0-9]{9}$"); //校验手机号码
         Matcher m = p.matcher(xNumber);
         if(m.matches()) {
             judgeSign = true;
         }
         else {
             p = Pattern.compile("^([0][1-9][0-9]{1,2})[0-9]{6,8}$"); //校验座机号码
             m = p.matcher(xNumber);
             if(m.matches()) {
                 judgeSign = true;
             }
         }
//         System.out.println(xxx + "," + m.matches());

         return judgeSign;
     }

     /**
     * 功能：除法运算(小数点后保留2位)
     * @param molecule 分子
     * @param denominator 分母
     */
     public String division(String molecule,String denominator){
         float num3 = 0.0f;
         float mole = Float.parseFloat(molecule); //(float)molecule1;
         float deno = Float.parseFloat(denominator); //(float)denominator1;
         //System.out.println("--mole--" + mole + "--" + deno);

         if (Float.parseFloat(molecule) != 0) {
             num3 = mole / deno;
         }
         String radio = new java.text.DecimalFormat("###.##").format(num3);
         //System.out.println("小数点后面保留二位:"+radio);
         return radio;
     }

     /**
     * 功能：Base64编码
     * @param xstring 要进行处理的字符串
     */
     public String base64_Encode(String xstring) {
         String xtempstr = "";
         if (xstring == null) {
             return null;
         }
         xtempstr =  (new sun.misc.BASE64Encoder()).encode( xstring.getBytes() );

         return xtempstr;
     }

     /**
     * 功能：Base64解码
     * @param xstring 要进行处理的字符串
     */
     public String base64_Decode(String xstring) {
         String xtempstr = "";

         if (xstring == null) {
             return null;
         }
         try {
             sun.misc.BASE64Decoder decoder = new BASE64Decoder();
             byte[] b = decoder.decodeBuffer(xstring);
             xtempstr =  new String(b);
         } catch (Exception e) {
             return null;
         }
         return xtempstr;
     }
     /**大写字符串加1 如AB->AC AZ->BA；如遇到小写字符或ZZ则报溢出错误
      * @param xstring 大写字符串
      * @return 字符串加1后返回结果
      */
     public String StringPlus1(String xstring){
      String xtempstr="";
       if (xstring == null) {
              return null;
          }
     
          try {
           char xchar[]=xstring.toCharArray();
           //System.out.print((int)++xchar[1]);
           for(int i=xstring.length()-1;i>=0;i--){
            if((int)++xchar[i]>90){
             xchar[i]='A';
             if(i==0){
              System.out.print("溢出！");
              return null;
             }
            }
            else
            {
             System.out.print("");
             break;
            }
           }
           for(int j=0;j<xstring.length();j++)
            xtempstr=xtempstr+xchar[j];
          }catch(Exception e){
           System.err.print(e.getMessage());
           return null;
          }
          return xtempstr;
     }
}

   // 数据库中有一个item表，其中的file_name (varchar2)存储文件名，file_blob (blob)存储文件对象
  String sql="INSERT INTO item (file_name,file_blob) VALUES ('" + file_name + "',EMPTY_BLOB())";  // 使用“EMPTY_BLOB()“成生一个空blob
  Statement stmt=conn.createStatement();
  int count=stmt.executeUpdate(sql);
  
  sql="SELECT file_blob FROM item WHERE iid='" + iid + "' FOR UPDATE";  // 使用“FOR UPDATE”得到表的写锁
  ResultSet rs=stmt.executeQuery(sql);
  rs.next();
  BLOB blob=((OracleResultSet)rs).getBLOB("file_blob");  // 得到BLOB对象
  OutputStream out=blob.getBinaryOutputStream();  // 建立输出流
  InputStream in=new FileInputStream(file);  // 建立输入流
  int size=blob.getBufferSize();
  byte[] buffer=new byte[size];  // 建立缓冲区
  int len;
  while((len=in.read(buffer)) != -1)
    out.write(buffer,0,len);
  in.close();
  out.close();

  conn.commit();
}
catch(Exception ex){
  try{
    conn.rollback();
  }
  catch(SQLException sqle){
    System.err.println(sqle.getMessage());
  }
}

如果要读出文件的话只需调用BLOB的getBinaryStream()生成一个输入流，再写入一个文件就行了。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=779983