文章目录

一、StringBuilder类
二、包装类

一、StringBuilder类

1.1 字符串拼接问题

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

public class StringDemo {
   
    public static void main(String[] args) {
   
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。

根据这句话分析我们的代码，其实总***生了三个字符串，即"Hello"、"World"和"HelloWorld"。引用变量s首先指向Hello对象，最终指向拼接出来的新字符串对象，即HelloWord 。

由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用java.lang.StringBuilder类。

1.2 StringBuilder概述

查阅java.lang.StringBuilder的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)

1.3 构造方法

根据StringBuilder的API文档，常用构造方法有2个：

public StringBuilder()：构造一个空的StringBuilder容器。
public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

public class StringBuilderDemo {
   
    public static void main(String[] args) {
   
        //空参数构造方法
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+bu1);// bu1:""

        //带字符串的构造方法
        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:"+bu2);// bu2:abc
    }
}

1.4 常用方法

StringBuilder常用的方法有2个：

public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
public String toString()：将当前StringBuilder对象转换为String对象。

1.4.1 append方法

append方法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。例如：

public class Demo02StringBuilder {
   
	public static void main(String[] args) {
   
		//创建对象
		StringBuilder builder = new StringBuilder();
		//public StringBuilder append(任意类型)
		StringBuilder builder2 = builder.append("hello");
		//对比一下
		System.out.println("builder:"+builder);   // builder:hello
		System.out.println("builder2:"+builder2); // builder:hello
		System.out.println(builder == builder2);  //比较的是地址 true
	    // 可以添加 任何类型
		builder.append("hello");
		builder.append("world");
		builder.append(true);
		builder.append(100);
		// 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
        // 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
		//链式编程
		builder.append("hello").append("world").append(true).append(100);
		System.out.println("builder:"+builder); // builder:abchelloworldtrue100
	}
}

备注：StringBuilder已经覆盖重写了Object当中的toString方法。

1.4.2 toString方法

StringBuilder和String可以相互转换:

String->StringBuilder: 可以使用StringBuilder的构造方法
- StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内
StringBuilder->String:可以使用StringBuilder中的toString方法
public String toString()：将当前StringBuilder对象转换为String对象。

public class Demo16StringBuilder {
   
    public static void main(String[] args) {
   
        //String->StringBuilder
        String str = "hello";
        System.out.println("str:"+str); // str:hello
        StringBuilder bu = new StringBuilder(str);
        //往StringBuilder中添加数据
        bu.append("world");
        System.out.println("bu:"+bu); // bu:helloworld

        //StringBuilder->String
        String s = bu.toString();
        System.out.println("s:"+s); // s:helloworld
    }
}

二、包装类

2.1 概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

2.2 装箱与拆箱

2.2.1 概述

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

2.2.2 举例

用Integer与 int为例：（看懂代码即可）

装箱：

构造方法:
- Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
- Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
  传递的字符串,必须是基本类型的字符串,否则会抛出异常， “100” 正确 “a” 抛异常
静态方法:
- static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
- static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。

拆箱：

成员方法:

int intValue() 以 int 类型返回该 Integer 的值。

public class Demo01Integer {
   
    public static void main(String[] args) {
   
        //装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
        //构造方法
        Integer in1 = new Integer(1);//方法上有横线,说明方法过时了
        System.out.println(in1);//1 重写了toString方法

        Integer in2 = new Integer("1");
        System.out.println(in2);//1

        //静态方法
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3);

        //Integer in4 = Integer.valueOf("a");//NumberFormatException数字格式化异常
        Integer in4 = Integer.valueOf("1");
        System.out.println(in4);

        //拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
        int i = in1.intValue();
        System.out.println(i);
    }
}

2.3 自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

public class Demo02Ineger {
   
    public static void main(String[] args) {
   
        /* 自动装箱:直接把int类型的整数赋值包装类 Integer in = 1; 就相当于 Integer in = new Integer(1); */
        Integer in = 1;

        /* 自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,在进行计算 in+2; 将in对象转成基本数值(自动拆箱)就相当于 in.intVale() + 2 ; in = in.intVale() + 2 = 3 又是一个自动装箱,把基本数值转成对象。 */
        in = in+2;

        ArrayList<Integer> list = new ArrayList<>();
        /* ArrayList集合无法直接存储整数,可以存储Integer包装类 */
        list.add(1); //-->自动装箱 list.add(new Integer(1));

        int a = list.get(0); //-->自动拆箱 list.get(0).intValue();
    }
}

2.4 基本类型与字符串之间的转换

基本类型转换为String

基本类型转换String总共有三种方式
1. 基本类型的值+"" 最简单的方法(工作中常用)
2. 包装类的静态方法toString(参数),不是Object类的toString() 重载
  static String toString(int i) 返回一个表示指定整数的 String 对象。
3. String类的静态方法valueOf(参数)
  static String valueOf(int i) 返回 int 参数的字符串表示形式。
String转换成对应的基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：
- public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
- public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
- public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
- public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
- public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
- public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
- public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。
代码使用（仅以Integer类的静态方法parseXxx为例）如：
```
public class Demo03Integer {
     
    public static void main(String[] args) {
     
        //基本类型->字符串(String)
        int i1 = 100;
        String s1 = i1+"";
        System.out.println(s1+200);//100200

        String s2 = Integer.toString(100);
        System.out.println(s2+200);//100200

        String s3 = String.valueOf(100);
        System.out.println(s3+200);//100200

        //字符串(String)->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i-10); //90

        int a = Integer.parseInt("a");//NumberFormatException
        System.out.println(a); 
    }
}
```

注意：如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

StringBuilder类和包装类