TomyZhang
TomyZhang

JDK源码 -- String

一、概念

类定义：

public final class String
    implements java.io.Serializable, Comparable, CharSequence
  • 实现了Serializable接口，可进行序列化。
  • 实现了Comparable接口，可进行比较。
  • 实现了CharSequence接口，说明是个字符序列。

特点：

  • 不可继承。
  • 不可变。
  • 线程安全。

二、使用

//TestString
public class TestString {
    private static final String TAG = "TestString";
    private String str = "tomorrow";

    public void testEquals() {
        Log.d(TAG, "zwm, tomorrow equals tommy: " + str.equals("tommy"));
        Log.d(TAG, "zwm, tomorrow equals tomorrow: " + str.equals("tomorrow"));
    }

    public void testEqualsIgnoreCase() {
        Log.d(TAG, "zwm, tomorrow equalsIgnoreCase TOMORROW: " + str.equalsIgnoreCase("TOMORROW"));
    }

    public void testSubSequence() {
        CharSequence charSequence = str.subSequence(2, 6);
        Log.d(TAG, "zwm, subSequence index 2 - 6: " + charSequence.toString());
    }

    public void testHashCode() {
        Log.d(TAG, "zwm, hashCode: " + str.hashCode());
    }

    public void testStartsWith() {
        Log.d(TAG, "zwm, startsWith tom: " + str.startsWith("tom"));
    }

    public void testStartsWith2() {
        Log.d(TAG, "zwm, startsWith morr index 2: " + str.startsWith("morr", 2));
    }

    public void testEndsWith() {
        Log.d(TAG, "zwm, endsWith rrow: " + str.endsWith("rrow"));
    }

    public void testContains() {
        Log.d(TAG, "zwm, contains morr: " + str.contains("morr"));
    }

    public void testCharAt() {
        Log.d(TAG, "zwm, charAt index 2: " + str.charAt(2));
    }

    public void testCodePointAt() {
        Log.d(TAG, "zwm, codePointAt index 2: " +  str.codePointAt(2));
    }

    public void testCodePointBefore() {
        Log.d(TAG, "zwm, codePointBefore index 2: " +  str.codePointBefore(2));
    }

    public void testCodePointCount() {
        Log.d(TAG, "zwm, codePointCount index 0 - 2: " +  str.codePointCount(0, 2));
    }

    public void testOffsetByCodePoints() {
        Log.d(TAG, "zwm, offsetByCodePoints index 2, offset 1: " +   str.offsetByCodePoints(2, 1));
    }

    public void testCompareTo() {
        Log.d(TAG, "zwm, tomorrow compareTo TOMORROW: " + str.compareTo("TOMORROW"));
    }

    public void testCompareToIgnoreCase() {
        Log.d(TAG, "zwm, tomorrow compareToIgnoreCase TOMORROW: " + str.compareToIgnoreCase("TOMORROW"));
    }

    public void testConcat() {
        Log.d(TAG, "zwm, tomorrow concat XYZ, result: " + str.concat("XYZ"));
        Log.d(TAG, "zwm, tomorrow concat XYZ, str: " + str);
    }

    public void testContentEquals() {
        CharSequence charSequence = "tomorrow";
        Log.d(TAG, "zwm, contentEquals CharSequence: " + str.contentEquals(charSequence));
    }

    public void testContentEquals2() {
        StringBuffer stringBuffer = new StringBuffer("tomorrow");
        Log.d(TAG, "zwm, contentEquals StringBuffer: " + str.contentEquals(stringBuffer));
    }

    public void testGetBytes() {
        Log.d(TAG, "zwm, getBytes size: " + str.getBytes().length);
    }

    public void testGetChars() {
        char[] dest = new char[10];
        str.getChars(2, 6, dest, 0);
        for(int i=0; i<4; i++) {
            Log.d(TAG, "zwm, getChars, ch: " + dest[i]);
        }
    }

    public void testLength() {
        Log.d(TAG, "zwm, length: " + str.length());
    }

    public void testIsEmpty() {
        Log.d(TAG, "zwm, isEmpty: " + str.isEmpty());
    }

    public void testIndexOf() {
        Log.d(TAG, "zwm, indexOf o: " +  str.indexOf('o'));
    }

    public void testLastIndexOf() {
        Log.d(TAG, "zwm, lastIndexOf o: " +  str.lastIndexOf('o'));
    }

    public void testIntern() {
        Log.d(TAG, "zwm, intern: " +  str.intern());
    }

    public void testMatches() {
        boolean result = str.matches(".+omo.+");
        Log.d(TAG, "zwm, match result: " + result);
    }

    public void testRegionMatches() {
        Log.d(TAG, "zwm, tomorrow regionMatches xxtomoxx: " + str.regionMatches(2, "xxtomoxx", 4, 2));
    }

    public void testReplace() {
        String result = str.replace('o', 'p');
        Log.d(TAG, "zwm, tomorrow p replace o, result: " + result);
        Log.d(TAG, "zwm, tomorrow p replace o, str: " + str);
    }

    public void testSplit() {
        String[] result = str.split("o");
        for(String str : result) {
            Log.d(TAG, "zwm, split item: " + str);
        }
        Log.d(TAG, "zwm, split str: " + str);
    }

    public void testSubstring() {
        String result = str.substring(2, 6);
        Log.d(TAG, "zwm, tomorrow substring index 2 - 6, result: " + result);
        Log.d(TAG, "zwm, tomorrow substring index 2 - 6, str: " + str);
    }

    public void testToLowerCase() {
        String result = str.toLowerCase();
        Log.d(TAG, "zwm, toLowerCase, result: " + result);
        Log.d(TAG, "zwm, toLowerCase, str: " + str);
    }

    public void testToUpperCase() {
        String result = str.toUpperCase();
        Log.d(TAG, "zwm, toUpperCase, result: " + result);
        Log.d(TAG, "zwm, toUpperCase, str: " + str);
    }

    public void testToCharArray() {
        char[] result = str.toCharArray();
        for(char ch : result) {
            Log.d(TAG, "zwm, toCharArray ch: " + ch);
        }
    }

    public void testTrim() {
        String test = "  , " + str + " ,  ";
        Log.d(TAG, "zwm, test: " + test  + ", length: " + test.length());
        String result = test.trim();
        Log.d(TAG, "zwm, result: " + result  + ", length: " + result.length());
        Log.d(TAG, "zwm, test: " + test  + ", length: " + test.length());
    }
}

//测试代码
private void testMethod() {
    Log.d(TAG, "zwm, testMethod");
    TestString testString = new TestString();
    testString.testEquals();
    testString.testEqualsIgnoreCase();
    testString.testSubSequence();
    testString.testHashCode();
    testString.testStartsWith();
    testString.testStartsWith2();
    testString.testEndsWith();
    testString.testContains();
    testString.testCharAt();
    testString.testCodePointAt();
    testString.testCodePointBefore();
    testString.testCodePointCount();
    testString.testOffsetByCodePoints();
    testString.testCompareTo();
    testString.testCompareToIgnoreCase();
    testString.testConcat();
    testString.testContentEquals();
    testString.testContentEquals2();
    testString.testGetBytes();
    testString.testGetChars();
    testString.testLength();
    testString.testIsEmpty();
    testString.testIndexOf();
    testString.testLastIndexOf();
    testString.testIntern();
    testString.testMatches();
    testString.testRegionMatches();
    testString.testReplace();
    testString.testSplit();
    testString.testSubstring();
    testString.testToLowerCase();
    testString.testToUpperCase();
    testString.testToCharArray();
    testString.testTrim();
}

//输出log
2019-08-18 17:23:01.983 zwm, testMethod
2019-08-18 17:23:01.985 zwm, tomorrow equals tommy: false
2019-08-18 17:23:01.985 zwm, tomorrow equals tomorrow: true
2019-08-18 17:23:01.986 zwm, tomorrow equalsIgnoreCase TOMORROW: true
2019-08-18 17:23:01.986 zwm, subSequence index 2 - 6: morr
2019-08-18 17:23:01.986 zwm, hashCode: -1037172987
2019-08-18 17:23:01.987 zwm, startsWith tom: true
2019-08-18 17:23:01.987 zwm, startsWith morr index 2: true
2019-08-18 17:23:01.987 zwm, endsWith rrow: true
2019-08-18 17:23:01.987 zwm, contains morr: true
2019-08-18 17:23:01.987 zwm, charAt index 2: m
2019-08-18 17:23:01.987 zwm, codePointAt index 2: 109
2019-08-18 17:23:01.987 zwm, codePointBefore index 2: 111
2019-08-18 17:23:01.987 zwm, codePointCount index 0 - 2: 2
2019-08-18 17:23:01.988 zwm, offsetByCodePoints index 2, offset 1: 3
2019-08-18 17:23:01.988 zwm, tomorrow compareTo TOMORROW: 32
2019-08-18 17:23:01.988 zwm, tomorrow compareToIgnoreCase TOMORROW: 0
2019-08-18 17:23:01.988 zwm, tomorrow concat XYZ, result: tomorrowXYZ
2019-08-18 17:23:01.988 zwm, tomorrow concat XYZ, str: tomorrow
2019-08-18 17:23:01.988 zwm, contentEquals CharSequence: true
2019-08-18 17:23:01.988 zwm, contentEquals StringBuffer: true
2019-08-18 17:23:01.989 zwm, getBytes size: 8
2019-08-18 17:23:01.989 zwm, getChars, ch: m
2019-08-18 17:23:01.989 zwm, getChars, ch: o
2019-08-18 17:23:01.989 zwm, getChars, ch: r
2019-08-18 17:23:01.989 zwm, getChars, ch: r
2019-08-18 17:23:01.989 zwm, length: 8
2019-08-18 17:23:01.989 zwm, isEmpty: false
2019-08-18 17:23:01.989 zwm, indexOf o: 1
2019-08-18 17:23:01.989 zwm, lastIndexOf o: 6
2019-08-18 17:23:01.990 zwm, intern: tomorrow
2019-08-18 17:23:01.990 zwm, match result: true
2019-08-18 17:23:01.990 zwm, tomorrow regionMatches xxtomoxx: true
2019-08-18 17:23:01.990 zwm, tomorrow p replace o, result: tpmprrpw
2019-08-18 17:23:01.990 zwm, tomorrow p replace o, str: tomorrow
2019-08-18 17:23:01.991 zwm, split item: t
2019-08-18 17:23:01.991 zwm, split item: m
2019-08-18 17:23:01.991 zwm, split item: rr
2019-08-18 17:23:01.991 zwm, split item: w
2019-08-18 17:23:01.991 zwm, split str: tomorrow
2019-08-18 17:23:01.991 zwm, tomorrow substring index 2 - 6, result: morr
2019-08-18 17:23:01.991 zwm, tomorrow substring index 2 - 6, str: tomorrow
2019-08-18 17:23:01.991 zwm, toLowerCase, result: tomorrow
2019-08-18 17:23:01.991 zwm, toLowerCase, str: tomorrow
2019-08-18 17:23:01.992 zwm, toUpperCase, result: TOMORROW
2019-08-18 17:23:01.992 zwm, toUpperCase, str: tomorrow
2019-08-18 17:23:01.992 zwm, toCharArray ch: t
2019-08-18 17:23:01.992 zwm, toCharArray ch: o
2019-08-18 17:23:01.992 zwm, toCharArray ch: m
2019-08-18 17:23:01.992 zwm, toCharArray ch: o
2019-08-18 17:23:01.992 zwm, toCharArray ch: r
2019-08-18 17:23:01.992 zwm, toCharArray ch: r
2019-08-18 17:23:01.992 zwm, toCharArray ch: o
2019-08-18 17:23:01.992 zwm, toCharArray ch: w
2019-08-18 17:23:01.993 zwm, test:   , tomorrow ,  , length: 16
2019-08-18 17:23:01.993 zwm, result: , tomorrow ,, length: 12
2019-08-18 17:23:01.993 zwm, test:   , tomorrow ,  , length: 16

三、原理

重要参数

//存放字符串内容的数组
private final char value[];

//hashCode值的缓存
private int hash; // Default to 0

//自定义比较器，可忽略大小写进行字符串的比较
public static final Comparator CASE_INSENSITIVE_ORDER
                                     = new CaseInsensitiveComparator();

构造函数

//无参构造函数
public String() {
    this.value = new char[0]; //创建一个长度为0的新字符数组
}

//指定一个字符串参数的构造函数
public String(String original) {
    this.value = original.value; //取其中的字符数组
    this.hash = original.hash; //取其中的哈希值
}

//指定一个字符数组的构造函数
public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length); //拷贝参数中的字符数组生成一个新的字符数组
}

//指定一个字符数组、偏移量、长度的构造函数
public String(char value[], int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count < 0) {
        throw new StringIndexOutOfBoundsException(count);
    }
    // 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 int hashCode()

//计算哈希值
public int hashCode() {
    int h = hash; //hash为缓存的哈希值，如果为0则表示未进行缓存
    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;
}

public boolean equals(Object anObject)

//判定当前对象与指定的对象是否相等
public boolean equals(Object anObject) {
    if (this == anObject) { //如果对象地址相同
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) { //如果字符串长度相同
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i]) //如果字符不相同
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

public boolean equalsIgnoreCase(String anotherString)

//忽略大小写，判定当前对象与指定的对象是否相等
public boolean equalsIgnoreCase(String anotherString) {
    return (this == anotherString) ? true //如果对象地址相同
            : (anotherString != null)
            && (anotherString.value.length == value.length) //如果字符串长度相同
            && regionMatches(true, 0, anotherString, 0, value.length); //调用regionMatches方法进行比较
}

public boolean regionMatches(boolean ignoreCase, int toffset,
        String other, int ooffset, int len) {
    char ta[] = value;
    int to = toffset;
    char pa[] = other.value;
    int po = ooffset;
    // Note: toffset, ooffset, or len might be near -1>>>1.
    if ((ooffset < 0) || (toffset < 0)
            || (toffset > (long)value.length - len)
            || (ooffset > (long)other.value.length - len)) {
        return false;
    }
    while (len-- > 0) {
        char c1 = ta[to++];
        char c2 = pa[po++];
        if (c1 == c2) {
            continue;
        }
        if (ignoreCase) { //判断是否忽略大小写
            // If characters don't match but case may be ignored,
            // try converting both characters to uppercase.
            // If the results match, then the comparison scan should
            // continue.
            char u1 = Character.toUpperCase(c1);
            char u2 = Character.toUpperCase(c2);
            if (u1 == u2) {
                continue;
            }
            // Unfortunately, conversion to uppercase does not work properly
            // for the Georgian alphabet, which has strange rules about case
            // conversion.  So we need to make one last check before
            // exiting.
            if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                continue;
            }
        }
        return false;
    }
    return true;
}

public int compareTo(String anotherString)

//当前对象与指定对象进行比较
public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;

    int k = 0;
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2;
}

public int compareToIgnoreCase(String str)

//忽略大小写，比较当前字符串与指定的字符串
public int compareToIgnoreCase(String str) {
    return CASE_INSENSITIVE_ORDER.compare(this, str);
}

//自定义比较器
public static final Comparator CASE_INSENSITIVE_ORDER
                                     = new CaseInsensitiveComparator();

//CaseInsensitiveComparator
public int compare(String s1, String s2) {
    int n1 = s1.length();
    int n2 = s2.length();
    int min = Math.min(n1, n2);
    for (int i = 0; i < min; i++) {
        char c1 = s1.charAt(i);
        char c2 = s2.charAt(i);
        if (c1 != c2) {
            c1 = Character.toUpperCase(c1);
            c2 = Character.toUpperCase(c2);
            if (c1 != c2) {
                c1 = Character.toLowerCase(c1);
                c2 = Character.toLowerCase(c2);
                if (c1 != c2) {
                    // No overflow because of numeric promotion
                    return c1 - c2;
                }
            }
        }
    }
    return n1 - n2;
}

//CaseInsensitiveComparator
private Object readResolve() { return CASE_INSENSITIVE_ORDER; }

public CharSequence subSequence(int beginIndex, int endIndex)

//从beginIndex索引到endIndex索引构造新字符串
public CharSequence subSequence(int beginIndex, int endIndex) {
    return this.substring(beginIndex, endIndex);
}

public boolean startsWith(String prefix)

//判断当前字符串是否以指定的字符串开头
public boolean startsWith(String prefix) {
    return startsWith(prefix, 0);
}

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;
}

public boolean endsWith(String suffix)

//判断当前字符串是否以指定的字符串结尾
public boolean endsWith(String suffix) {
    return startsWith(suffix, value.length - suffix.value.length);
}

public boolean contains(CharSequence s)

//判断当前字符串是否包含指定的字符序列
public boolean contains(CharSequence s) {
    return indexOf(s.toString()) > -1;
}

public char charAt(int index)

//查找索引位置的字符
public char charAt(int index) {
    if ((index < 0) || (index >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
    return value[index];
}

public int codePointAt(int index)

//获取索引位置的字符的Unicode码
public int codePointAt(int index) {
    if ((index < 0) || (index >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
    return Character.codePointAtImpl(value, index, value.length);
}

//Character
static int codePointAtImpl(char[] a, int index, int limit) {
    char c1 = a[index];
    if (isHighSurrogate(c1) && ++index < limit) {
        char c2 = a[index];
        if (isLowSurrogate(c2)) {
            return toCodePoint(c1, c2);
        }
    }
    return c1;
}

//Character
public static int toCodePoint(char high, char low) {
    // Optimized form of:
    // return ((high - MIN_HIGH_SURROGATE) << 10)
    //         + (low - MIN_LOW_SURROGATE)
    //         + MIN_SUPPLEMENTARY_CODE_POINT;
    return ((high << 10) + low) + (MIN_SUPPLEMENTARY_CODE_POINT
                                   - (MIN_HIGH_SURROGATE << 10)
                                   - MIN_LOW_SURROGATE);
}

public int codePointBefore(int index)

//获取指定索引的前一个位置的字符的Unicode码
public int codePointBefore(int index) {
    int i = index - 1;
    if ((i < 0) || (i >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
    return Character.codePointBeforeImpl(value, index, 0);
}

static int codePointBeforeImpl(char[] a, int index, int start) {
    char c2 = a[--index];
    if (isLowSurrogate(c2) && index > start) {
        char c1 = a[--index];
        if (isHighSurrogate(c1)) {
            return toCodePoint(c1, c2);
        }
    }
    return c2;
}

public int codePointCount(int beginIndex, int endIndex)

//获取beginIndex索引到endIndex索引的Unicode字节码个数
public int codePointCount(int beginIndex, int endIndex) {
    if (beginIndex < 0 || endIndex > value.length || beginIndex > endIndex) {
        throw new IndexOutOfBoundsException();
    }
    return Character.codePointCountImpl(value, beginIndex, endIndex - beginIndex);
}

static int codePointCountImpl(char[] a, int offset, int count) {
    int endIndex = offset + count;
    int n = count;
    for (int i = offset; i < endIndex; ) {
        if (isHighSurrogate(a[i++]) && i < endIndex &&
            isLowSurrogate(a[i])) {
            n--;
            i++;
        }
    }
    return n;
}

public int offsetByCodePoints(int index, int codePointOffset)

//获取index索引偏移codePointOffset长度后的索引位置
public int offsetByCodePoints(int index, int codePointOffset) {
    if (index < 0 || index > value.length) {
        throw new IndexOutOfBoundsException();
    }
    return Character.offsetByCodePointsImpl(value, 0, value.length,
            index, codePointOffset);
}

//Character
static int offsetByCodePointsImpl(char[]a, int start, int count,
                                  int index, int codePointOffset) {
    int x = index;
    if (codePointOffset >= 0) {
        int limit = start + count;
        int i;
        for (i = 0; x < limit && i < codePointOffset; i++) {
            if (isHighSurrogate(a[x++]) && x < limit &&
                isLowSurrogate(a[x])) {
                x++;
            }
        }
        if (i < codePointOffset) {
            throw new IndexOutOfBoundsException();
        }
    } else {
        int i;
        for (i = codePointOffset; x > start && i < 0; i++) {
            if (isLowSurrogate(a[--x]) && x > start &&
                isHighSurrogate(a[x-1])) {
                x--;
            }
        }
        if (i < 0) {
            throw new IndexOutOfBoundsException();
        }
    }
    return x;
}

public String concat(String str)

//在当前字符串后面拼接指定的字符串，生成新的字符串
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); //构造新的字符串
}

//构造函数
String(char[] value, boolean share) {
    // assert share : "unshared not supported";
    this.value = value; //将指定的字符数组的地址传递给成员变量value
}

public boolean contentEquals(CharSequence cs)

//当前字符串对象与指定的CharSequence对象进行内容比较
public boolean contentEquals(CharSequence cs) {
    // Argument is a StringBuffer, StringBuilder
    if (cs instanceof AbstractStringBuilder) {
        if (cs instanceof StringBuffer) { //若指定对象是StringBuffer实例，则需要进行同步
            synchronized(cs) {
               return nonSyncContentEquals((AbstractStringBuilder)cs);
            }
        } else {
            return nonSyncContentEquals((AbstractStringBuilder)cs);
        }
    }
    // Argument is a String
    if (cs.equals(this))
        return true;
    // Argument is a generic CharSequence
    char v1[] = value;
    int n = v1.length;
    if (n != cs.length()) {
        return false;
    }
    for (int i = 0; i < n; i++) {
        if (v1[i] != cs.charAt(i)) {
            return false;
        }
    }
    return true;
}

private boolean nonSyncContentEquals(AbstractStringBuilder sb) {
    char v1[] = value;
    char v2[] = sb.getValue();  //获取字符数组内容
    int n = v1.length;
    if (n != sb.length()) {
        return false;
    }
    for (int i = 0; i < n; i++) {
        if (v1[i] != v2[i]) {
            return false;
        }
    }
    return true;
}

public boolean contentEquals(StringBuffer sb)

//当前字符串对象与指定的StringBuffer对象进行内容比较
public boolean contentEquals(StringBuffer sb) {
    return contentEquals((CharSequence)sb);
}

public byte[] getBytes()

//对当前字符串使用默认的字符集获取字节数组
public byte[] getBytes() {
    return StringCoding.encode(value, 0, value.length);
}

//StringCoding
static byte[] encode(char[] ca, int off, int len) {
    String csn = Charset.defaultCharset().name(); //获取默认的字符集
    try {
        // use charset name encode() variant which provides caching.
        return encode(csn, ca, off, len);
    } catch (UnsupportedEncodingException x) {
        warnUnsupportedCharset(csn);
    }
    try {
        return encode("ISO-8859-1", ca, off, len);
    } catch (UnsupportedEncodingException x) {
        // If this code is hit during VM initialization, MessageUtils is
        // the only way we will be able to get any kind of error message.
        MessageUtils.err("ISO-8859-1 charset not available: "
                         + x.toString());
        // If we can not find ISO-8859-1 (a required encoding) then things
        // are seriously wrong with the installation.
        System.exit(1);
        return null;
    }
}

void getChars(char dst[], int dstBegin)

//获取从索引dstBegin开始组成的新字符串
void getChars(char dst[], int dstBegin) {
    System.arraycopy(value, 0, dst, dstBegin, value.length);
}

public int length()

//获取字符串长度
public int length() {
    return value.length;
}

public boolean isEmpty()

//判断字符串是否为空
public boolean isEmpty() {
    return value.length == 0;
}

public int indexOf(int ch)

//从左到右获取第一个与指定字符相同的位置索引
public int indexOf(int ch) {
    return indexOf(ch, 0);
}

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

    if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
        // handle most cases here (ch is a BMP code point or a
        // negative value (invalid 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);
    }
}

public int lastIndexOf(int ch)

//从右到左获取第一个与指定字符相同的位置索引
public int lastIndexOf(int ch) {
    return lastIndexOf(ch, value.length - 1);
}

public int lastIndexOf(int ch, int fromIndex) {
    if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
        // handle most cases here (ch is a BMP code point or a
        // negative value (invalid code point))
        final char[] value = this.value;
        int i = Math.min(fromIndex, value.length - 1);
        for (; i >= 0; i--) {
            if (value[i] == ch) {
                return i;
            }
        }
        return -1;
    } else {
        return lastIndexOfSupplementary(ch, fromIndex);
    }
}

public boolean matches(String regex)

//判断当前字符串是否匹配指定的正则表达式
public boolean matches(String regex) {
    return Pattern.matches(regex, this);
}

public String replace(char oldChar, char newChar)

//将当前字符串的旧字符oldChar替换为新字符newChar
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;
}

public String[] split(String regex)

//使用指定的正则表达式分割字符串，并返回分割后的字符串数组
public String[] split(String regex) {
    return split(regex, 0);
}

public String[] split(String regex, int limit) {
    /* fastpath if the regex is a
     (1)one-char String and this character is not one of the
        RegEx's meta characters ".$|()[{^?*+\\", or
     (2)two-char String and the first char is the backslash and
        the second is not the ascii digit or ascii letter.
     */
    char ch = 0;
    if (((regex.value.length == 1 &&
         ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
         (regex.length() == 2 &&
          regex.charAt(0) == '\\' &&
          (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
          ((ch-'a')|('z'-ch)) < 0 &&
          ((ch-'A')|('Z'-ch)) < 0)) &&
        (ch < Character.MIN_HIGH_SURROGATE ||
         ch > Character.MAX_LOW_SURROGATE))
    {
        int off = 0;
        int next = 0;
        boolean limited = limit > 0;
        ArrayList list = new ArrayList<>();
        while ((next = indexOf(ch, off)) != -1) {
            if (!limited || list.size() < limit - 1) {
                list.add(substring(off, next));
                off = next + 1;
            } else {    // last one
                //assert (list.size() == limit - 1);
                list.add(substring(off, value.length));
                off = value.length;
                break;
            }
        }
        // If no match was found, return this
        if (off == 0)
            return new String[]{this};

        // Add remaining segment
        if (!limited || list.size() < limit)
            list.add(substring(off, value.length));

        // Construct result
        int resultSize = list.size();
        if (limit == 0) {
            while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
                resultSize--;
            }
        }
        String[] result = new String[resultSize];
        return list.subList(0, resultSize).toArray(result);
    }
    return Pattern.compile(regex).split(this, limit);
}

public String substring(int beginIndex, int endIndex)

//从索引beginIndex开始到索引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 String toLowerCase()

//将当前字符串转化成小写
public String toLowerCase() {
    return toLowerCase(Locale.getDefault());
}

public String toUpperCase()

//将当前字符串转化成大写
public String toUpperCase() {
    return toUpperCase(Locale.getDefault());
}

public char[] toCharArray()

//将当前字符串转换成字符数组
public char[] toCharArray() {
    // Cannot use Arrays.copyOf because of class initialization order issues
    char result[] = new char[value.length];
    System.arraycopy(value, 0, result, 0, value.length);
    return result;
}

public String trim()

//将当前字符串左右两边的空格去掉，生成新的字符串
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;
}

public static String format(String format, Object... args)

//格式化输出字符串
public static String format(String format, Object... args) {
    return new Formatter().format(format, args).toString();
}

public static String valueOf(int i)

//将基本类型数据转为字符串数据
public static String valueOf(int i) {
    return Integer.toString(i);
}

public native String intern()

//本地方法
//对于JDK 1.6及之前，当使用intern()方法时，查询字符串常量池是否存在当前字符串，若不存在则将当前字符串复制到字符串常量池中，并返回字符串常量池中的引用。
//对于JDK 1.7及之后，当使用intern()方法时，先查询字符串常量池是否存在当前字符串，若字符串常量池中不存在则再从堆中查询，然后存储并返回相关引用；若都不存在则将当前字符串复制到字符串常量池中，并返回字符串常量池中的引用。
public native String intern();


//例子1
String s = new String("180") + new String("280");
Log.d(TAG, "zwm, s.intern() == s: " + (s.intern() == s));

//输出log
//s指向堆内存字符串地址引用
//s.intern()也指向堆内存字符串地址引用，因为常量池中不存在"180280"字符串地址引用
08-18 15:48:12.401 zwm, s.intern() == s: true


//例子2
String s = new String("181") + new String("281");
Log.d(TAG, "zwm, s == 181281: " + (s == "181281"));
Log.d(TAG, "zwm, s.intern() == s: " + (s.intern() == s));

//输出log
//s指向堆内存字符串地址引用
//由于代码中使用了"181281"字符串，因此常量池中存在一份字符串地址引用
//s.intern()指向常量池字符串地址引用，即非堆内存字符串地址引用
08-18 15:51:41.535 zwm, s == 181281: false
08-18 15:51:41.535 zwm, s.intern() == s: false

四、主题

StringBuffer StringBuilder

你可能感兴趣的:(JDK源码 -- String)

  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • 2024.9.6 Python，华为笔试题总结，字符串格式化，字符串操作，广度优先搜索解决公司组织绩效互评问题，无向图 RaidenQ python华为leetcode算法力扣广度优先无向图
    1.字符串格式化name="Alice"age=30formatted_string="Name:{},Age:{}".format(name,age)print(formatted_string)或者name="Alice"age=30formatted_string=f"Name:{name},Age:{age}"print(formatted_string)2.网络健康检查第一行有两个整数m
  • 非对称加密算法原理与应用2——RSA私钥加密文件 私语茶馆 云部署与开发架构及产品灵感记录RSA2048私钥加密
    作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
  • Golang语言基础知识点总结 最帅猪猪侠 golang开发语言后端
    Golang语言基础知识点小总结1.go语言有两大类型：值类型：数值类型，bool，string，数组，struct结构体变量直接存储值，内存通常在栈中分配,修改值,不会对源对象产生影响引用类型：指针，slice切片，管道chan，map，interface变量存储的是一个地址，这个地址对应的空间才真正存储数据值，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾
  • string trim的实现 JamesSawyer
    if(typeofString.prototype.trim!=='function'){String.prototype.trim=function(){//这个正则的意思是//'^''$'表示结束和开始//'^\s*'表示任意以空格开头的空格//'\s*$'表示任意以空格结尾的空格//'\S*'表示任意非空字符//'$1'表示'(\S*(\s*\S*)*)'returnthis.replace
  • [Swift]LeetCode943. 最短超级串 | Find the Shortest Superstring 黄小二哥 swift
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号：山青咏芝（shanqingyongzhi）➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）➤GitHub地址：https://github.com/strengthen/LeetCode➤原文地址：https://www.cnblogs.com/streng
  • [Swift]LeetCode767. 重构字符串 | Reorganize String weixin_30591551 swiftruntime
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号：山青咏芝（shanqingyongzhi）➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）➤GitHub地址：https://github.com/strengthen/LeetCode➤原文地址：https://www.cnblogs.com/streng
  • golang获取用户输入的几种方式 余生逆风飞翔 golang开发语言后端
    一、定义结构体typeUserInfostruct{Namestring`json:"name"`Ageint`json:"age"`Addstring`json:"add"`}typeReturnDatastruct{Messagestring`json:"message"`Statusstring`json:"status"`DataUserInfo`json:"data"`}二、get请求的
  • golang实现从服务器下载文件到本地指定目录 余生逆风飞翔 golang服务器开发语言
    一、连接服务器，采用sftp连接模式packagemiddlewaresimport("fmt""time""github.com/pkg/sftp""golang.org/x/crypto/ssh")//建立服务器连接funcConnect(user,password,hoststring,portint)(*sftp.Client,error){var(auth[]ssh.AuthMethod
  • spring mvc @RequestBody String类型参数 zoyation spring-mvcspringmvc
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
  • 处理标签包裹的字符串，并取出前250字符 周bro 前端javascript开发语言
    //假设这是你的HTML字符串varhtmlString=`这是一个段落。这是一个标题这是另一个段落，包含一些链接。`;//解析HTML字符串并提取文本functionextractTextFromHTML(html){varparser=newDOMParser();vardoc=parser.parseFromString(html,"text/html");vartextContent=do
  • 代码的执行效果 高天
    packagecom20210409;publicclassdemo04{publicstaticvoidmain(String[]args){//////&&当前的条件不满足,则最后结果一定不满足,后面的条件不再执行////&不管条件是否满足所有条件均作判断//intx=1,y=1;//if(++y==2&&x++==2){//x=7;//}//System.out.println("x="+x
  • Rust 所有权 简介 东离与糖宝 rust后端rust开发语言
    文章目录发现宝藏1.所有权基本概念2.所有权规则3.变量作用域4.栈与堆4.1栈（Stack）4.2堆（Heap）5.String类型5.1String类型5.2String的内存分配5.3所有权与内存管理5.4String与切片6.变量与数据交互方式6.1移动（Move）6.2.克隆（Clone）7.所有权与函数7.1.传递参数7.2.返回值总结发现宝藏前些天发现了一个巨牛的人工智能学习网站，通
  • 详解mybatis的一二级缓存以及缓存失效原因 仰望天花板 缓存数据库mybatisjavamysql
    数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
  • 如何区分Python中数据类型可变还是不可变 秸秆混凝烧结工程师
    关键字改变元素值，内存地址发生改变，被称为数据内型不可变如string，元组，存储数据类型单一，不能同时存在两个数据类型，新增元素后，表容量，元素个数，元素存储区ID改变，典型的内置元素一体存储法；改变元素值，但是内存地址不改变就是可变数据内型，如list，存储元素可以不同，删除，新增，插入，表序列不改变，扩展表容量时，对象地址ID不变，属于顺序表的，分离式存储结构，外置元素法，python中不可
  • python比较字符串是否一样,Python如何确定两个字符串是否相同 鲁东学子 python比较字符串是否一样
    I'vetriedtounderstandwhenPythonstringsareidentical(akasharingthesamememorylocation).Howeverduringmytests,thereseemstobenoobviousexplanationwhentwostringvariablesthatareequalsharethesamememory:importsy
  • 【自用25.1】C++-智能交友系统项目 .远_ 学习笔记C++Proc++算法开发语言
    注：项目类文章会陆续更新，请大家关注系列文章创建Girl类头文件#pragmaonce#includeusingnamespacestd;classBoy;classGirl{public:Girl();Girl(intage,stringname,intstyle);~Girl();intgetAge()const;stringgetName()const;intgetStyle()const;
  • Lombok：Java开发者的代码简化神器【后端 17】 终末圆 Java后端java开发语言mysql数据库后端springbootpython
    Lombok：Java开发者的代码简化神器在Java开发中，我们经常需要编写大量的样板代码，如getter、setter、equals、hashCode、toString等方法。这些代码虽然基础且必要，但往往占据了大量开发时间，且容易在属性变更时引发错误。幸运的是，Lombok这个Java库通过注解的方式，为我们提供了一种高效的解决方案。本文将详细介绍Lombok的使用及其优势。什么是Lombok
  • 2018-08-16【Swift 4.1】 关于Swift4.0以后调用MJExtension无法模型转换问题 码农happy
    1、本人使用swift4.1，弄了一晚上才弄好，结果还是一个小问题真是尴尬，要在model中每个属性前面加上@objcimportUIKitclassUserModel:NSObject{@objcvardix=String()}letdic=["dix":"ffffff"]asNSDictionaryletmodel=UserModel.mj_object(withKeyValues:dic)!
  • three.js AnimationClip 和 AnimationMixer 灵魂清零 threeweb3前端javascriptvue.js
    AnimationClip动画剪辑（AnimationClip）是一个可重用的关键帧轨道集，它代表动画。构造器AnimationClip(name:String,duration:Number,tracks:Array)name-此剪辑的名称duration-持续时间(单位秒).如果传入负数,持续时间将会从传入的数组中计算得到。tracks-一个由关键帧轨道（KeyframeTracks）组成的数
  • python使用MD5 18.程序员 哈希算法算法
    一、要使用Python进行MD5加密，可以使用Python标准库中的hashlib模块。二、案例importhashlibstring="Hello,World!"#要进行加密的字符串hash_object=hashlib.md5(string.encode())#将字符串编码并进行MD5加密hash_hex=hash_object.hexdigest()#获取加密后的十六进制字符串print(h
  • Java字符串为何是不可变的？ 木南曌 Javajava
    Java中字符串是一个非常常用的数据类型，它不仅在日常编码中频繁使用，也是面试中常见的考点之一。一个经常被讨论的话题是Java中的字符串为何是不可变的。本文将探讨这个问题，并解释其背后的原因。引言在Java中，字符串是通过String类来表示的，这个类有一个很重要的特性，那就是不可变性（Immutability）。这意味着一旦一个字符串对象被创建，它的值就不能被更改。例如，当你试图修改一个字符串时
  • shp文件解析转换为geojson/wkt格式字符串 自律_平庸 前端数据库大数据
    此函数用于处理上传的ZIP文件并将其转换为GeoJSON格式的字符串。具体步骤如下：验证上传文件是否为ZIP格式。创建临时目录以解压ZIP文件。解压缩ZIP文件至临时目录。查找解压后的.shp文件。如果缺少.shx或.dbf辅助文件，则创建空文件。读取Shapefile数据。将特征集合转换为GeoJSON格式。清理临时文件和资源。函数返回转换后的GeoJSON字符串。publicStringshp
  • day12 控制流程 if switch while do...while 猜数字游戏 卓越小Y JAVA学习日志游戏java开发语言
    控制流程顺序结构所有的程序都是按顺序执行if语句选择结构单选择语句if(a>0){System.out.println(“hello”);}packagecom.ckw.blog.select;importjava.util.Scanner;publicclassdemo01{publicstaticvoidmain(String[]args){intscore=0;Scannerscanner=
  • 多线程编程之存钱与取钱 周凡杨 javathread多线程存钱取钱
      生活费问题是这样的：学生每月都需要生活费，家长一次预存一段时间的生活费，家长和学生使用统一的一个帐号，在学生每次取帐号中一部分钱，直到帐号中没钱时 通知家长存钱，而家长看到帐户还有钱则不存钱，直到帐户没钱时才存钱。   问题分析：首先问题中有三个实体，学生、家长、银行账户，所以设计程序时就要设计三个类。其中银行账户只有一个，学生和家长操作的是同一个银行账户，学生的行为是
  • java中数组与List相互转换的方法 征客丶 JavaScriptjavajsonp
    1.List转换成为数组。（这里的List是实体是ArrayList) 　　调用ArrayList的toArray方法。 　　toArray 　　public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。如果列表能放入指定的数组，则返回放入此列表元素的数组。否则，将根据指定数组的运行时类型和此列表的大小分
  • Shell 流程控制 daizj 流程控制if elsewhilecaseshell
    Shell 流程控制 和Java、PHP等语言不一样，sh的流程控制不可为空，如(以下为PHP流程控制写法)： <?php if(isset($_GET["q"])){ search(q);}else{// 不做任何事情} 在sh/bash里可不能这么写，如果else分支没有语句执行，就不要写这个else，就像这样 if else if if 语句语
  • Linux服务器新手操作之二 周凡杨 Linux 简单 操作
    1.利用关键字搜寻Man Pages    man -k keyword  其中-k 是选项，keyword是要搜寻的关键字 如果现在想使用whoami命令，但是只记住了前3个字符who，就可以使用 man -k who来搜寻关键字who的man命令       [haself@HA5-DZ26 ~]$ man -k
  • socket聊天室之服务器搭建 朱辉辉33 socket
    因为我们做的是聊天室，所以会有多个客户端，每个客户端我们用一个线程去实现，通过搭建一个服务器来实现从每个客户端来读取信息和发送信息。    我们先写客户端的线程。 public class ChatSocket extends Thread{ Socket socket; public ChatSocket(Socket socket){ this.sock
  • 利用finereport建设保险公司决策分析系统的思路和方法 老A不折腾 finereport金融保险分析系统报表系统项目开发
    决策分析系统呈现的是数据页面，也就是俗称的报表，报表与报表间、数据与数据间都按照一定的逻辑设定，是业务人员查看、分析数据的平台，更是辅助领导们运营决策的平台。底层数据决定上层分析，所以建设决策分析系统一般包括数据层处理（数据仓库建设）。   项目背景介绍 通常，保险公司信息化程度很高，基本上都有业务处理系统（像集团业务处理系统、老业务处理系统、个人代理人系统等）、数据服务系统（通过
  • 始终要页面在ifream的最顶层 林鹤霄
    index.jsp中有ifream，但是session消失后要让login.jsp始终显示到ifream的最顶层。。。始终没搞定，后来反复琢磨之后，得到了解决办法，在这儿给大家分享下。。 index.jsp--->主要是加了颜色的那一句 <html> <iframe name="top" ></iframe> <ifram
  • MySQL binlog恢复数据 aigo mysql
    1，先确保my.ini已经配置了binlog：   # binlog log_bin = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.log log_bin_index = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.index log_error = D:/mysql-5.6.21-win
  • OCX打成CBA包并实现自动安装与自动升级 alxw4616 ocxcab
    近来手上有个项目,需要使用ocx控件 (ocx是什么? http://baike.baidu.com/view/393671.htm) 在生产过程中我遇到了如下问题. 1. 如何让 ocx 自动安装?     a) 如何签名?     b) 如何打包?     c) 如何安装到指定目录? 2.
  • Hashmap队列和PriorityQueue队列的应用 百合不是茶 Hashmap队列PriorityQueue队列
      HashMap队列已经是学过了的,但是最近在用的时候不是很熟悉,刚刚重新看以一次,   HashMap是K,v键 ,值     put()添加元素      //下面试HashMap去掉重复的 package com.hashMapandPriorityQueue; import java.util.H
  • JDK1.5 returnvalue实例 bijian1013 javathreadjava多线程returnvalue
    Callable接口： 返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。 Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。        ExecutorService接口方
  • angularjs指令中动态编译的方法(适用于有异步请求的情况) 内嵌指令无效 bijian1013 JavaScriptAngularJS
            在directive的link中有一个$http请求，当请求完成后根据返回的值动态做element.append('......');这个操作，能显示没问题，可问题是我动态组的HTML里面有ng-click，发现显示出来的内容根本不执行ng-click绑定的方法！     
  • 【Java范型二】Java范型详解之extend限定范型参数的类型 bit1129 extend
    在第一篇中，定义范型类时，使用如下的方式：   public class Generics<M, S, N> { //M,S,N是范型参数 }  这种方式定义的范型类有两个基本的问题：   1. 范型参数定义的实例字段，如private M m = null;由于M的类型在运行时才能确定，那么我们在类的方法中，无法使用m，这跟定义pri
  • 【HBase十三】HBase知识点总结 bit1129 hbase
    1. 数据从MemStore flush到磁盘的触发条件有哪些？    a.显式调用flush，比如flush 'mytable'    b.MemStore中的数据容量超过flush的指定容量，hbase.hregion.memstore.flush.size,默认值是64M 2. Region的构成是怎么样？ 1个Region由若干个Store组成
  • 服务器被DDOS攻击防御的SHELL脚本 ronin47
    mkdir /root/bin vi /root/bin/dropip.sh #!/bin/bash/bin/netstat -na|grep ESTABLISHED|awk ‘{print $5}’|awk -F:‘{print $1}’|sort|uniq -c|sort -rn|head -10|grep -v -E ’192.168|127.0′|awk ‘{if($2!=null&a
  • java程序员生存手册-craps 游戏-一个简单的游戏 bylijinnan java
    import java.util.Random; public class CrapsGame { /** * *一个简单的赌*博游戏，游戏规则如下： *玩家掷两个骰子，点数为1到6，如果第一次点数和为7或11，则玩家胜， *如果点数和为2、3或12，则玩家输， *如果和为其它点数，则记录第一次的点数和，然后继续掷骰，直至点数和等于第一次掷出的点
  • TOMCAT启动提示NB: JAVA_HOME should point to a JDK not a JRE解决 开窍的石头 JAVA_HOME
    当tomcat是解压的时候，用eclipse启动正常，点击startup.bat的时候启动报错; 报错如下：   The JAVA_HOME environment variable is not defined correctly This environment variable is needed to run this program NB: JAVA_HOME shou
  • [操作系统内核]操作系统与互联网 comsci 操作系统
         我首先申明：我这里所说的问题并不是针对哪个厂商的，仅仅是描述我对操作系统技术的一些看法       操作系统是一种与硬件层关系非常密切的系统软件，按理说，这种系统软件应该是由设计CPU和硬件板卡的厂商开发的，和软件公司没有直接的关系，也就是说，操作系统应该由做硬件的厂商来设计和开发
  • 富文本框ckeditor_4.4.7 文本框的简单使用 支持IE11 cuityang 富文本框
    <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <title>知识库内容编辑</tit
  • Property null not found darrenzhu datagridFlexAdvancedpropery null
    When you got error message like "Property null not found ***", try to fix it by the following way: 1)if you are using AdvancedDatagrid, make sure you only update the data in the data prov
  • MySQl数据库字符串替换函数使用 dcj3sjt126com mysql函数替换
    需求：需要将数据表中一个字段的值里面的所有的  .   替换成  _   原来的数据是  site.title  site.keywords  .... 替换后要为     site_title  site_keywords   使用的SQL语句如下：   updat
  • mac上终端起动MySQL的方法 dcj3sjt126com mysqlmac
    首先去官网下载: http://www.mysql.com/downloads/ 我下载了5.6.11的dmg然后安装,安装完成之后..如果要用终端去玩SQL.那么一开始要输入很长的:/usr/local/mysql/bin/mysql 这不方便啊,好想像windows下的cmd里面一样输入mysql -uroot -p1这样...上网查了下..可以实现滴. 打开终端,输入: 1
  • Gson使用一（Gson） eksliang jsongson
    转载请出自出处：http://eksliang.iteye.com/blog/2175401 一.概述 从结构上看Json，所有的数据（data）最终都可以分解成三种类型： 第一种类型是标量（scalar），也就是一个单独的字符串（string）或数字（numbers），比如"ickes"这个字符串。 第二种类型是序列（sequence），又叫做数组（array）
  • android点滴4 gundumw100 android
    Android 47个小知识 http://www.open-open.com/lib/view/open1422676091314.html Android实用代码七段（一） http://www.cnblogs.com/over140/archive/2012/09/26/2611999.html http://www.cnblogs.com/over140/arch
  • JavaWeb之JSP基本语法 ihuning javaweb
      目录   JSP模版元素  JSP表达式  JSP脚本片断  EL表达式  JSP注释  特殊字符序列的转义处理  如何查找JSP页面中的错误   JSP模版元素    JSP页面中的静态HTML内容称之为JSP模版元素，在静态的HTML内容之中可以嵌套JSP
  • App Extension编程指南（iOS8/OS X v10.10）中文版 啸笑天 ext
             当iOS 8.0和OS X v10.10发布后，一个全新的概念出现在我们眼前，那就是应用扩展。顾名思义，应用扩展允许开发者扩展应用的自定义功能和内容，能够让用户在使用其他app时使用该项功能。你可以开发一个应用扩展来执行某些特定的任务，用户使用该扩展后就可以在多个上下文环境中执行该任务。比如说，你提供了一个能让用户把内容分
  • SQLServer实现无限级树结构 macroli oraclesqlSQL Server
    表结构如下： 数据库id path titlesort 排序 1 0 首页 0 2 0,1 新闻 1 3 0,2 JAVA 2 4 0,3 JSP 3 5 0,2,3 业界动态 2 6 0,2,3 国内新闻 1 创建一个存储过程来实现，如果要在页面上使用可以设置一个返回变量将至传过去   create procedure test as begin decla
  • Css居中div，Css居中img，Css居中文本，Css垂直居中div qiaolevip 众观千象学习永无止境每天进步一点点css
    /**********Css居中Div**********/ div.center { width: 100px; margin: 0 auto; } /**********Css居中img**********/ img.center { display: block; margin-left: auto; margin-right: auto; }
  • Oracle 常用操作(实用) 吃猫的鱼 oracle
    SQL>select text from all_source where owner=user and name=upper('&plsql_name');  SQL>select * from user_ind_columns where index_name=upper('&index_name');  将表记录恢复到指定时间段以前
  • iOS中使用RSA对数据进行加密解密 witcheryne iosrsaiPhoneobjective c
      RSA算法是一种非对称加密算法,常被用于加密数据传输.如果配合上数字摘要算法, 也可以用于文件签名. 本文将讨论如何在iOS中使用RSA传输加密数据. 本文环境 mac os  openssl-1.0.1j, openssl需要使用1.x版本, 推荐使用[homebrew](http://brew.sh/)安装. Java 8 RSA基本原理 RS
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他