主要内容
- System类
- StringBuilder类
- 包装类
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)：将数组中指定的数据拷贝到另一个数组中。
1.1 currentTimeMillis方法
实际上，currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值，类似于python中的time.time(),一般用于测试程序的运行时间。
1.使用：
public class SystemDemo {
public static void main(String[] args) {
//获取当前时间毫秒值
System.out.println(System.currentTimeMillis()); // 1516090531144
}
}
- 练习--(常用)
验证for循环打印数字1-9999所需要使用的时间（毫秒）
public class SystemTest1 {
public static void main(String[] args) {
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println("共耗时毫秒：" + (end - start));
}
}
1.2 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]
public class Demo01System {
public static void main(String[] args) {
demo02();
}
private static void demo02() {
//定义源数组
int[] src = {1,2,3,4,5};
//定义目标数组
int[] dest = {6,7,8,9,10};
System.out.println("复制前:"+ Arrays.toString(dest)); //复制前:[6, 7, 8, 9, 10]
//使用System类中的arraycopy把源数组的前3个元素复制到目标数组的前3个位置上
System.arraycopy(src,0,dest,0,3);
System.out.println("复制后:"+ Arrays.toString(dest)); //复制后:[1, 2, 3, 9, 10]
}
}
在复制前后dest的地址值并没有改变。
2.StringBuilder类
2.1 字符串拼接问题
由于String类的对象内容不可改变，该类其实是由final修饰的数组，是一个常量。
private final byte[] value;
所以每当进行字符串拼接时，总是会在内存中创建新的对象。例如：
public class StringDemo {
public static void main(String[] args) {
String str = "abc";
System.out.println(str); //abc
System.out.println(System.identityHashCode(str)); //2083562754
str +="123";
System.out.println(str); //123
System.out.println(System.identityHashCode(str)); //1811044090
}
}
在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。
根据这句话分析我们的代码，其实总共产生了三个字符串:即"abc"、"123"和"abc123"。引用变量s首先指向Hello对象，最终指向拼接出来的新字符串对象，即abc123 。
由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用java.lang.StringBuilder类。
2.2 StringBuilder类概述
查阅java.lang.StringBuilder的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。
原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)
String类和StringBuilder类对比：
2.3 构造方法
根据StringBuilder的API文档，常用构造方法有2个：
-
public StringBuilder()：构造一个空的StringBuilder容器。 -
public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。
代码：
public class Demo01StringBuilder {
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
}
}
2.4 常用方法
StringBuilder常用的方法有2个：
-
public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。 -
public String toString()：将当前StringBuilder对象转换为String对象。
1. append方法
append方法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder对象中。
当StringBuilder对象调用append方法时，返回值为对象本身this，所以该返回值可以不用定义变量接收，如果接收了返回值，那么这两个对象完全相同。
public class Person {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("123");
System.out.println(sb); //123
System.out.println(System.identityHashCode(sb)); //2083562754
sb.append("abc");
System.out.println(sb); //123abc
System.out.println(System.identityHashCode(sb)); //2083562754
}
}
上图中append前后sb的地址不变，但是内容变了。
链式编程:方法返回值是当前对象时,可以继续调用方法。
public class Demo02StringBuilder {
public static void main(String[] args) {
//创建StringBuilder对象
StringBuilder bu = new StringBuilder();
System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase()); //abc
bu.append("abc").append(1).append(true).append(8.8).append('中');
System.out.println(bu); //abc1true8.8中
2. toString方法
通过上边的实验，我们可能已经发现了当打印StringBuilder类的对象时，打印出来的不是地址值，而是该对象指向的字符串内容。
所以StringBuilder已经覆盖重写了Object当中的toString方法。
StringBuilder和String可以相互转换:
- String->StringBuilder:可以使用StringBuilder的构造方法
StringBuilder sb = StringBuilder(String str)构造一个字符串生成器，并初始化为指定的字符串内容，命名为sb。 - StringBuilder->String:可以使用StringBuilder中的toString方法
public String toString()：将当前StringBuilder对象转换为String对象。
代码：
public class Demo03StringBuilder {
public static void main(String[] args) {
// 1.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
// 2.StringBuilder->String
String s = bu.toString();
System.out.println("s:"+s); //s:helloworld
}
}
3.包装类
3.1 概述
Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：
| 基本类型 | 对应的包装类（位于java.lang包中） |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
其中int和char的包装类名相对特殊，其他的嗾使首字母大写。
3.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 对象。
public class Demo01Integer {
public static void main(String[] args) {
//装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
//构造方法
Integer in1 = new Integer(1);//方法上有横线,说明方法过时了
System.out.println(in1); //1 重写了toString方法
Integer in2 = new Integer("100");
System.out.println(in2); //100
//静态方法
Integer in3 = Integer.valueOf(90);
System.out.println(in3); //90
//Integer in4 = Integer.valueOf("a");//NumberFormatException数字格式化异常
Integer in4 = Integer.valueOf("79");
System.out.println(in4); //79
}
}
前两种构造方法已经过时，不建议使用。
拆箱
拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
- 成员方法:
int intValue()以 int 类型返回该 Integer 的值。
public class Demo01Integer {
public static void main(String[] args) {
//拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
//创建Integer对象，并赋值23
Integer in9 = Integer.valueOf(23);
//取出in9中的内容，转为int类型
int i = in9.intValue();
System.out.println(i); // 23
}
}
3.3 自动装箱与自动拆箱
由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：
自动装箱
Integer in = 1; //相当于Integer i = Integer.valueOf(1);
自动拆箱
in = in + 2 //先拆箱为int类型执行加法运算，然后赋值给in，自动装箱为Integer类型。
// in+2:就相当于 in.intVale() + 2 = 3
// in = in.intVale() + 2 = 3:是一个自动装箱
例如：
//定义接收Integer类型的对象
ArrayList list = new ArrayList<>();
/*
ArrayList集合无法直接存储整数,可以存储Integer包装类
*/
list.add(2); //-->自动装箱 list.add(new Integer(1));
int a = list.get(0); //-->自动拆箱 list.get(0).intValue();
3.4 基本类型与字符串之间的转换
基本类型与字符串类型之间的相互转换：
1.基本类型->字符串(String)
- 1.基本类型的值+"" 最简单的方法(工作中常用)
- 2.包装类的静态方法toString(参数),不是Object类的toString() 重载
static String toString(int i)返回一个表示指定整数的 String 对象。 - 3.String类的静态方法valueOf(参数)
static String valueOf(int i)返回 int 参数的字符串表示形式。
2.字符串(String)->基本类型
使用包装类的静态方法parseXXX("字符串");
- Integer类:
static int parseInt(String s) - Double类:
static double parseDouble(String s)
实例：
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
Double s = Double.parseDouble("100");
System.out.println(s+10000); //10100.0
// int a = Integer.parseInt("a");//NumberFormatException
// System.out.println(a);
}
}
对于基本数据类型转String，第一种+""最常用，其他作为了解即可。
在String转基本数据类型时，参数不能为不能转数字的字符,例如:a。
注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出
java.lang.NumberFormatException异常。
3.String转换成对应的基本类型对应API
除了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基本类型。
4.System类&StringBuilder类&包装类-总结
4.1System类
1.currentTimeMillis()方法
- 作用：获取当前系统毫秒值时间
- 使用：
long ms = System.currentTimeMillis();
2.arraycopy()方法
- 作用：复制数组
- 使用：
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5, 6, 7};
int[] arr2 = {9, 8, 7, 6, 5, 4};
System.arraycopy(arr1, 0, arr2, 0, 3);
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i]+" "); //1 2 3 6 5 4
}
}
4.2 StringBuilder类
1.构造方法
-
StringBuilder();:创建一个空的字符串缓冲区对象。 -
StringBuilder(String s);:根据传入参数创建一个字符串缓冲区对象
2. 成员方法
-
StringBuilder StringBuilder(Object obj): 添加任何类型的数据内容。 -
StringBuilder reverse(): 反转对象中得数据。 -
String toString();: 将缓冲区的内容StringBuilder对象转为字符串String对象。
实例：
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
//append，可以链式调用，返回this
sb.append(123).append(true);
System.out.println(sb); //true123
//反转sb
sb.reverse();
System.out.println(sb); //eurt321
System.out.println(sb.getClass().getName()); //java.lang.StringBuilder
String str = sb.toString();
System.out.println(str.getClass().getName()); //java.lang.String
}
4.3 包装类
1.内部类以及拆装箱
对于每一个基本数据类型都有对应的的包装类，该包装类封装了该基本数据类型，使其成为一个类似于String对象的东西，方便之后使用。
- 装箱：从基本类型转换为对应的包装类对象。
- 拆箱：从包装类对象转换为对应的基本类型。
常用方法不在赘述，见上方详解。
对于JDK1.5之后有了自动拆装箱，定义一个Integer对象，在使用基本运算时自动拆箱，计算完成后自动装箱。很方便。
2.基本数据类型--> 字符串String
最简单的：
String str = 123 +"";
3.字符String--> 基本数据类型
除了Character类之外，其他所有基本数据类型的包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型。
Int/Short/Double parseInt/Short/Double(String s)