深入理解Java常用类----String(二)

     上篇介绍了String类的构造器,获取内部属性等方法,最后留下了最常用的局部操作函数没有介绍,本篇将接着上篇内容,从这些最常见的函数的操作说起,看看我们日常经常使用的这些方法的内部是怎么实现的。第一个函数:

    public boolean startsWith(String prefix, int toffset) {
        char ta[] = value;
        int to = toffset;
        char pa[] = prefix.value;
        int po = 0;
        int pc = prefix.value.length;
        // Note: toffset might be near -1>>>1.
        if ((toffset < 0) || (toffset > value.length - pc)) {
            return false;
        }
        while (--pc >= 0) {
            if (ta[to++] != pa[po++]) {
                return false;
            }
        }
        return true;
    }

该方法用于判断是否当前的字符串对象是以指定的子串开头。prefix参数指定了这个字串,toffset参数指定了要从原字符串的哪里开始查找。先看个例子:

    public static void main(String[] args){
        String str = "hello-walker";
        System.out.println(str.startsWith("wa", 0));
        System.out.println(str.startsWith("wa",6));
    }

结果如下:

源代码相对而言也是比较容易理解的,首先是做了个简单的判断,如果toffset小于0或者toffset和prefix的长度超过了原字符串的长度,直接返回false。接着通过了一个while循环从原字符串的toffset位置和prefix的0位置开始,一个字符一个字符的比较,一旦发现有两者在某个位置的字符值是不等的,返回false,否则在循环结束时返回true。该方法还有一个重载,该重载默认toffset为0,即从原字符串的开头开始搜索。

endWith这个方法其实内部调用的还是上述介绍的startWith方法。

public boolean endsWith(String suffix) {
        return startsWith(suffix, value.length - suffix.value.length);
    }

我们看到该方法内部调用的startsWith方法,第二个参数传入的是value.length - suffix.value.length,该参数将会导致程序跳过前面一部分的字符,直接跳到还剩下suffix.value.length的字符的位置处。

下面我们看看hashCode在String类中的的实现:

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

虽然知道是这么实现的,但是我不知道为什么这么做。只知道它每次都乘31然后加上当前字符的Unicode编号。下面看一个重要的方法:

    public int indexOf(int ch, int fromIndex) {
        final int max = value.length;
        if (fromIndex < 0) {
            fromIndex = 0;
        } else if (fromIndex >= max) {
            return -1;
        }

        if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
            final char[] value = this.value;
            for (int i = fromIndex; i < max; i++) {
                if (value[i] == ch) {
                    return i;
                }
            }
            return -1;
        } else {
            return indexOfSupplementary(ch, fromIndex);
        }
    }

indexOf方法用于返回某个字符首次出现的位置,当然对应的还有lastIndexOf,我们一点点看。上述的方法,两个参数,第一个参数的值表示需要查找的指定字符(我们知道字符和int型是可以无条件互转的,所以这里用int接收),后面的代码主要分为两部分,一部分是大部分情况,另一部分则是专门用于处理增补字集情况,该情况我们暂时不去研究。第一部分的代码就比较简单了,遍历整个字符串对象,如果找到指定字符,则返回当前位置,否则返回-1。当然该方法也有一些重载,但本质都是调用了上述介绍的方法。

lastIndexOf方法类似,只不过他是从后往前查找,此处不再赘述。

下面看一个截取子串的方法:

public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }

该方法的前面两个判断主要用于处理一些极端情况,最后一条语句是该方法的核心。如果beginIndex 为0表示截取整个字符串则直接返回当前字符串对象,否则重新构造一个字符串对象。当然该方法自然是有重载的,

    public String substring(int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > value.length) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
    }

从该重载的两个参数可以看出来,之前只提供一个beginIndex则默认从开始索引处全部截取余下字符。而此处指定endIndex则选择性的截取从beginIndex到endIndex之间的子串作为结果返回。具体的实现也是类似,只是多了一些判断。

下面介绍的方法可以连接两个不同的字符串。

    public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }

该方法具有一个参数,该参数的值是一个字符串对象,用于连接在当前字符串对象的后面。前三行很简单,就是判断连接字符串str是否为空,如果是则直接返回当前字符串对象,我们看到很多的方法源码都是会把核心方法放在最后面,前面是一堆判断,这也是一种效率的体现,就是说如果不满足调用该方法的条件则直接在前面被pass了,而不用调用复杂耗时的核心方法。Arrays.copyOf 方法用于创建一个能够容纳上述两个字符串的更大的数组,然后将原字符串复制到进去,后面留给str的位置为空。接着调用getChars方法从偏移量为len的索引位置开始将str中字符拷贝到buf中,最后构建字符串对象返回。

下面看一个更为实用的方法:

    public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */

            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

该方法用于替换字符串对象中指定的某个字符,当然它会替换掉所有的oldchar。该方法首先判断oldchar(需要被替换的字符)是否和newchar(替换它的字符)相等,如果相等则不用做任何操作,直接返回当前字符串对象,否则,通过while循环找到第一个oldchar,然后重新构建了一个char数组,该数组和value这个数组长度一样,接着将第一个oldchar位置之前的所有字符复制到新数组中,然后while循环一边遍历value数组查找oldchar并替换为newchar,一边将newchar添加到新数组中,最后返回新数组构造的String 对象。

上述的该方法只能替换指定的一个字符,但是不能替换某个子串。下面的几个方法都是用于替换某个子串。

@1替换第一个子串
public String replaceFirst(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
    }
@2替换每一个符合规则的子串
public String replaceAll(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(replacement);
    }
@3
public String replace(CharSequence target, CharSequence replacement) {
        return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
                this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
    }

上述的第一个方法是相对较为好理解,第二个和第三个方法都是替换所有指定的子串,他们的区别在于,replaceAll方法是基于正则表达式的,replace则只针对char串的替换。例如:

    public static void main(String[] args){
        String str = "aaabssddaa\\\\";
        System.out.println(str);
        System.out.println(str.replace("\\\\", "x"));
        System.out.println(str.replaceAll("\\\\", "x"));
    }

输出结果:

我们知道在Java中  表示转义字符,也就是上述的str中 \\ 将被转义成两个 \ ,而在正则表达式中该符号也是转义字符,所以我们 replaceAll 方法中的第一个参数的实际值为:,被转义了两次,所以针对str中的 \的替换,replaceAll 输出两个x,而在replace方法中,四个\被Java转义了一次为两个,所以replace输出一个x。它两区别就是一个是基于正则表达式的,一个则只针对char子串。

下面看一个分割字符串的函数split,由于代码比较多,此处就不贴出来了,我大致介绍下实现原理。该方法的参数依然是依赖正则表达式的,其内部定义了一个ArrayList,定义一个用于匹配字符串的Matcher对象,然后while循环去find原字符串对象,如果找到则直接subSequence前面的所有字符集合,并添加到ArrayList中,然后起始位置从0跳到当前位置之后继续搜索,最后ArrayList对象的toArray方法,返回String类型数组。

下面看一个join方法:

    public static String join(CharSequence delimiter, CharSequence... elements) {
        Objects.requireNonNull(delimiter);
        Objects.requireNonNull(elements);
        // Number of elements not likely worth Arrays.stream overhead.
        StringJoiner joiner = new StringJoiner(delimiter);
        for (CharSequence cs: elements) {
            joiner.add(cs);
        }
        return joiner.toString();
    }

首先,该方法是静态方法。然后该方法中涉及到一个类StringJoiner ,它有一个构造方法:

    public StringJoiner(CharSequence delimiter,
                        CharSequence prefix,
                        CharSequence suffix) {
        Objects.requireNonNull(prefix, "The prefix must not be null");
        Objects.requireNonNull(delimiter, "The delimiter must not be null");
        Objects.requireNonNull(suffix, "The suffix must not be null");
        // make defensive copies of arguments
        this.prefix = prefix.toString();
        this.delimiter = delimiter.toString();
        this.suffix = suffix.toString();
        this.emptyValue = this.prefix + this.suffix;
    }

该构造函数为该类的一些字段赋值,至于这些字段时干什么的,等再次遇到的时候介绍,此处只需了解下他们的存在。此处调用该构造函数并传入delimiter分割符,然后调用了该类对象的add方法,

    public StringJoiner add(CharSequence newElement) {
        prepareBuilder().append(newElement);
        return this;
    }
    
    private StringBuilder prepareBuilder() {
        //此处value为一个StringBilder实例,是StringJoiner的一个成员
        if (value != null) {
            value.append(delimiter);
        } else {
            value = new StringBuilder().append(prefix);
        }
        return value;
    }

第一次add会走else部分,新建一个StringBuilder对象并添加prefix元素(此处在调用构造器的时候为其赋值为空)赋值给我们的成员变量,回到add方法添加该元素到StringBuilder中,第二次到prepareBuilder方法中只会向StringBuilder实例中添加delimiter分割符,然后出来add方法中又将第二个元素添加到其中。这样就完成了为这些元素连接一个分隔符,并放入到StringBuilder实例中,最后tostring返回。看个例子:

public static void main(String[] args){
        String[] strs = new String[]{"hello","walker","yam","cyy","huaaa"};
        System.out.println(String.join("-",strs));
    }
输出结果:hello-walker-yam-cyy-huaaa

最后还有两个方法,比较简单不再赘述其原理实现。

//返回内部的字符数组,之所以不直接返回value是为了封装的严密性
public char[] toCharArray() {
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
    }
//去除头尾部的空格
public String trim() {
        int len = value.length;
        int st = 0;
        char[] val = value;    /* avoid getfield opcode */

        while ((st < len) && (val[st] <= ' ')) {
            st++;
        }
        while ((st < len) && (val[len - 1] <= ' ')) {
            len--;
        }
        return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
    }

至此,有关String源码的阅读大致结束,并没有涉及全部代码,有些源码束作者能力问题,没能完全参透,总结的不好,见谅!

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏BY的专栏

Swift 4 新特性

2749
来自专栏大数据钻研

JavaScript arguments 对象详解

1. 什么是 arguments MDN 上解释: arguments 是一个类数组对象。代表传给一个function的参数列表。 我们先用一个例子直观了解下 ...

41410
来自专栏Java 源码分析

静态内部类

定义:静态内部类,定义在类中,任何方法外,用static定义;静态内部类只能访问外部类的静态成员。 注意点: 一般情况下,如果一个内部类不是被定义成静态内部类,...

2988
来自专栏个人随笔

房上的猫:数组

一.数组:  1.定义:   (1)数组就是一个变量,用于将相同数据类型的数据储存在内存中   (2)数组中的每一个数据元素都属于统一数据类型  2.基本要素:...

3449
来自专栏一名合格java开发的自我修养

python类与对象基本语法

对象是面向对象编程的核心,在使用对象的过程中,为了将具有共同特征和行为的一组对象抽象定义,提出了另外一个新的概念——类。

753
来自专栏丑胖侠

《Drools7.0.0.Final规则引擎教程》第4章 4.4 LHS简介&Pattern

LHS简介 在规则文件组成章节,我们已经了解了LHS的基本使用说明。LHS是规则条件部分的统称,由0个或多个条件元素组成。前面我们已经提到,如果没有条件元素那么...

1947
来自专栏青枫的专栏

思想:java中,父类的方法中传入的形参的数据类型是泛型,子类的方法的形参想只要一种确定的数据类型,子类该如何做呢?

652
来自专栏C/C++基础

C++不要在构造函数和析构函数中调用虚函数

虽然可以对虚函数进行实调用,但程序员编写虚函数的本意应该是实现动态联编。在构造函数中调用虚函数,函数的入口地址是在编译时静态确定的,并未实现虚调用。但是为什么在...

862
来自专栏企鹅号快讯

bash shell 中如何区别$和${}和$和

$()和${}的用法: 在 bash shell 中,$( ) 与 ` ` (反引号) 都是用来做命令替换用(command substitution)的。而...

34116
来自专栏Hellovass 的博客

使用递归逆序一个栈

822

扫码关注云+社区