Java之字符串

1-实现了serializable，表示该类可以串行化，表明可以在网络中传输
2-实现了Comparable，表明可以比较大小
3-是final修饰的，不能被其他类继承
4-底层是private final byte[] value,用于存储字符串内容，final修饰的，一旦赋值不能被改变，
	不能被修改的意思是，地址不能被修改，但是可以修改其中单个字符

// 不能被改变
final byte[] a = {'a','b'};
a[0] = 'c'; //可以改变其中的单个字符

a = {'c'}; //编译错误，不能改变整体的值

//创建string字符串的方式
1：String s1 = "aa";
	先从常量池查看是否有aa,如果有直接指向常量池地址，如果没有先在常量池创建再指向，aa最终指向
    常量池地址
2：String s2 = new String("aa");
	现在堆中创建空间，里面维护了value属性，指向常量池中的aa空间，常量池中没有aa,重新创建，
    常量池中有直接通过value属性指向，最终指向的是堆中的空间地址

String s3 = "aa";
String s4 = "aa";
s3.equals(s4);//true
s3==s4;//true

String s5 = new String("aa");
String s6 = new String("aa");
s5.equals(s6);//true
s5 == s6;//false

String s7 ="aa";
String s8=new String("aa");
s7==s8;//false
s7.equals(s8);//true
s7==s8.intern();//true
s8==s8.intern();//false

intern()被调用时先检查常量池中是否有该字符串，如果没有，就创建一个放入常量池，如果有，就直接
取出返回池中的引用，最终返回的是常量池中的地址

Person per1 = new Person();
per1.setName = "aa";
Person per2 = new Person();
per2.setName = "aa";

p1.name == p2.name //true
p1.name == "aa"//true
p1 == p2//false    

String s1 = "aa";
s1 = "bb";//一共创建两个对象

String s1 = "aa" + "bb";//一共创建1个对象，编译器对于"+"会做优化，会直接创建"aabb",是常量池
中的相加

String s2 = "aabb"
s1 == s2 //true

String s1 = "aa";
String s2 = "bb";
String s3 = s1+s2;
// String s3 = s1+s2;底层是StringBuilder sb = new StringBuilder()
// sb.append(a);sb.append(b);sb.toString();s3是堆中变量的相加，一共创建三个对象：aa、bb、aabb

String s4 = "aabb";
s3 == s4 // false

String s = "a";
String s1 = new String("a");
创建一个对象

equals

String 重写了 equals 方法

public boolean equals(Object anObject) {
        // 判断内存地址是否相同
        if (this == anObject) {
            return true;
        }
    	// 判断是否是string类型
        if (anObject instanceof String) {
            String aString = (String)anObject;
            if (coder() == aString.coder()) {
                return isLatin1() ? StringLatin1.equals(value, aString.value)
                                  : StringUTF16.equals(value, aString.value);
            }
        }
        return false;
}

 public static boolean equals(byte[] value, byte[] other) {
     	// 长度是否相等
        if (value.length == other.length) {
            for (int i = 0; i < value.length; i++) {
                // 比较每个字符是否相等
                if (value[i] != other[i]) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

String 类是保存常量的，每次更新都需要开辟新的内存空间，效率很低，因此StringBuilder和
StringBuffer来增强String功能。并提高效率

subString(0,b)//从索引下标0开始取值，到b-1位置-》[0,b)

StringBuffer

1-StringBuffer表示可变长度的字符序列，可以对字符串内容进行增删。
  长度是可变长度
2-StringBuffer的直接父类是AbstractStringBuilder
3-StringBuffrt实现了Serializable接口，表明该类可以实现序列化
4-在父类AbstractStringBuilder有属性byte[] value,不是final,引用存放在堆中
5-StringBuffer是一个final类，不能被继承
6-StringBuffer sb = new StringBuffer();
	底层是创建一个长度为16的byte数组
7-String s = null;
  StringBuffer stringBuffer = new StringBuffer();
  stringBuffer.append(s);//"null",此处调用的是AbstractStringBuilder的appendNull()，追加一个"null"
8-String s = null;
  StringBuffer stringBuffer1 = new StringBuffer(s);//此处会报空指针异常，StringBuffer有参构造方法，会执行super(str.length() + 16);
9-StringBuffer是线程安全的,其方法由synchornized修饰
10-String a = "hello"；
   StringBuffer s = new StringBuffer("hello");
   a.equals(s) // false

StringBuilder

1-StringBuilder不是线程安全的，比StringBuffer快，方法没有被synchornized修饰

String、StringBuffer、StringBuilder区别

StringBuffer和StringBuilder均代表可变字符序列，方法一样
String是不可变字符序列，效率低，但是复用率高
StringBuffer线程安全
StringBuilder线程不安全
String s = "a";
s+="b";//实际上原来的“a”已经丢弃了，现在又产生一个字符穿ab,如果在循环中执行这样的操作，
会导致大量副本字符串存留在内存中，降低效率。

Integer.valueOf (String s) 和 Integer.parseInt(String s) 的源码解读

// parseInt 方法有两个参数，第二个参数是进制，默认是 10进制
public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
}

// 也可以直接调用该方法，指定要转换的进制
public static int parseInt(String s, int radix)
                throws NumberFormatException
    {
    ...
}        

// valueOf(s) 方法调用 parseInt(), 返回 Integer 类型
public static Integer valueOf(String s) throws NumberFormatException {
    return Integer.valueOf(parseInt(s, 10));
}

ion
{
…
}

// valueOf(s) 方法调用 parseInt(), 返回 Integer 类型
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}