28 . Implement strStr()

Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

Example 1:

Input: haystack = "hello", needle = "ll"
Output: 2

Example 2:

Input: haystack = "aaaaa", needle = "bba"
Output: -1

第一眼看到这个题就联想到了KMP算法。结果提交上去特慢，看到评论区有人用substring()来写速度很快，

于是乎就想看看这个方法的底层是如何实现的。

此题较快的AC代码:

class Solution {
    public int strStr(String haystack, String needle) {
        if(needle.length() == 0) return 0;
        if(haystack.length() == 0) return -1;
        if(haystack.length() == 1 && needle.length() == 1){
            if(haystack.charAt(0) == needle.charAt(0)){
                return 0;
            }
        }
        int len=needle.length();
        for(int i=0;i<haystack.length()-len+1;i++){
            if(haystack.substring(i,i+len).equals(needle))
                return i;
        }
        return -1;
    }
}

看了一下Java8的底层实现代码：

	/**
	*  截取当前字符串对象的片段，组成一个新的字符串对象
	*  beginIndex为截取的初始位置，默认截到len - 1位置
	*/
	public String substring(int beginIndex) {
        if (beginIndex < 0) {   //小于0抛异常
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;  //新字符串的长度
        if (subLen < 0) {       //小于0抛异常
            throw new StringIndexOutOfBoundsException(subLen);
        }
        //如果beginIndex是0，则不用截取，返回自己(非新对象)，否则截取0到subLen位置，不包括(subLen)
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }

	/**
	* 截取一个区间范围
	* [beginIndex,endIndex)，不包括endIndex
	*/
    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);
    }


    public CharSequence subSequence(int beginIndex, int endIndex) {
        return this.substring(beginIndex, endIndex);
    }

以及调用的string类的一个构造函数：

public String(char value[], int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count <= 0) {
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            if (offset <= value.length) {
                this.value = "".value;
                return;
            }
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
}

public static char[] copyOfRange(char[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        char[] copy = new char[newLength];   //是创建了一个新的char数组
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

 

相比于Java6版本的源码，Java6中是直接引用value数组的，this.value=value;

容易造成内存泄漏。详细理解。

而Java8中使用了数组拷贝。