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)

  • 利用apache-pdfbox库修改pdf文件模板，进行信息替换 区块链攻城狮 pdf合同模板pdf生成合同生成
    publicStringcreateSignFile(Longid)throwsIOException{//1.验证企业信息CompanyDOcompany=validateCompanyExists(id);//2.验证签约状态if(company.getSignStatus()!=0){throwexception(COMPANY_SIGN_STATUS_NOT_ZERO);}//3.获取合同
  • JavaSE:4、流程控制 _Power_Y JavaSEjava算法开发语言
    1、代码块与作用域变量的使用范围，仅限于其定义时所处的代码块，也就是他的作用域。目前所说的变量均为局部变量publicclassMain{publicstaticvoidmain(String[]argv){inta=10;{intb=10;System.out.println(a);System.out.println(b);}System.out.println(a);//System.out
  • 字节跳动面试官亲述：Android开发学会了这些技术，你离大厂不远了 m0_65322636 程序员架构移动开发android
    HTTPSHTTP是超文本传输协议，明文传输；HTTPS使用SSL协议对HTTP传输数据进行了加密HTTP默认80端口；HTTPS默认443端口优点：安全缺点：费时、SSL证书收费，加密能力还是有限的，但是比HTTP强多了2、Java基础&容器&同步&设计模式StringBuilder、StringBuffer、+、String.concat链接字符串：StringBuffer线程安全，Strin
  • 文件大小自动转换工具类 小卡车555 java
    根据传入的文件大小，自动转换为B、KB、MB、GB、TBimportjava.text.DecimalFormat;publicclassFileSizeUtil{/***文件单位*/privatestaticfinalString[]units=newString[]{"B","KB","MB","GB","TB"};/***文件大小自动转换*@paramsize*@return*/public
  • java常用校验注解 Bee.F javajava
    1、值校验@NotNull注解被注解的元素必须不为空，一般用于数值类型的参数校验。@NotNull(message="用户编号不能为空")privateIntegeruserId;@NotBlank注解验证注解的元素值不为空（不为null、去除首位空格后长度为0），并且类型为String。@NotBlank(message="用户名称不能为空")privateStringuserName;@Not
  • Eclipse如何给main方法传值 马斯洛金字塔下的小灵猴儿 JAVA工程师相关eclipsemain方法传参
    importjava.util.Arrays;/***这是一个测试类，用来研究main方法的传值问题*@authorHHB*/publicclassTest{/***这是类的主方法，可以用来接受用户的输入，并将输入数据保存到一个String类型的数组里*@paramargs*/publicstaticvoidmain(String[]args){System.out.println(Arrays.
  • String存储原理 程序员阿鹏 Java面试八股文javajvm开发语言eclipseintellij-idea后端
    1.是什么在Java中，String是一种特殊的类，它是不可变的并且存储在堆内存中。为了理解String的存储原理，我们需要分解几个关键概念：不可变性、堆内存、字符串常量池和垃圾回收机制。下面我将详细解释这些概念并举例说明。不可变性(Immutability)String类在Java中是不可变的，这意味着一旦创建了String对象，它的值就不能被修改。任何对String进行的修改操作，实际上都是创
  • JAVA常用校验注解 小卡车555 java
    引入依赖org.springframeworkspring-boot-starter-validation2.6.13相关注解及使用说明注解描述@AssertFalse所注解的元素必须是Boolean类型，且值为false@AssertTrue所注解的元素必须是Boolean类型，且值为true@DecimalMin验证Number和String对象是否大于等于指定的值，支持小数@DecimalM
  • 哈希表 383.赎金信 柴... 散列表算法leetcode
    统计两个字符串中，每个字母出现的次数，最后统计，当数组所有位置都>0时，就能确定。classSolution{publicbooleancanConstruct(StringransomNote,Stringmagazine){int[]record=newint[26];if(ransomNote.length()>magazine.length()){returnfalse;}for(inti
  • 枚举，注解 柴... 韩顺平学习java开发语言
    自定义类实现枚举1.不需要提供setXxx方法，因为枚举对象值通常为只读2.对枚举对象/属性使用final+static共同修饰，实现底层优化3.枚举对象名通常使用全部大写，常量的命名规范(XXX_XXX)4.枚举对象根据需要，也可以有多个属性packagechapter;publicclassEnum{publicstaticvoidmain(String[]args){System.out.p
  • String方法(JDK9) 凯哥学堂
    声明：本栏目所使用的素材都是凯哥学堂VIP学员所写，学员有权匿名，对文章有最终解释权；凯哥学堂旨在促进VIP学员互相学习的基础上公开笔记。String方法(JDK9)构造器：String#String()无参数构造器，默认给的是一个””空字符串String#String(java.lang.String)给你一个char数组，它就帮你进行ABCD输出GBK中文简体+繁体字符集GB2312中文简体字
  • SharedPreferences hdychi
    一、简介在Android中，主要有以下几种存储方式：1、SharedPreferences，在键值对中存储私有原始数据。2、内部存储，在设备内存中存储私有数据。官方示例：StringFILENAME="hello_file";Stringstring="helloworld!";FileOutputStreamfos=openFileOutput(FILENAME,Context.MODE_PRI
  • vue3 内置组件＜Teleport＞ fishmemory7sec vue3vue.js前端
    官方文档：Teleport内置组件将一个组件的模板内容渲染到指定的DOM节点位置，而不是在组件自身的挂载点。组件的参数说明：to：必填项。指定目标容器。可以是选择器或实际元素。类型：string|HTMLElement作用：指定要将内容传送（teleport）到的目标位置。可以是一个CSS选择器字符串，用于选择一个现存的DOM元素，也可以是一个实际的DOM元素对象引用。示例：disabled：可选
  • Python3.8 特性介绍 刷漆猫咪
    简介海象表达式:=仅位置参数/f-strings说明符=启动异步REPLunittest支持异步简介Python3.8已经发布了,官方文档看这里What’sNewInPython3.8.介绍一些Python3.8中的新特性.海象表达式:=新的语法:=将给变量赋值,这个变量是更大的表达式的一部分.if(n:=len(a))>10:print(f"Lististoolong({n}elements,e
  • C# 多线程操作同一个文件，如何避免冲突 FlYFlOWERANDLEAF c#开发语言
    1使用lock经测试，依然存在线程冲突privatestaticobjectlocker=newobject();……lock(locker){stringbText=File.ReadAllText(FPath);returnbText;}……lock(locker){File.WriteAllText(FPath,aContent);}2使用ReaderWriterLockSlim经测试，依然
  • 使用poi替换XWPFTableCell内容，并设置行间距 RR369_yyh javaUtiljavapoi
    使用poi读取word文档（docx类型），进行数据替换。另外，为了记录poi设置行间距的api，真是找了好几十分钟才找到啊啊啊啊！！！importorg.apache.poi.xwpf.usermodel.*;importorg.springframework.util.StringUtils;importjava.io.File;importjava.io.FileInputStream;im
  • Java之String、StringBuffer、StringBuilder zoux
    （1）String：String类是final修饰的，是不可变的。我们看到的例如:Stringa="hello";a=a+"1";实际上是先生成了一个对象然后得到结果"hello1",最后在赋值给对象a;String类型的任何改动都是先生成一个其他对象再重新赋值。所以String类适合那种常量或者基本没变化的字符串。（2）StringBuilderStringbuffer是可改变的，用append
  • VUE中使用vue-office/pdf预览PDF 人间废料记 vue.jspdf前端
    安装npminstall@vue-office/pdfVUE组件中importVueOfficePdffrom'@vue-office/pdf';importEmptyElefrom'@/components/EmptyEle/index';//没有数据时的占位组件constprops=defineProps({pdfUrl:{type:String,default:''}});/*这块是处理边上
  • react 更新元素状态 叶绿素yls
    所有的react元素都是immutable不可变的。当元素被创建之后，我们无法修改他的内容或属性。根据我们现在所学的react的知识，我们要更新元素的内容，我们必须重新渲染这个元素，也就是重新创建这个元素。看一个例子：functiontick(){constelement=Hello,worldItis{newDate().toLocaleString()}.;ReactDOM.render(el
  • Android保存Activity状态 wishes丶啊
    在Activity#onSaveInstanceState()可以对数据进行保存，然后在Activity#onCreate()中获取代码:classMainActivityextendsActivity{@OverrideprotectedvoidonCreate(BundlesavedInstanceState){if(savedInstanceState!=null){Stringname=s
  • 把html字符串转为可以被js操作的dom 微特尔普拉斯 javascriptwebnodejavascripthtml前端
    在JavaScript中，您可以使用DOMParserAPI将HTML字符串转换为可操作的DOM节点。以下是具体步骤：1.创建DOMParser实例：constparser=newDOMParser();2.使用parseFromString()方法解析HTML字符串：consthtmlString='Hello,world!';constdoc=parser.parseFromString(ht
  • 基础-3 hellomyshadow
    异常处理error接口：Go中的一个关于错误处理的标准模式，属于Go内建的接口类型；typeerrorinterface{Error()string}使用方式：import"errors"functest(aint,bint)(valueint,errerror){ifb==0{err=errors.New("0不能作为除数！")return}else{value=a/breturn}}funcm
  • java:datatimeformat(处理字符串格式问题) StringBuilder（处理字符串）BigDecimal(解决小数失真) 不会编程的阿成 java开发语言
    时间相关的获取方案LocalDate:代表本地的日期（年，月，日，星期）LocalTime:代表本地时间（时，分，秒，纳秒）localDateTime:代表本地日期，时间（年，月，日，星期，时，分，秒，纳秒）importjava.text.SimpleDateFormat;importjava.util.Date;publicclassTimeDemo{publicstaticvoidmain(S
  • Rust 函数 lly202406 开发语言
    Rust函数Rust是一种系统编程语言，以其安全性、速度和并发性而闻名。在Rust中，函数是一等公民，是组织代码和实现功能的基本单位。本文将深入探讨Rust中的函数，包括其定义、特性、参数、返回值以及高级用法。函数定义在Rust中，函数使用fn关键字定义。函数可以有参数和返回值。下面是一个简单的函数定义示例：fngreet(name:&str)->String{format!("Hello,{}!
  • ctf逆向解题——Bomb二进制炸弹 Funkypantss
    BombPhase1在输入阶段将由文件输入的字符存储在input中，在phase1，该阶段将原字符串存储到rdi中，调用pases_1函数进行字符串比较。image进入phase1函数，该函数将原字符串rdi与预先设定的字符串“BorderrelationswithCanadahaveneverbeenbetter.”（存储在rsi中）进行比较，用于比较的函数是strings_not_equal，
  • Java语言程序设计与数据结构（基础篇）课后练习题 第十一章 （一） 2401_85111725 java数据结构python
    publicStringtoString(){return"Triangle:side1="+s1+"side2="+s2+"side3="+s3;}}11.2=================================================================packagedishiyizhang;publicclassdishiyizhang{publicstati
  • 【数据结构】字符串与JSON字符串、JSON字符串及相应数据结构（如对象与数组）之间的相互转换 理想青年宁兴星 数据结构数据结构jsonjava
    前言：下面打印日志用的是FastJSON依赖库中的@Log4j2。依赖：com.alibabafastjson1.2.80目录普通字符串->json字符串json字符串->普通字符串java对象->json字符串json字符串->java对象普通字符串->json字符串代码：publicstaticvoidmain(String[]args){Strings="ningxingxing";Stri
  • WPF中的文件保存功能 Vae_Mars AI对话中的其他知识wpf
    1.解释说明-在设计wpf界面的时候，难免会有文件保存的需求，这时就需要添加文件下载功能-这个是调用的windows的api，所以兼容性比较强-可以根据返回值确定是否成功-使用时直接调用这个程序就行，url填写你的文件地址，name即为文件的默认名2.程序示例privateboolDownloadView(stringurl,stringname){boolfanhui=false;stringm
  • WPF中图片的宫格显示 Vae_Mars WPF-AI对话wpf
    1.解释说明-使用ScrollViewer控件来达到滑动的效果-使用WrapPanel的自动换行特性，保证图片在占满横向空间后自动往下排布-使用foreach的方法来游历所有的图片url2.xaml代码示例3.cs代码示例//加载url转换成BitmapImageprivateasyncTaskLoadImageFromUrl(stringurl){try{using(HttpClientclie
  • .net6 SqlSugar配置及增删改查（webapi项目） 潘小白梦想进大厂 SqlSugar.net数据库
    NuGet包：1.SqlSugarCore2.System.Data.SqlClientProgram配置:builder.Services.AddScoped(x=>{SqlSugarClientdb=newSqlSugarClient(newConnectionConfig(){ConnectionString="DataSource=.;InitialCatalog=hx;Integrate
  • 多线程编程之存钱与取钱 周凡杨 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其他