第二章 字符串String、数组、数据类型转换

（一）字符串String

1、String、StringBuffer和StringBuilder的区别

1.String
字符串常量，字符串长度不可变。Java中String是immutable（不可变）的。
/** The value is used for character storage. */
private final char value[];
用于存放字符的数组被声明为final的，因此只能赋值一次，不可再更改。
2.StringBuffer（JDK1.0）
字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用StringBuffer，如果想转成String类型，可以调用StringBuffer的toString()方法。
Java.lang.StringBuffer线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
3.StringBuilder（JDK5.0）
字符串变量（非线程安全）。在内部，StringBuilder对象被当作是一个包含字符序列的变长数组。
java.lang.StringBuilder是一个可变的字符序列，是JDK5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
4.String、StringBuffer和StringBuilder的区别

2、String的不可变性

2.1）不可变对象
不可变类只是其实例不能被修改的类，每个实例中包含的所有信息都必须在创建该实例的时候就提供，并在对象的整个生命周期内固定不变。
2.2）如何实现不可变
1、不要提供任何会修改对象状态的方法。
2、保证类不会被拓展（一般声明为final即可）。
3、使所有的域都是 private final的。
4、确保对于任何可变组件的互斥访问（可以理解如果中存在可变对象的域，得确保客户端无法获得其引用，并且不要使用客户端提供的对象来初始化这样的域）。
2.3）String的不可变
实例

public static void main(String[] args) {
    String s = "ABCDEF";
    System.out.println("s = " + s);
    
    s = "123456";
    System.out.println("s = " + s);
}

打印结果

s = ABCDEF
s = 123456

从结果上看，s的值改变了，但s仅仅是一个String对象的引用，并不是对象本身。对象在内存中是一块内存区，而s只是一个引用，它指向了一个具体的对象。
在创建String对象的时候，s指向的是内存中的"ABDCEF",当执行语句s = “123456"后，其实又创建了一个新的对象"123456”,而s重新指向了这个新的对象，同时原来的"ABCDEF"并没有发生改变，仍保存在内存中。
2.4）改变"不可变对象"
现在我们已经知道了String的成员变量是private final 的，也就是初始化之后不可改变的。同时也提到value这个成员变量其实也是一个引用，指向真正的数组内存地址，不能改变它的引用指向，我们能不能直接改变内存数组中的数据呢，那么就需要获取到value，而value是私有的，可用反射获取

public static void reflectString() throws Exception{
    
    String s = "ABCDEF";
    System.out.println("s = " + s);
    
    Field valueField = s.getClass().getDeclaredField("value");
    valueField.setAccessible(true);
    
    char[] value = (char[]) valueField.get(s);
    value[0] = 'a';
    value[2] = 'c';
    value[4] = 'e';
    
    System.out.println("s = " + s);
}

打印结果

s = ABCDEF
s = aBcDeF

（二）数组

（三）数据类型转换

1、Java中基本类型转换

（1）由String转换成其他类型
由于在JDK 5以后就有了自动拆箱和自动装箱。因此我们可以用数据的类型来做数据的转换。

String str="123456";
int i=Integer.parseInt(str);

（2）其他类型转换为String类型
方法1：在String中有解析数据的方法，可以把任意基础类型转换成String类型

char ch[]=new char[]{'5','a','B'};
String str=String.valueOf(ch);

方法2：直接用变量加" "的形式直接把整形变成字符串

String st=5+"";

2、Java 8 种数据类型 字节大小

（四）Java基础类型与封装类型

4.1）Java基础类型与封装类型的区别

一、传递方式不同
基本类型（原始数据类型）在传递参数时都是按值传递。
封装类型是引用类型，按引用传递的(其实“引用也是按值传递的”，传递的是对象的地址)。由于包装类型都是不可变量，因此没有提供改变它值的方法，增加了对“按引用传递”的理解难度。
int是基本类型，直接存放数值；Integer是类，产生对象时用一个引用指向这个对象。
二、封装类可以有方法和属性
封装类可以有方法和属性，利用这些方法和属性来处理数据，如Integer.parseInt(Strings)。基本数据类型都是final修饰的，不能继承扩展新的类、新的方法。
三、默认值不同
基本类型跟封装类型的默认值是不一样的。如int i,i的预设为0；Integer j，j的预设为null,因为封装类产生的是对象，对象默认值为null。
四、存储位置
基本类型在内存中是存储在栈中，引用类型的引用（值的地址）存储在栈中，而实际的对象（值）是存在堆中。
虽然基本类型在栈上分配内存效率高，但是在堆栈上分配内存可能有内存泄漏的问题。
五、基础类型与封装类型对比
基本数据类型的好处就是速度快（不涉及到对象的构造和回收），封装类的目的主要是更好的处理数据之间的转换。

JDK5.0开始可以自动封包了，基本数据类型可以自动封装成封装类。
比如集合List，往里添加对象Object，在JDK5.0 之前，需要将数字封装成封装类型对象，再存到List中。

List list=new ArreyList();
list.add(new Integer(1));

在JDK5.0 以后可以自动封包，简写成

List list=new ArrayList();
list.add(1);

面试题：int与Integer不同
1、Integer是int的包装类，int则是java的一种基本数据类型
2、Integer变量必须实例化后才能使用，而int变量不需要
3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
4、Integer的默认值是null，int的默认值是0
延伸：
关于Integer和int的比较
1、由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.print(i == j); //false

2、Integer变量和int变量比较时，只要两个变量的值是相等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）

Integer i = new Integer(100);
int j = 100；
System.out.print(i == j); //true

3、非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）

Integer i = new Integer(100);
Integer j = 100;
System.out.print(i == j); //false

4、对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false

Integer i = 100;
Integer j = 100;
System.out.print(i == j); //true
Integer i = 128;
Integer j = 128;
System.out.print(i == j); //false

原因：
java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueOf(100)；，而java API中对Integer类型的valueOf的定义如下：

public static Integer valueOf(int i){
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high){
        return IntegerCache.cache[i + (-IntegerCache.low)];
    }
    return new Integer(i);
}

java对于-128到127之间的数，会直接从缓存中取，故相等。否则创建一个新的对象，故不等。

4.2）Java自动装箱与拆箱

1、什么是自动装箱、拆箱

装箱就是 自动将基本数据类型转换为包装器类型；拆箱就是 自动将包装器类型转换为基本数据类型。

Integer i = 10;  //装箱
int n = i;   //拆箱

2、自动装箱的原理及使用场景

基本数据类型–>封装类

    Integer i = 10;

执行时实际上系统执行了

    Integer i = Integer.valueOf(10);

分析Integer的valueOf源码：

public static Integer valueOf(int i) {
    if(i >= -128 && i <= IntegerCache.high)　　// 没有设置的话，IngegerCache.high 默认是127
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}

对于–128到127（默认是127）之间的值，Integer.valueOf(int i) 返回的是缓存的Integer对象（并不是新建对象），而其他值，执行Integer.valueOf(int i) 返回的是一个新建的 Integer对象。装箱的过程会创建对应的对象，这个会消耗内存，所以装箱的过程会增加内存的消耗，影响性能。

3、自动拆箱的原理及使用场景

封装类–>基本数据类型

Integer i = 10; //装箱 
int t = i; //拆箱，实际上执行了 int t = i.intValue();

进行运算时也可以进行拆箱

Integer i = 10; 
System.out.println(i++);

Integer与int运算

int i = 10;
Integer integer1 = new Integer(10); 
System.out.println(i==integer1);//true,integer1自动拆箱

intValue函数很简单，直接返回value值即可

@Override
 public int intValue() {
    return value;
}