7. 包装类、常用类
7.1 包装类
7.1.1 定义
在Java中，数据类型分为: 基本数据类型 和 引⽤数据类型。
包装类，其实就是对基本数据类型进⾏的⼀层包装，使其具有引⽤数据类型的特性，并添加了若⼲个
⽅法。其实，包装类在设计的时候，只是设计⼀个类，在类中维护了⼀个属性，⽤来表示包装的值。。
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
7.1.2 装箱与拆箱
**装箱：**将基本数据类型转型成包装类型。
实现方式：
1.可以通过包装类型的构造方法实现装箱。例：
Integer ai =new Integer(num);2.通过包装类型提供的静态方法 valueof【推荐】，例：
Integer ai2 = Integer.valueOf(num);
**拆箱：**将包装类型转型成基本数据类型。
// 1. 准备一个包装类型 Integer i = Integer.valueOf(10); // 2. 使用非静态方法 xxxValue() 实现 int n1 = i.intValue(); byte n2 = i.byteValue(); int n3 = Float.valueOf(3.14f).intValue();
补充：在JDK 1.4之后，装箱与拆箱是自动完成的。例：
//自动装箱
Integer a = 10;
//自动拆箱
int n=a;
7.1.3 自动装箱和拆箱
在JDK1.4之后，装箱和拆箱是可以⾃动完成的!
⾃动装箱: 直接使⽤⼀个基本数据类型的变量给⼀个包装类型的引⽤进⾏赋值即可
⾃动拆箱: 直接使⽤⼀个包装类型的引⽤给⼀个基本数据类型的变量进⾏赋值即可
⾃动的装箱: 省略掉的是 valueOf ⽅法
⾃动的拆箱: 省略掉的是 xxValue ⽅法
7.1.4 手动装箱和拆箱的使⽤场景
如果重载的⽅法中，不同的参数分别是基本数据类型和包装类型，则此时需要使⽤⼿动的装箱或拆箱
来区分调⽤不同的重载⽅法。
private static void show(int a) {
System.out.println("show(int)");
}
private static void show(Integer a) {
System.out.println("show(Integer)");
}
7.1.5 包装类中的享元原则
享元模式：将某些常⽤的值存储起来，在每次使⽤是时候，可以直接从⼀个容器中获取，⽽不是每次
使⽤都需要进⾏⼀次新的实例化。
Integer a = new Integer(10);
Integer b = new Integer(10);
System.out.println(a==b); //false
System.out.println(a.equals(b));//true
Integer c = Integer.valueOf(10);
Integer d = Integer.valueOf(10);
System.out.println(c==d); //true,因为满足一定的条件，共享同一块空间
Integer e = Integer.valueOf(1000);
Integer f = Integer.valueOf(1000);
System.out.println(e==f); //false，因为不满足享元条件
7.1.6字符串与基本数据类型之间的转换
-
基本数据类型转为字符串型
// 1、使⽤包装类的 toString ⽅法 int a = 10; String s1 = Integer.valueOf(a).toString(); // 2、拼接⼀个空字符串 String s2 = a + ""; // 3、使⽤字符串String类的valueOf⽅法 String s3 = String.valueOf(a); -
字符串类型转为基本数据类型
String str = "123"; // 1、使⽤parseXX⽅法 int n = Integer.parseInt(str); // 2、使⽤valueOf⽅法 // 这个⽅法，返回的其实是⼀个包装类的对象，在这⾥⼜进⾏了⼀次⾃动拆箱 int m = Integer.valueOf(str); -
特例: 字符型
// 字符串类型转型为字符型，上述的⼏种⽅式都不可以 // 因为字符是⼀个⽐较特殊的类型，⼀个字符串是由若⼲个字符组成的 // 字符串转字符，⽤charAt⽅法: 获取⼀个字符串中指定下标位的字符 char c = "hello".charAt(0);
7.2 Math类（必备）
封装了若干数学公式的数学类，当进行数学运算的时候，可以直接使用这个类。
int a =30,b=20;double c=0.5;
Math.PI; //静态属性：PI
Math.E; //静态属性：自然数E
//常用方法
Math.abs(-10); //计算一个数字的绝对值
Math.max(10, 20); //找出两个数的最大值
Math.min(10,20); //找出两个数的最小值
Math.pow(a, b); //计算参数a的b次幂的数值
Math.pow(a, 1.0/3); //计算参数a的开三次方跟
Math.sqrt(a); //计算参数a的算术平方根
Math.sin(a); //计算参数a的正弦：sin(a)的值
Math.cos(a); //计算参数a的余弦：cos(a)的值
Math.tan(a); //计算参数a的正切：tan(a)的值
Math.tan(1/a); //计算参数a的余切：cot(a)的值
Math.asin(c); //计算参数c的反正弦：arcsin(a)的值
Math.acos(c); //计算参数c的反余弦：arccos(a)的值
Math.atan(c); //计算参数c的反正切：arctan(a)的值
Math.atan(1/c); //计算参数c的反余切：arccot(a)的值
Math.floor(c); //计算参数c的向下取整数
Math.ceil(c); //计算参数c的向上取整数
Math.round(c); //计算参数c的四舍五入整数
Math.random(); //产生一个[0,1]范围的随机数
int a = (int)(Math.random()*10); //产生一个[0,10]范围的随机整数
7.3 Random类（必备）
是一个产生随机数的类。
//使用前需导包：
import java.util.Random;
public class Program2 {
public static void main(String[] args) {
int a = 10;
//1.实例化一个Random类对象
Random random = new Random();
//2.使用随机方法生成随机数
random.nextInt(); //生成一个[Integer.MIN_VALUE即-2^31,Integer.MAX_VALUE即2^31 +1]范围整型随机数
random.nextInt(a); //生成一个[0,a)范围整型随机数
random.nextBoolean(); //生成一个boolean类型随机数
random.nextDouble(); //生成一个[0.0,1.0)范围浮点型随机数
}
}
注：含参（此时称其为随机种子）的构造方法在程序每次运行得到的随机数列是固定的。而无参构造方法的随机数种子是纳秒级别的系统时间。
7.4 SimpleDateFormat类
1、将⼀个Date对象转成⼀个指定格式的字符串
2、将⼀个⾃定格式的字符串转成⼀个Date对象
7.5 BigInteger、BigDecimal类
BigInteger：用于描述一个非常大的整型数字
BigDecimal：用于描述一个非常大的浮点型数字
//使用前需导包：
import java.math.BigInteger;
import java.math.BigDecimal;
//实例化BigInteger类对象
BigInteger i1 = new BigInteger("2312334432343143245324123546572432489734");
BigInteger i2 = new BigInteger("3424354765665879870987546435234143435456");
//加法
BigInteger ret1 = i1.add(i2);
//减法
BigInteger ret2 = i1.subtract(i2);
//乘法
BigInteger ret3 = i1.multiply(i2);
//除法
BigInteger ret4 = i1.divide(i2); //同阶整型，根据首元素知结果为0
BigInteger [] ret5 = i1.divideAndRemainder(i2); //返回一个BigInteger类型的数组，首索引是商，次索引是余数
//实例化BigInteger类对象
BigDecimal i1 = new BigDecimal("1.231233443234314324532412354657243248974465434535523233232134");
BigDecimal i2 = new BigDecimal("2.3424354765665879870987546435234143435456");
//加法
BigDecimal ret1 = i1.add(i2);
//减法
BigDecimal ret2 = i1.subtract(i2);
//乘法
BigDecimal ret3 = i1.multiply(i2);
//除法
BigDecimal ret4 = i1.divide(i2); //同阶整型，根据首元素知结果为0
BigDecimal [] ret5 = i1.divideAndRemainder(i2); //返回一个BigInteger类型的数组，首索引是商，次索引是余数
7.6 System类
7.6.5.1arraycopy方法
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 Demo11SystemArrayCopy {
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]
*/
}
}
//获取系统当前时间，单位：毫秒
long time = System.currentTimeMillis(); //获取到的是一个时间戳，是从1970年1月1日起至今的毫秒数
long year = time/1000/60/60/24/365; //近似年份
//获取系统当前时间，单位：纳秒
System.nanoTime();
//数组间复制
System.arraycopy(src, srcPos, dest, destPos, length);//原数组,从元数据的起始位置开始,目标数组,目标数组的开始起始位置,要copy的数组的长度
//程序报错时输出相应红字信息
System.err.println("错误信息");
//垃圾回收器
System.gc();
7.7 Date、SimpleDateFormat类（必备）
Date:是一个日期类，用来描述一个日期、时间。
//使用前需导包：
import java.util.Date;
//获取系统当前时间，单位：毫秒
long time = System.currentTimeMillis(); //获取到的是一个时间戳，是从1970年1月1日起至今的毫秒数
long year = time/1000/60/60/24/365; //近似年份
//获取系统当前时间，单位：纳秒
System.nanoTime();
//数组间复制
System.arraycopy(src, srcPos, dest, destPos, length);//原数组,从元数据的起始位置开始,目标数组,目标数组的开始起始位置,要copy的数组的长度
//垃圾回收器
System.gc();
//Date:日期
Date date = new Date(); //构造方法，获取系统当前时间
Date date2 = new Date(21342543537823984l);//也可以通过一个指定的时间戳来实例化一个Date对象
System.out.println(date);
//常用方法
long time = date.getTime(); //获取时间戳，是从1970年1月1日起至今的毫秒数
date.before(date2); //判断一个日期是否在参数日期之前
date.after(date2); //判断一个日期是否在参数日期之后
date.equals(date2); //判断两个日期是否相同
SimpleDateFormat类：实现对日期进行格式化，可以实现将一个Date对象转成指定格式的字符串，或者将一个指定格式的字符串转成Date对象。
//1.一般情况下是通过有参构造来实例化这个对象的
//注：以下对应关系是系统规定的，不能自行替换
//y:年 yyyy:四位的年份 yy:两位的年份
//M:月 MM:两位的月份，若不够两位则首位补0
//d:日
//H:时（24小时制） h:时（12小时制）
//m:分
//s:秒 S:毫秒
//使用前需导包：
import java.text.SimpleDateFormat;
import java.util.Date;
//功能一：通过自定义参数格式来定义格式化字符串的格式
private static void format() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//2.将一个Date对象转成上述格式的字符串
String string = sdf.format(new Date());
System.out.println(string);
}
//功能二：将一个指定格式的字符串解析为一个Date
private static void parse() {
//1.实例化一个SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//2.将指定格式的字符串进行解析
try {
Date date = sdf.parse("2020年02月02日 22:22:22");
System.out.println(date);
} catch (ParseException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
7.8 Calendar类（必备）
Calendar类：日历类，也是用来表示日期、时间的类，在Date中很多时间操作的方法都被废弃并用该类中的方法替代。
//使用前需导包：
import java.time.Year;
import java.util.Calendar;
import java.util.Date;
//1.Calendar对象的获取
//1.获取一个Calendar对象,注：Calendar是抽象类，不能实例化对象，需调用方法获取
//getInstance()这个方法，返回的其实是Calendar类的一个非抽象子类的对象，并向上转型。
Calendar calendar = Calendar.getInstance();
/*例：
java.util.GregorianCalendar 对应的类
[time=1580648601281, 时间戳
areFieldsSet=true,
areAllFieldsSet=true,
lenient=true,
zone=sun.util.calendar.ZoneInfo[ 关于时区的设置
id="Asia/Shanghai",
offset=28800000,
dstSavings=0,
useDaylight=false,
transitions=19,
lastRule=null
],
firstDayOfWeek=1, 以下为关于日期的设置
minimalDaysInFirstWeek=1,
ERA=1,
YEAR=2020,
MONTH=1, 月份是0~11一一对应
WEEK_OF_YEAR=6,
WEEK_OF_MONTH=2,
DAY_OF_MONTH=2,
DAY_OF_YEAR=33,
DAY_OF_WEEK=1, 星期以周日为起始
DAY_OF_WEEK_IN_MONTH=1,
AM_PM=1, 0代表上午，1代表下午
HOUR=9,
HOUR_OF_DAY=21,
MINUTE=3,
SECOND=21,
MILLISECOND=281,
ZONE_OFFSET=28800000,
DST_OFFSET=0]
*/
}
2.常见的Calendar方法
// Calendar: 日历，在Java中，使用这个类来描述、操作时间。
// Date类中很多的方法都被废弃了，使用Calendar来替代。
// 1. 获取一个Calendar对象（因为Calendar是一个抽象类，不能通过new实例化对象）
// getInstance()这个方法，返回的其实是Calendar类的一个非抽象子类的对象，并向上转型。
Calendar calendar = Calendar.getInstance();
// 2. 常用方法
Date date = calendar.getTime(); // 获取一个用来描述指定时间的Date对象
long timestamp = calendar.getTimeInMillis(); // 获取时间戳
// 3. 设置、获取属性
// 3.1. 在设置属性的时候，Calendar会自动的进行合法性的校验，并且会自动的完成进位
calendar.set(Calendar.YEAR, 2022);
calendar.set(Calendar.MONTH, 12);
calendar.set(Calendar.DAY_OF_MONTH, 31);
calendar.set(Calendar.HOUR_OF_DAY, 24);
// 3.2. 内置的常见属性的设置方法
// 设置年月日
calendar.set(2020, Calendar.FEBRUARY, 28);
// 设置年月日时分
calendar.set(2020, Calendar.FEBRUARY, 28, 23, 39);
// 设置年月日时分秒
calendar.set(2020, Calendar.FEBRUARY, 29, 23, 59, 59);
// 3.3. 属性的获取
System.out.println("year: " + calendar.get(Calendar.YEAR));
System.out.println("month: " + calendar.get(Calendar.MONTH));
System.out.println("day: " + calendar.get(Calendar.DAY_OF_MONTH));
System.out.println("hour: " + calendar.get(Calendar.HOUR_OF_DAY));
System.out.println("minute: " + calendar.get(Calendar.MINUTE));
System.out.println("second: " + calendar.get(Calendar.SECOND));
// 4. 其他方法
calendar.setTime(new Date()); // 通过一个Date对象，设置日历信息
calendar.setTimeInMillis(1582859805644L); // 通过时间戳，设置时间
calendar.add(Calendar.YEAR, -1); // 对某一个属性值进行增的运算
System.out.println(calendar.get(Calendar.YEAR));
calendar.add(Calendar.DAY_OF_MONTH, 2);
System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.MONTH));
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
Calendar c = Calendar.getInstance();
System.out.println(calendar.before(c)); // 判断一个时间是否在另外一个时间之前
System.out.println(calendar.after(c)); // 判断一个时间是否在另外一个时间之后
System.out.println(calendar.equals(c)); // 判断两个时间是否想等
calendar.clear(); // 清空所有的属性值，重置为 1970年1月1日 00:00:00
calendar.clear(Calendar.YEAR); // 清空指定的属性值
System.out.println(calendar.get(Calendar.YEAR));
