java源码之String类

string实现的三个接口和常用的方法

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {

string类实现了三个接口，现在分别分析一下这三个接口。

Comparable接口

 public int compareTo(T o);   //声明了compareTo()方法

从名字可知：这个接口应该和比较功能相关：

所有想要具有比较功能的类，都建议实现这个接口，而非是自己定义这个功能，这是面向对象的概念（将具有相同功能的事物抽象到一个共同的类或接口），并且为了多态也建议通过实现接口来进行向上转型，通过接口来操作具体实现，这也是面向接口编程要求我们做的

更多请参考：
https://www.cnblogs.com/lin-jing/p/8278271.html

string对象的属性有

//string的对应的基本数据类型是字符串数组
char value[];
//记录字符串的hash码
int hash;
//Class String is special cased within the Serialization Stream Protocol
//A String instance is written into an ObjectOutputStream
ObjectStreamField[] serialPersistentFields =new ObjectStreamField[0];

CharSequence接口

CharSequence b = “s”; > 这里表达有些不准确； CharSequence b = “s” 是一个类型强转操作 等于CharSequence b = (CharSequence) new String(“s”)
这里也就是接口的引用指向实现类的对象

CharSequence类是java.lang包下的一个接口，此接口对多种不同的对char访问的统一接口，像String、StringBuffer、StringBuilder类都是CharSequence的子接口；
CharSequence类和String类都可以定义字符串，但是==String定义的字符串只能读，CharSequence定义的字符串是可读可写的；(对于抽象类或者接口来说不可以直接使用new的方式创建对象，但是可以直接给它赋值；)

//字符串的长度
int length();
//返回字符串数组中指定下标的字符
char charAt(int index);
//返回子字符串
CharSequence subSequence(int start, int end);
//
public String toString();

Serializable接口

//类的可序列化性由实现类的java.io类启用。类的可序列化性由实现java.io.serializable接口的类启用。不实现此接口的类将不具有序列化或反序列化的任何状态。可序列化类的所有子类型都是其自身可序列化。序列化接口没有方法或字段仅用于识别可序列化的语义
public interface Serializable {}

indexOf()方法

 /**
     * @param   source       正在被搜索的字符串.
     * @param   sourceOffset 源字符串的偏移量.
     * @param   sourceCount  源字符串的计数.
     * @param   target       正在搜索的字符.
     * @param   targetOffset 目标字符串的偏移量.
     * @param   targetCount  目标字符串的计数.
     * @param   fromIndex    从哪开始搜索.
     */
    static int indexOf(char[] source, int sourceOffset, int sourceCount,
            char[] target, int targetOffset, int targetCount,
            int fromIndex) {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        if (targetCount == 0) {
            return fromIndex;
        }

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

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

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

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