`

net.sf.hibernate.util.StringHelper

阅读更多
源码解读心得 - net.sf.hibernate.util.StringHelper
给这个类做了一下注释,不是很详细,而且还有一些地方不是很清楚。

//$Id: StringHelper.java,v 1.16.2.11 2004/01/10 03:14:04 oneovthafew Exp $
package net.sf.hibernate.util;

import java.util.Iterator;
import java.util.StringTokenizer;

public final class StringHelper {

    /**//**
     * 下面定义了一些常用的字符串常量
     */
    public static final String EMPTY_STRING="";                            // 空字符串
    public static final char DOT='.';                                    // 点
    public static final char UNDERSCORE='_';                            // 下划线
    public static final String COMMA_SPACE=", ";                        // 逗号+空格
    public static final String COMMA = ",";                                // 逗号
    public static final String OPEN_PAREN = "(";                        // 左括号
    public static final String CLOSE_PAREN = ")";                        // 右括号
    public static final char SINGLE_QUOTE = '\'';                        // 单引号




    /**//**
     * 连接多个字符串
     */
    public static String join(String seperator, String[] strings) {

        int length = strings.length; // 取需要连接的字符串的数目
        if (length==0) return EMPTY_STRING;        //如果字符串个数为0,则返回空字符串

        StringBuffer buf = new StringBuffer( length * strings[0].length() ) // 创建字符串缓存,以便进行字符串的连接
        .append(strings[0]); //写入第一个字符串


        // 循环写入后面的字符串
        for (int i=1; i<length; i++) {
            buf.append(seperator).append(strings[i]);
        }


        // 返回结果
        return buf.toString();
    }






    public static String join(String seperator, Iterator objects) {

        StringBuffer buf = new StringBuffer(); // 创建字符串缓存

        if ( objects.hasNext() ) buf.append( objects.next() ); // 写入第一个对象

        // 循环写入后面的对象
        while ( objects.hasNext() ) {
            buf.append(seperator).append( objects.next() );
        }

        // 返回结果
        return buf.toString();
    }




    // 一一对应地连接两个字符串数组
    public static String[] add(String[] x, String sep, String[] y) {

        String[] result = new String[ x.length ]; // 新建用于返回的字符串数组

        // 对各个字符串对进行连接
        for ( int i=0; i<x.length; i++ ) {
            result[i] = x[i] + sep + y[i];
        }

        return result;
    }




    // 生成重复字符串
    public static String repeat(String string, int times) {
        StringBuffer buf = new StringBuffer( string.length() * times );
        for (int i=0; i<times; i++) buf.append(string);
        return buf.toString();
    }




    // 替换字符串
    public static String replace(String template, String placeholder, String replacement) {
        return replace(template, placeholder, replacement, false);
    }




    // 替换字符串
    public static String replace(String template, String placeholder, String replacement, boolean wholeWords) {

        // 取待替换的字符串的位置
        int loc = template.indexOf(placeholder);

        // 如果没有找到,则返回原串 (递归的终点)
        if (loc<0) {
            return template;
        }
        else {

            /**//** 此段代码有点难理解,重构如下:
            final boolean actuallyReplace;
            if ( wholeWords ) {

                if ( loc + placeholder.length() == template.length() ) {

                    actuallyReplace = false;
                }
                else {
                    if ( Character.isJavaIdentifierPart( template.charAt( loc + placeholder.length() ) {
                        actuallyReplace = false;
                    }
                    else actuallyReplace = true;
                }       
            }
            else actuallyReplace = false;
            */
            final boolean actuallyReplace = !wholeWords ||
                loc + placeholder.length() == template.length() || // 待替换字符串是否处于原字符串的末尾
                !Character.isJavaIdentifierPart( template.charAt( loc + placeholder.length() ) ); // 确保后面没有Java Identifier字符
            //
            String actualReplacement = actuallyReplace ? replacement : placeholder;
            return new StringBuffer( template.substring(0, loc) )    // 先写入没有变动的
                .append(actualReplacement)                            // 再写入被替换的部分
                .append( replace(            // 递归调用replace方法,替换后面全部的字符串
                    template.substring( loc + placeholder.length() ),
                    placeholder,
                    replacement,
                    wholeWords
                ) ).toString();
        }
    }




    // 仅替换一次
    public static String replaceOnce(String template, String placeholder, String replacement) {
        int loc = template.indexOf(placeholder);
        if ( loc<0 ) {
            return template;
        }
        else {
            return new StringBuffer( template.substring(0, loc) )
            .append(replacement)
            .append( template.substring( loc + placeholder.length() ) )
            .toString();
        }
    }


    // 将字符串按指定分隔符分开
    public static String[] split(String seperators, String list) {
        return split(seperators, list, false);
    }



    // 将字符串按指定分隔符分开
    public static String[] split(String seperators, String list, boolean include) {
        StringTokenizer tokens = new StringTokenizer(list, seperators, include);
        String[] result = new String[ tokens.countTokens() ];
        int i=0;
        while ( tokens.hasMoreTokens() ) {
            result[i++] = tokens.nextToken();
        }
        return result;
    }


    // 取文件名的后缀
    public static String unqualify(String qualifiedName) {
        return unqualify(qualifiedName, ".");
    }

    // 取符号 seperator 后面的字符串
    public static String unqualify(String qualifiedName, String seperator) {
        return qualifiedName.substring( qualifiedName.lastIndexOf(seperator) + 1 );
    }


    // 取不含后缀的文件名称
    public static String qualifier(String qualifiedName) {
        int loc = qualifiedName.lastIndexOf(".");
        if ( loc<0 ) {
            return EMPTY_STRING;
        }
        else {
            return qualifiedName.substring(0, loc);
        }
    }


    // 给字符串加后缀
    public static String[] suffix( String[] columns, String suffix) {
        if (suffix==null) return columns;
        String[] qualified = new String[columns.length];
        for ( int i=0; i<columns.length; i++ ) {
            qualified[i] = suffix( columns[i], suffix);
        }
        return qualified;
    }
   
    // 给字符串加后缀
    public static String suffix(String name, String suffix) {
        return (suffix==null) ? name : name + suffix;
    }


    // 给字符串加前缀
    public static String[] prefix( String[] columns, String prefix) {
        if (prefix==null) return columns;
        String[] qualified = new String[columns.length];
        for ( int i=0; i<columns.length; i++ ) {
            qualified[i] = prefix + columns[i];
        }
        return qualified;
    }

    // 返回字符串中.前面的部分
    public static String root(String qualifiedName) {
        int loc = qualifiedName.indexOf(".");
        return (loc<0) ? qualifiedName : qualifiedName.substring(0, loc);
    }


    // 把字符串转换成boolean型
    public static boolean booleanValue(String tfString) {
        String trimmed = tfString.trim().toLowerCase();
        return trimmed.equals("true") || trimmed.equals("t");
    }


    // 把数组转换成字符串
    public static String toString(Object[] array) {
        int len = array.length;
        if (len==0) return StringHelper.EMPTY_STRING;
        StringBuffer buf = new StringBuffer(len * 12);
        for ( int i=0; i<len-1; i++ ) {
            buf.append( array[i] ).append(StringHelper.COMMA_SPACE);
        }
        return buf.append( array[len-1] ).toString();
    }


    // 字符串替换的一个“笛卡儿积”(不明白有什么用)
    public static String[] multiply(String string, Iterator placeholders, Iterator replacements) {
        String[] result = new String[] { string };
        while ( placeholders.hasNext() ) {
            result = multiply( result, (String) placeholders.next(), (String[]) replacements.next() );
        }
        return result;
    }

    // 字符串替换的一个“积”,枚举所有可以替换的可能
    private static String[] multiply(String[] strings, String placeholder, String[] replacements) {
        String[] results = new String[ replacements.length * strings.length ];
        int n=0;
        for ( int i=0; i<replacements.length; i++ ) {
            for ( int j=0; j<strings.length; j++ ) {
                results[n++] = replaceOnce( strings[j], placeholder, replacements[i] );
            }
        }
        return results;
    }

    /**//*public static String unQuote(String name) {
        return ( Dialect.QUOTE.indexOf( name.charAt(0) ) > -1 ) ?
        name.substring(1, name.length()-1) :
        name;
    }

    public static void unQuoteInPlace(String[] names) {
        for ( int i=0; i<names.length; i++ ) names[i] = unQuote( names[i] );
    }

    public static String[] unQuote(String[] names) {
        String[] unquoted = new String[ names.length ];
        for ( int i=0; i<names.length; i++ ) unquoted[i] = unQuote( names[i] );
        return unquoted;
    }*/


    // 计算指定字符出现的次数
    public static int count(String string, char character) {
        int n=0;
        for ( int i=0; i<string.length(); i++ ) {
            if ( string.charAt(i)==character ) n++;
        }
        return n;
    }


    // 计算未被包含在单引号对中的指定字符的个数
    public static int countUnquoted(String string, char character) {
        if ( SINGLE_QUOTE == character ) {
            throw new IllegalArgumentException("Unquoted count of quotes is invalid");
        }
        // Impl note: takes advantage of the fact that an escpaed single quote
        // embedded within a quote-block can really be handled as two seperate
        // quote-blocks for the purposes of this method
        int count=0;
        int stringLength = string == null ? 0 : string.length();
        boolean inQuote = false;        // 是否被包含在单引号对之内
        for ( int indx=0; indx<stringLength; indx++ ) {
            if ( inQuote ) {
                // 不断循环,直到遇到第二个单引号inQuote才变为false
                if ( SINGLE_QUOTE == string.charAt(indx) ) {
                    inQuote = false;
                }
            }
            else if ( SINGLE_QUOTE == string.charAt(indx) ) {
                inQuote = true;
            }
            else if ( string.charAt(indx)==character ) {
                count++;
            }
        }
        return count;
    }


    // 判断字符串是否为空
    public static boolean isNotEmpty(String string) {
        return string!=null && string.length() > 0;
    }


    // 生成具有限定符“.”的字符串
    public static String qualify(String prefix, String name) {
        return new StringBuffer( prefix.length() + name.length() + 1 )
            .append(prefix)
            .append(DOT)
            .append(name)
            .toString();
    }



    // 生成具有限定符“.”的字符串
    public static String[] qualify(String prefix, String[] names) {
        if (prefix==null) return names;
        int len = names.length;
        String[] qualified = new String[len];
        for ( int i=0; i<len; i++) {
            qualified[i] = qualify( prefix, names[i] );
        }
        return qualified;
    }

    private StringHelper() { /**//* static methods only - hide constructor */ }


    // 对求字符索引的一个扩展。求字符串string中包含的字符在sqlString中存在的最小位置
    public static int firstIndexOfChar(String sqlString, String string, int startindex) {
        int matchAt=-1;        //此处 -1 可以理解为无穷大
        for (int i = 0; i < string.length(); i++) {
            int curMatch  = sqlString.indexOf( string.charAt(i), startindex );
            if (curMatch >=0) {
                if (matchAt==-1) { // first time we find match!
                    matchAt = curMatch;
                }
                else {
                    matchAt = Math.min(matchAt, curMatch);
                }
            }
        }
        return matchAt;
    }
   

    // 取字符串的前面指定长度的字符串
    public static String truncate(String string, int length) {
        if (string.length()<=length) {
            return string;
        }
        else {
            return string.substring(0, length);
        }
    }

}







分享到:
评论
1 楼 浴盆儿 2008-07-12  
thanks,i have take some usage code

相关推荐

    Could not initialize class net.sf.jasperreports.engine.util.JRStyledTextParser

    标题 "Could not initialize class net.sf.jasperreports.engine.util.JRStyledTextParser" 提示了一个Java运行时错误,这通常意味着在尝试加载或初始化`JRStyledTextParser`类时遇到了问题。`JRStyledTextParser`是...

    net.sf.json.JSONObject依赖jar

    import java.util.HashMap; public class JsonDemo { public static void main(String[] args) { // 创建一个Java对象 HashMap, String&gt; map = new HashMap(); map.put("name", "John"); map.put("age", "30")...

    Java中使用Json的net.sf.json包

    为了在Java中处理JSON数据,开发者通常会使用特定的库,如`net.sf.json`包,这是一个非常实用的JSON库,提供了丰富的功能来创建、解析和操作JSON对象。 `net.sf.json`库主要包含了两个核心类:`JSONObject`和`...

    net.sf.json需要的jar

    6. **commons-logging-1.1.1.jar**:Apache Commons Logging是一个日志抽象层,允许开发者在不修改代码的情况下切换不同的日志实现,如log4j、java.util.logging等。 这些JAR文件组合在一起,构成了一个完整的环境...

    net.sf.json.JSONObject 依赖的包

    import java.util.HashMap; HashMap, String&gt; map = new HashMap(); map.put("name", "John"); map.put("age", "30"); JSONObject jsonObject = JSONObject.fromObject(map); String jsonString = jsonObject....

    net.sf.json

    - 转换策略:`net.sf.json.util.JSONConfig`允许你配置转换规则,比如日期格式、循环引用的处理等。 总的来说,`net.sf.json`库是Java开发中处理JSON的强大工具,它简化了JSON数据在Java对象间的转换,同时也提供了...

    jodconverter-3.0-beta-2.jar

    META-INF/MANIFEST.MF META-INF/maven/net.sf.jodconverter/jodconverter/pom.properties META-INF/maven/net.sf.jodconverter/jodconverter/pom.xml ...net.sf.jodconverter.util.TemporaryException.class

    net.sf.json jar包

    import net.sf.json.util.JSONTokener; String jsonString = "{\"name\":\"John\", \"age\":30}"; JSONObject jsonObject = (JSONObject) new JSONTokener(jsonString).nextValue(); Person person = jsonObject....

    json lib net.sf.json使用的所有jar包

    6. **commons-logging-1.1.jar**:Apache Commons Logging是一个日志抽象层,允许开发者选择不同的日志实现,如log4j、java.util.logging等。在处理JSON时,可能会用到日志来记录错误信息或调试信息。 使用`...

    net.mindview.util包

    5. **使用JAR文件**:要在项目中使用`net.mindview.util.jar`,你需要确保它在项目的类路径(ClassPath)中。在IDE如Eclipse或IntelliJ IDEA中,可以通过设置项目配置来添加外部JAR。在命令行环境中,可以在运行Java...

    借助Ehcache缓存框架实现对页面的缓存Demo

    at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$101(ScheduledThreadPoolExecutor.java:98) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask....

    net.mindview.util包(Thinking in Java 4#)

    net.mindview.util包(Thinking in Java 4#)

    net.mindview.util.jar

    标题“net.mindview.util.jar”暗示我们正在讨论一个Java编程相关的JAR文件,它包含了net.mindview.util包下的类和资源。这个JAR文件可能是《Thinking in Java》这本经典书籍中引用的代码库的一部分,作者是Bruce ...

    android.util.Base64类

    android.util.Base64类

    org.jasig.cas.client.util.CommonUtils

    予org.jasig.cas.client.util.CommonUtils 加入 public static void disableSSLVerification(){ try { // Create a trust manager that does not validate certificate chains TrustManager[] ...

    org.apache.commons.net.util.jar

    org.apache.commons.net.util.jar

    java编程思想中的源码与net.mindview.util.Print.*jar包

    Java编程思想中的各个章节的源码,以及所要的net.mindview.util.Print.*的jar包。

    用java.util.zip包现数据压缩与解压

    ### 使用 Java.util.zip 包实现数据压缩与解压 在计算机科学领域,数据压缩技术是一项重要的功能,它能够帮助减少存储空间的需求以及提高网络传输效率。本文将通过一系列的示例来详细介绍如何利用 Java 中的 `java....

Global site tag (gtag.js) - Google Analytics