深入学习java源码之StringBuilder.indexOf()与StringBuilder.reverse()

最新推荐文章于 2025-03-07 17:55:09 发布

wespten

最新推荐文章于 2025-03-07 17:55:09 发布

阅读量2k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： Java源码文章标签：深入学习java源码之StringBuilder.index

本文链接：https://blog.youkuaiyun.com/qq_35029061/article/details/85858669

Java源码专栏收录该内容

86 篇文章

订阅专栏

本文深入探讨了Java中的StringBuilder类，详细分析了indexOf()和reverse()方法的工作原理，同时介绍了toString()方法的实现，以及System.out.println的源码细节。通过本文，读者将对StringBuilder的内部机制有更深入的理解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

深入学习java源码之StringBuilder.indexOf()与StringBuilder.reverse()

java的toString()方法

在Java中每个类都默认继承Object类，除非声明继承某个类。而Object类中有一个叫做toString的方法。该方法返回的是该Java对象的内存地址经过哈希算法得出的int类型的值在转换成十六进制。这个输出的结果可以等同的看作Java对象在堆中的内存地址。

我们知道，在输出一个类的时候，如果没有重写父类的toString方法的话，打印的将会是Book@987876,即

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

所以只有子类重写父类的toString()方法之后，才会打印你想输出的信息。

System.out.println的源码：

public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }

String.valueOf(),

public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
}

Modifier and Type	Method and Description
`int`	`capacity()` 返回当前容量。
`char`	`charAt(int index)` 返回 `char`在指定索引在这个序列值。
`void`	`ensureCapacity(int minimumCapacity)` 确保容量至少等于规定的最小值。
`void`	`getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)` 字符从该序列复制到目标字符数组 `dst` 。
`int`	`indexOf(String str)` 返回指定子字符串第一次出现的字符串内的索引。
`int`	`indexOf(String str, int fromIndex)` 返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
`int`	`lastIndexOf(String str)` 返回指定子字符串最右边出现的字符串内的索引。
`int`	`lastIndexOf(String str, int fromIndex)` 返回指定子字符串最后一次出现的字符串中的索引。
`int`	`length()` 返回长度（字符数）。
`int`	`offsetByCodePoints(int index, int codePointOffset)` 返回此序列中与 `index`由 `codePointOffset`代码点偏移的索引。
`StringBuilder`	`reverse()` 导致该字符序列被序列的相反代替。
`void`	`setCharAt(int index, char ch)` 指定索引处的字符设置为 `ch` 。
`void`	`setLength(int newLength)` 设置字符序列的长度。
`CharSequence`	`subSequence(int start, int end)` 返回一个新的字符序列，该序列是该序列的子序列。
`String`	`substring(int start)` 返回一个新的 `String` ，其中包含此字符序列中当前包含的字符的子序列。
`String`	`substring(int start, int end)` 返回一个新的 `String` ，其中包含此序列中当前包含的字符的子序列。
`String`	`toString()` 返回表示此顺序中的数据的字符串。
`void`	`trimToSize()` 尝试减少用于字符序列的存储。

java源码

package java.lang;

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{

    static final long serialVersionUID = 4383685877147921099L;

    public StringBuilder() {
        super(16);
    }

    public StringBuilder(int capacity) {
        super(capacity);
    }

    public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }

    public StringBuilder(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }
	
    @Override
    public int indexOf(String str) {
        return super.indexOf(str);
    }

    @Override
    public int indexOf(String str, int fromIndex) {
        return super.indexOf(str, fromIndex);
    }

    @Override
    public int lastIndexOf(String str) {
        return super.lastIndexOf(str);
    }

    @Override
    public int lastIndexOf(String str, int fromIndex) {
        return super.lastIndexOf(str, fromIndex);
    }

    @Override
    public StringBuilder reverse() {
        super.reverse();
        return this;
    }

    @Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }
	
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        s.defaultWriteObject();
        s.writeInt(count);
        s.writeObject(value);
    }
	
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        count = s.readInt();
        value = (char[]) s.readObject();
    }	
}

package java.lang;

import sun.misc.FloatingDecimal;
import java.util.Arrays;

abstract class AbstractStringBuilder implements Appendable, CharSequence {

    char[] value;
	
    int count;	
	
    AbstractStringBuilder() {
    }

    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

    @Override
    public int length() {
        return count;
    }

    public int capacity() {
        return value.length;
    }

    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int newCapacity = (value.length << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }	
	
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }	

    public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
    {
        if (srcBegin < 0)
            throw new StringIndexOutOfBoundsException(srcBegin);
        if ((srcEnd < 0) || (srcEnd > count))
            throw new StringIndexOutOfBoundsException(srcEnd);
        if (srcBegin > srcEnd)
            throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }
	
    public int indexOf(String str) {
        return indexOf(str, 0);
    }
	
    public int indexOf(String str, int fromIndex) {
        return String.indexOf(value, 0, count, str, fromIndex);
    }
	
    public int lastIndexOf(String str) {
        return lastIndexOf(str, count);
    }

    public int lastIndexOf(String str, int fromIndex) {
        return String.lastIndexOf(value, 0, count, str, fromIndex);
    }

    public AbstractStringBuilder reverse() {
        boolean hasSurrogates = false;
        int n = count - 1;
        for (int j = (n-1) >> 1; j >= 0; j--) {
            int k = n - j;
            char cj = value[j];
            char ck = value[k];
            value[j] = ck;
            value[k] = cj;
            if (Character.isSurrogate(cj) ||
                Character.isSurrogate(ck)) {
                hasSurrogates = true;
            }
        }
        if (hasSurrogates) {
            reverseAllValidSurrogatePairs();
        }
        return this;
    }	
	
    private void reverseAllValidSurrogatePairs() {
        for (int i = 0; i < count - 1; i++) {
            char c2 = value[i];
            if (Character.isLowSurrogate(c2)) {
                char c1 = value[i + 1];
                if (Character.isHighSurrogate(c1)) {
                    value[i++] = c1;
                    value[i] = c2;
                }
            }
        }
    }
	
    public String substring(int start) {
        return substring(start, count);
    }
	
    @Override
    public CharSequence subSequence(int start, int end) {
        return substring(start, end);
    }

    public String substring(int start, int end) {
        if (start < 0)
            throw new StringIndexOutOfBoundsException(start);
        if (end > count)
            throw new StringIndexOutOfBoundsException(end);
        if (start > end)
            throw new StringIndexOutOfBoundsException(end - start);
        return new String(value, start, end - start);
    }	
	
    @Override
    public abstract String toString();
	
    final char[] getValue() {
        return value;
    }
	
}