资讯专栏INFORMATION COLUMN

关于String内的indexOf方法的一些疑问

sunnyxd / 3042人阅读

摘要:今天浏览了一下里的类,发现一个静态方法有点意思,就是我们常用的的底层实现,先看下代码调用链。所以字符串的长度是可以不用匹配的,故是没问题的。关键的地方是这里加上了,是字符串的起始匹配偏移量,即从的哪个字符开始匹配。

今天浏览了一下java里的String类,发现一个静态方法有点意思,就是我们常用的indexOf(String str)的底层实现,先看下代码调用链。

public int indexOf(String str) {
    return indexOf(str, 0);
}
    
public int indexOf(String str, int fromIndex) {
    return indexOf(value, 0, value.length,
            str.value, 0, str.value.length, fromIndex);
}

static int indexOf(char[] source, int sourceOffset, int sourceCount,
        String target, int fromIndex) {
    return indexOf(source, sourceOffset, sourceCount,
                   target.value, 0, target.value.length,
                   fromIndex);
}

/**
 * Code shared by String and StringBuffer to do searches. The
 * source is the character array being searched, and the target
 * is the string being searched for.
 *
 * @param   source       the characters being searched.
 * @param   sourceOffset offset of the source string.
 * @param   sourceCount  count of the source string.
 * @param   target       the characters being searched for.
 * @param   targetOffset offset of the target string.
 * @param   targetCount  count of the target string.
 * @param   fromIndex    the index to begin searching from.
 */
static int indexOf(char[] source, int sourceOffset, int sourceCount,
        char[] target, int targetOffset, int targetCount,
        int fromIndex) {
    if (fromIndex >= sourceCount) {
        return (targetCount == 0 ? sourceCount : -1);
    }
    if (fromIndex < 0) {
        fromIndex = 0;
    }
    if (targetCount == 0) {
        return fromIndex;
    }

    char first = target[targetOffset];
    int max = sourceOffset + (sourceCount - targetCount);

    for (int i = sourceOffset + fromIndex; i <= max; i++) {
        /* Look for first character. */
        if (source[i] != first) {
            while (++i <= max && source[i] != first);
        }

        /* Found first character, now look at the rest of v2 */
        if (i <= max) {
            int j = i + 1;
            int end = j + targetCount - 1;
            for (int k = targetOffset + 1; j < end && source[j]
                    == target[k]; j++, k++);

            if (j == end) {
                /* Found whole string. */
                return i - sourceOffset;
            }
        }
    }
    return -1;
}

底层的字符串匹配的逻辑比较简单,就是普通的匹配模式:

查找首字符,匹配target的第一个字符在source内的位置,若查找到max位置还找到,则返回-1;

若在source匹配到了target的第一个字符,那么在依次比较srouce和target后面的字符,一直到target的末尾;

如果target后面的字符与source都已经匹配,则返回在source上匹配到的第一个字符的相对下标,否则返回-1。

但是仔细读代码会发现一个问题,就是这里

int max = sourceOffset + (sourceCount - targetCount);

max的计算方式,max的作用是计算出最大的首字符匹配次数,取值范围应该是"max <= sourceCount"。
所以target字符串的长度是可以不用匹配的,故“sourceCount - targetCount”是没问题的。
关键的地方是这里加上了sourceOffset,sourceOffset是source字符串的起始匹配偏移量,即从source的哪个字符开始匹配。
所以,根据代码里的max计算方式,最终计算出来的max值是会有可能大于sourceCount。
看下测试代码:

package string;

/**
 * string test
 */
public class StringTest {

    static int indexOf(char[] source, int sourceOffset, int sourceCount,
                       char[] target, int targetOffset, int targetCount,
                       int fromIndex) {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        if (targetCount == 0) {
            return fromIndex;
        }

        char first = target[targetOffset];
        int max = sourceOffset + (sourceCount - targetCount);

        for (int i = sourceOffset + fromIndex; i <= max; i++) {
            /* Look for first character. */
            if (source[i] != first) {
                while (++i <= max && source[i] != first);
            }

            /* Found first character, now look at the rest of v2 */
            if (i <= max) {
                int j = i + 1;
                int end = j + targetCount - 1;
                for (int k = targetOffset + 1; j < end && source[j]
                        == target[k]; j++, k++);

                if (j == end) {
                    /* Found whole string. */
                    return i - sourceOffset;
                }
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        String source = "abcdefghigklmn";
        String target = "n";
        int sourceOffset = 5;
        int targetOffset = 0;

        int index = indexOf(source.toCharArray(), sourceOffset, source.length(), target.toCharArray(), targetOffset, target.length(), 0);
        System.out.println(index);
    }
}

如果target在source内可以匹配到返回正确结果8(结果8是相对于sourceOffset的结果,如果转换成source内的位置则是13)。
但是如果target在source内匹配不到,则会抛出java.lang.ArrayIndexOutOfBoundsException异常,如下:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 14
    at string.StringTest.indexOf(StringTest.java:27)
    at string.StringTest.main(StringTest.java:52)

可见报出越界的下标是14,这就是由于max = sourceOffset + (sourceCount - targetCount)引起,计算出的max值为:17。

所以,个人认为max计算这里是个潜在的BUG,应该改为 int max = sourceCount - targetCount;

不过这个方法是一个非public方法,只在String内部调用,同时也跟踪了所有对该方法的调用链,都是传入的默认0,在使用时不会出现数组越界问题。
不知这是开发者故意为之,还是其它我未知用意,欢迎大家交流讨论!!!

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/72701.html

相关文章

  • javascript 数组去重6种思路

    摘要:但是这并不妨碍我们从思维拓展的角度出发,看看去重可以用几种思路去实现。首先是常规的双层循环比对的思路实现定义一个变量表示当前元素在中是否存在。依次对中的元素和原数组元素进行比对。重点是保证碰撞的几率小到比中大奖还小就可以了。 前端在日常开发中或多或少都会碰到有对数据去重的需求,实际上,像是lodash这些工具库已经有成熟完备的实现,并且可以成熟地运用于生产环境。但是这并不妨碍我们从思维...

    AlphaWallet 评论0 收藏0
  • 也谈JavaScript数组去重

    摘要:昨天在微博上看到一篇文章,也写数组去重,主要推崇的方法是将利用数组元素当作对象来去重。我在微博转发了用对象去重不是个好办法然后作者问什么才是推荐的方法。实例对象实例对象主要指通过构造函数类生成的对象。 本文同时发布于个人博客https://www.toobug.net/articl... JavaScript的数组去重是一个老生常谈的话题了。随便搜一搜就能找到非常多不同版本的解法。 昨...

    崔晓明 评论0 收藏0
  • Javascripts数组原生方法集合

    摘要:如果数组已经为空,则不改变数组,并返回值。中所有在数组被修改时都遵从这个原则,以下不再重复方法会给原数组中的每个元素都按顺序调用一次函数。每次执行后的返回值没有指定返回值则返回组合起来 数组应该是我们在写程序中应用到最多的数据结构了,相比于无序的对象,有序的数组帮我们在处理数据时,实在是帮了太多的忙了。今天刚好看到一篇Array.include的文章,忽然发现经过几个ES3,ES5,E...

    awokezhou 评论0 收藏0
  • JS数组中indexOf方法

    摘要:数组方法大家再熟悉不过了,却忽略了数组有这个方法我个人感觉。输出因为是数组的第个元素,匹配到并返回下标。数组同样有方法,只不过做类型判断时,使用的严格相等,也就是。 本人微信公众号:前端修炼之路,欢迎关注 前言 这两天在家中帮朋友做项目,项目中使用了数组的indexOf 方法,找到了一篇文章,感觉非常不错,顺便整理下以防链接丢失。 相信说到 indexOf 大家并不陌生,判断字符串是否...

    rickchen 评论0 收藏0
  • 字符串四则运算表达式

    摘要:支持括号小数负数也行运算数字运算符没有括号正常运算括号内的值都取完了,删除括号左右括号齐全先算括号内的一个包含数字的列表和一个包含运算符的列表形式可能会有空字符串符号列表同时出现从左至右运算同时出现从左 public static void main(String[] args) { // 支持括号 小数 负数 String statement ...

    chnmagnus 评论0 收藏0

发表评论

0条评论

sunnyxd

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<