_strsplit.java

根据用户定义char型字符分割字符串

package hp.base.util;

/**
 * <p>Title: short message</p>
 * <p>Description: 根据用户定义char型字符分割字符串，以char型字符为分割符</p>
 * <p>Copyright: Copyright (c) 2005</p>
 * <p>Company: hopen</p>
 * @author kuangyoubo
 * @version 1.0
 */
public class _StrSplit
{
    public static final int _OK_ = 0;
    public static final int _ER_ = -1;

    public _StrSplit()
    {
    }

    /**
     * 去掉字符串中的空白字符
     * @param _str
     * @return
     */
    public static String h_filter_colon( String _str )
    {
        String str = "";
        if( null == _str ) return "";

        str = _str.replaceAll( "\n", "" );
        str = str.replaceAll( "\t", "" );
        str = str.replaceAll( "\0", "" );
        str = str.replaceAll(" ", "" );

        return str;
    }

    /**
     * 检查字符串中的小括号的合法性
     * @param _char_str
     * @return
     */
    public static int h_chk_bracket( String _char_str )
    {
        String pc_str,pc_tmp,pc_param;
        String str1,str2,pc_outstr;
        char c_bracket;
        int pi_lcnt=0,pi_rcnt=0;

        for( int i=0, n=_char_str.length(); i<n ; i++ )
        {
	  c_bracket = _char_str.charAt(i);
	  switch( c_bracket )
	  {
	      case '(':
		pi_lcnt++;
		break;
	      case ')':
		pi_rcnt++;
		break;
	      default:
	  }
	  if( pi_rcnt > pi_lcnt )
	  {
	      System.out.println( _char_str + " 表达式中')'出现在'('之前" );
	      return _ER_;
	  }
	  else if( (pi_lcnt-pi_rcnt)>1 )
	  {
	      System.out.println( _char_str + " 表达式中出现的'('不能嵌套多层" );
	      return _ER_;
	  }
        }
        if( pi_lcnt!=pi_rcnt )
        {
	  System.out.println( _char_str + " 表达式中的小括号不匹配" );
	  return _ER_;
        }

        return _OK_;
    }
    /**
     * 根据字符 regex 分割字符串，返回的字符串数组中不包括 regex 分割符
     * @param str 源字符串
     * @param regex 分割符
     * @return 拆分后的String数组
     */
    public static String[] _CharSplit( String str, char regex )
    {
        if( null == str ) return new String[0];
        String str_array[] = null;
        char ch[] = str.toCharArray();
        char ch_tmp[] = null;
        int int_flag = getCharNum( ch, regex );
        /**
        for( int i=0; i<ch.length; i++ )
        {
            if( ch[i] == regex )
            {
                int_flag++;
            }
        } ***/

        if( int_flag < 1 ){
            str_array = new String[1];
            str_array[0] = str;
            return str_array;
        }
        ch_tmp = new char[str.length()];
        str_array = new String[int_flag+1];
        int k = 0;
        int h = 0;

        for( int n=0; n<ch.length; n++ )
        {
            if( ch[n] != regex )
            {
                ch_tmp[k] = ch[n];
                k++;
            }
            else
            {
                str_array[h] = new String( ch_tmp ).substring(0,k);
                ch_tmp = new char[str.length()];
                k = 0;
                h++;
            }
        }
        str_array[h] = new String( ch_tmp ).substring(0,k);
        return str_array;
    }
    /**
     * 取得字符串_str中出现了多少次字符ch.
     * @param _str  需要检查的字符串
     * @param ch 需要检查的字符
     * @return 出现次数
     */
    public static int getCharNum( String _str, char ch )
    {
        if( null == _str ) return 0;
        int i_flag = 0;
        char _ch[] = _str.toCharArray();

        for( int i=0; i<_ch.length; i++ )
        {
            if( ch == _ch[i] )
            {
                i_flag++;
            }
        }
        return i_flag;
    }
    /**
     * 取得字符数组_str中出现了多少次字符ch.
     * @param _str  需要检查的字符数组
     * @param ch 需要检查的字符
     * @return 出现次数
     */
    public static int getCharNum( char _str[], char ch )
    {
        if( null == _str ) return 0;
        int i_flag = 0;

        for( int i=0; i<_str.length; i++ )
        {
            if( ch == _str[i] )
            {
                i_flag++;
            }
        }
        return i_flag;
    }

    /**
     * 解析表达式中的小括号
     * @param _str
     * @return  解析后的表达式
     * @return  出错返回 null
     */
    public static String h_parse_bracket( String _str )
    {
        String pc_str,pc_tmp,pc_param;
        String str1,str2,pc_outstr;
        int pi_negflag = 0;

        str1 = h_filter_colon( _str );

        if( h_chk_bracket(str1) == _ER_ )
	  return null;

        for( int i=0, n=str1.length(); i<n; i++ )
        {

        }
        return null;
    }

    /**
     * 根据分割符先后取字符串
     * @param str
     * @return
     */
    public static String _substr( String str, String b_s, String e_s )
    {
        int i,k;
        i = str.indexOf( b_s );
        k = str.indexOf( e_s );
        if( k < i && k>=0 )
        {
	  str = str.substring( k+1 );
	  str = _substr( str, b_s, e_s );
        }
        else if( i>k )
	  str = str.substring( i );
        else if( k > 0 && i>=0 && i < k)
	  str = str.substring( i, k );
        else if( i > 0 && k < 0 )
	  str = str.substring( i );
        else if( k>0 && i<0 )
	  str = str.substring( 0, k );
        else if( k<=0 )
	  str = str.substring( 1 );


        return str;
    }

    public static void main( String s[] )
    {
        if( false )
        System.out.println( _StrSplit.h_chk_bracket("kdk(rfg))djkdkf "));
        String str= "Ijk";
        System.out.println( _substr(str,"I","-") );

    }
}