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

     //==========属性

     private final char value[];

     private int hash;

     //==========构造器

     public String() {

        this.value = "".value;

     }

     public String(String original) {

        this.value = original.value;

        this.hash = original.hash;

     }

     //**************char[]

     public String(char value[]) {

        this.value = Arrays.copyOf(value, value.length);

     }

     //****************char[],charset

     public String(byte bytes[], Charset charset) {

        this(bytes, 0, bytes.length, charset);

    }

    public String(byte bytes[], int offset, int length, Charset charset) {

        if (charset == null)

            throw new NullPointerException("charset");

        checkBounds(bytes, offset, length);

        this.value =  StringCoding.decode(charset, bytes, offset, length);

    }

     //***********bytes[]

     public String(byte bytes[]) {

        this(bytes, 0, bytes.length);

     }

     //**********StringBuffer

     public String(StringBuffer buffer) {

        synchronized(buffer) {

            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());

        }

    }

    //**************StringBuilder

     public String(StringBuilder builder) {

        this.value = Arrays.copyOf(builder.getValue(), builder.length());

    }

    //============方法

    public char charAt(int index) {

        if ((index < 0) || (index >= value.length)) {

            throw new StringIndexOutOfBoundsException(index);

        }

        return value[index];

    }

    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 startsWith(String prefix) {

        return startsWith(prefix, 0);

    }

    public boolean endsWith(String suffix) {

        return startsWith(suffix, value.length - suffix.value.length);

    }

    public int hashCode() {

        int h = hash;

        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 int indexOf(String str) {

        return indexOf(str, 0);

    }

     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 boolean contains(CharSequence s) {

        return indexOf(s.toString()) > -1;

    }

    public String[] split(String regex) {

        return split(regex, 0);

    }

    public native String intern();

}

package com.an.string;

public class Test {

    public static void main(String[] args){

        test1();

        test2();

        test3();

        test4();

        test5();

    }

    /**

     *  java存储于  常量池中

     *  s1、s2存储于  堆内存中

     *  结果：false、true

     */

    public static void test1(){

        String s1=new String("java");

        String s2=new String("java");

        System.out.println(s1==s2);

        System.out.println(s1.equals(s2));

    }

    /**

     * java 存储于 常量池中

     * 结果：true、true

     */

    public static void test2(){

        String s1="java";

        String s2="java";

        System.out.println(s1==s2);

        System.out.println(s1.equals(s2));

    }

    /**

     *  s1、s2 、s4存放于常量池中

     *  s3 在运行期才会进行计算赋值

     *  结果：false

     */

    public static void test3(){

        String s1="java ";

        String s2="hi";

        String s3=s1+s2;

        String s4="java hi";

        System.out.println(s3==s4);

    }

    /**

     *  final修饰的，在编译期涉及该对象的会直接进行计算赋值

     *  s1、s2 、s4存放于常量池中

     *  s3 在编译期进行计算赋值

     *  结果：true

     */

    public static void test4(){

        final String s1="java ";

        final String s2="hi";

        String s3=s1+s2;

        String s4="java hi";

        System.out.println(s3==s4);

    }

    /**

     *  s1、hi、java存储于常量池中

     *  结果：true

     */

    public static void test5(){

        String s1="hi java";

        String s2="hi "+"java";

        System.out.println(s1==s2);

    }

}