JavaSE进阶系列(三)、常用API（System类、StringBuilder类、包装类）

三、常用API（System类、StringBuilder类、包装类）

3.1 System类

java.lang.System 类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：

public static long currentTimeMillis() ：返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将数组中指定的数据拷贝到另一个数组中。

currentTimeMillis方法

currentTimeMillis方法就是获取当前系统时间与1970年01月01日00:00点之间的毫秒差值。

public static void main(String[] args) {         
	//获取当前时间毫秒值           
	System.out.println(System.currentTimeMillis()); // 1516090531144    
}

arraycopy方法

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将数组中指定的数据拷贝到另一个数组中。

数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：

参数序号	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

例如：将src数组中前3个元素，复制到dest数组的前3个位置上。
复制元素前：src数组元素[1,2,3,4,5]，dest数组元素 [6,7,8,9,10]
复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]

import java.util.Arrays;   
public class systemArrayCopy {     
	public static void main(String[] args) {         
		int[] src = new int[]{1,2,3,4,5};         
		int[] dest = new int[]{6,7,8,9,10};         
		System.arraycopy( src, 0, dest, 0, 3);         
		/*代码运行后：两个数组中的元素发生了变化          
		src数组元素[1,2,3,4,5]          
		dest数组元素[1,2,3,9,10]         
		*/     
	} 
}

3.2 StringBuilder类

StringBuilder类的由来（字符串拼接问题）

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

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

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

构造方法

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

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

public class StringBuilderDemo {     
	public static void main(String[] args) {         
		StringBuilder sb1 = new StringBuilder();         
		System.out.println(sb1); // (空白)         
		// 使用带参构造         
		StringBuilder sb2 = new StringBuilder("itcast");         
		System.out.println(sb2); // itcast     
	} 
}

常用方法

StringBuilder常用的方法有2个：

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

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);          
		System.out.println("builder2:"+builder2);          
		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);          
		}      
}

toString方法
StringBuilder已经覆盖重写了Object当中的toString方法。
通过toString方法，StringBuilder对象将会转换为不可变的String对象。如：

public class Demo16StringBuilder {     
	public static void main(String[] args) {         
		// 链式创建         
		StringBuilder sb = new StringBuilder("Hello").append("World").append("Java"); 
		// 调用方法         
		String str = sb.toString();         
		System.out.println(str); // HelloWorldJava     
	} 
}

3.3 包装类

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

基本类型对应的包装类（位于java.lang包中）

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean
装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：
1. 装箱：从基本类型转换为对应的包装类对象。
2. 拆箱：从包装类对象转换为对应的基本类型。
```
//基本数值---->包装对象
Integer i = new Integer(4);//使用构造函数
Integer ii = Integer.valueOf(4);//使用包装类中的valueOf方法 
//包装对象---->基本数值
int num = i.intValue();
```

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

自动装箱与自动拆箱

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

//自动装箱。相当于Integer i = Integer.valueOf(4); 
Integer i = 4;

//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5; 
//加法运算完成后，再次装箱，把基本数值转成对象。
i = i + 5;

基本类型与字符串之间的转换
- 基本类型转换为String
  
  基本类型转换String总共有三种方式，查看课后资料可以得知，这里只讲简单的一种方式：
```
基本类型直接与””相连接即可；如：34+""
```
- String转换成对应的基本类型
  除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：
1. public static byte parseByte(String s) ：将字符串参数转换为对应的byte基本类型。
2. public static short parseShort(String s) ：将字符串参数转换为对应的short基本类型。
3. public static int parseInt(String s) ：将字符串参数转换为对应的int基本类型。
4. public static long parseLong(String s) ：将字符串参数转换为对应的long基本类型。
5. public static float parseFloat(String s) ：将字符串参数转换为对应的ﬂoat基本类型。
6. public static double parseDouble(String s) ：将字符串参数转换为对应的double基本类型。
7. public static boolean parseBoolean(String s) ：将字符串参数转换为对应的boolean基本类型。
```
public class Demo18WrapperParse {     
	public static void main(String[] args) {         
		int num = Integer.parseInt("100");     
	} 
}
```
注：如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出 java.lang.NumberFormatException 异常。