java中不能解析为一种类型 java无法解析string

String源码分析：

1.String类不可被继承

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

由String的类源码可知，String由final修饰，故String不能被继承

2.String的值不可更改

private final char value[];
 public String() {
        this.value = new char[0];
    }

String的value属性被final修饰，只能在构造器执行时被赋值，将不能再更改，因此所有对String字符串的修改（如追加字符串，删除部分字符串，截取字符串）都不是在原来的对象基础上修改，而是新建一个String对象修改并返回，这会造成原对象被废弃，浪费资源且性能较差（特别是追加字符串和删除部分字符串），若遇到字符串将被频繁修改的情况，建议不要使用String,改用StringBuffer或StringBuilder。

3.String构造器

public String() {
        this.value = new char[0];无参构造器，默认value为一个长度为0的数组，所以为null；
    }
 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);//起始值下标小于0，抛异常
        }
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);//取值长度小于0，抛异常
        }
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);//起始值下标加长度大于数组长度，抛异常
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }
 public String(int[] codePoints, int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        if (offset > codePoints.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        //精确计算String所需要的长度
        final int end = offset + count;
        int n = count;
        for (int i = offset; i < end; i++) {
            int c = codePoints[i];
            if (Character.isBmpCodePoint(c))
                continue;
            else if (Character.isValidCodePoint(c))
                n++;
            else throw new IllegalArgumentException(Integer.toString(c));
        }

        //提取每一位的字符，并将其放入String字符串
        final char[] v = new char[n];

        for (int i = offset, j = 0; i < end; i++, j++) {
            int c = codePoints[i];
            if (Character.isBmpCodePoint(c))
                v[j] = (char)c;
            else
                Character.toSurrogates(c, v, j++);
        }
<pre name="code" class="java"><span style="font-family: Arial, Helvetica, sans-serif;">        this.value = v;</span>

}

4.charAt（int i）

5.equals（）方法

public boolean equals(Object anObject) {//该方法重写equals（）方法，不再是比较地址值，而是比较字符串的值是否相同
        if (this == anObject) {
            return true;//若比较的两个对象引用地址值相同，则为同一个对象，值当然相同
        }
        if (anObject instanceof String) {//String与另一个对象能比较的前提是，对方也属于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) {//将两个String对象的值放入数组中，遍历比较，全部相同才表示相同
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

6.String Pool

String Pool为java内置的区域，当String不是以new String（），形势创建时，该字符串便会被存入String Pool，这个字符串会变为公共资源，当另一个引用需要指向与该字符串相同的字符串时，java不会再创建新的字符串，而是直接指向同一个字符串，请看下面的代码：

public static void main(String[] args) {
		String a="hello";
		String b="hello";
		String c=new String ("hello");
		String d=new String ("hello");
		System.out.println(a==b);//true，hello被创建在String Pool中，a和b会指向同一个对象，
		System.out.println(a==c);//a指向的hello被创建在String Pool中，而c所指向的对象被创建在heap中，两者为不同的对象，地址值不同
		System.out.println(d==c);//c和d所指的对象都被创建在heap中，但是两个不同的对象，地址值不同

}