一个基本数据类型对应一个包装类

基本数据类型	引用数据类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

1.包装类的目的

java中除基本数据类型外都是Object

oop的死角（基本数据类型）引入包装类去除死角

Java为了不让OOP有不面向对象的情况，给每个基本数据类型都定义了包装类类型，从而让所有数据都可以依照面向对象的方式处理。

Java的纯面向对象

保留基本数据类型的目的

1.基本数据类型存储真实值（字面量，立即量）引用数据类型大多存储对象，变量存储地址

2.引用数据类型除了有值，一般都有可以利用的属性和方法（包括构造方法），基本数据类型没有额外的方法

3.基本数据类型是原子性的（不可分割），引用数据类型由其他数据类型组合

4.基本数据类型操作简单，存储方便

2.包装类的作用

1.将基本数据类型转为引用数据类型

Integer类

自动装箱（常量直接创建对象）

// 包装类对象的创建
// 1.使用常量创建（自动装箱）
Integer integer1 = 1;
Integer integer2 = 1;
System.out.println(integer1);
System.out.println(integer2);
/*输出：
 *1
 *1
  */

构造方法

// 2.使用构造方法创建
Integer integer3 = new Integer(1);
Integer integer4 = new Integer(1);
System.out.println(integer3);
System.out.println(integer4);
/*输出：
 *1
 *1
  */

ValueOf()方法

// 3.ValueOf()方法
Integer integer5 = Integer.valueOf(1);
// ValueOf()方法可以将其他类型转换为本类型
Integer integer6 = Integer.valueOf("1");
Integer integer7 = Integer.valueOf((byte)1);
System.out.println(integer5);
System.out.println(integer6);
System.out.println(integer7);
/*输出：
 *1
 *1
  */

// 包装类重写了equals()方法
System.out.println(integer3.equals(integer4));// true
// 以常量创建的包装类对象在常量池中
System.out.println(integer1 == integer2);// true
System.out.println(integer1 == integer3);// false
// 以构造方法创建的包装类对象在堆内存中
System.out.println(integer3 == integer4);// false
// 以ValueOf()方法创建的包装类对象在常量池中
System.out.println(integer5 == integer6);// true
System.out.println(integer5 == integer7);// true
System.out.println(integer1 == integer5);// true
System.out.println(integer3 == integer5);// false

包装类转未基本数据类型的情况

1.自动拆箱

// 1.自动拆箱
int i = integer1;

2.与基本数据类型进行比较运算时会自动拆箱

System.out.println(i == integer1);// true

3.手动拆箱

// 1.intValue()方法,以int的形式转换
int i1 = integer1.intValue();
// 2.byteValue()方法,以byte的形式转换
byte b = integer1.byteValue();
// 3.shortValue()方法,以short的形式转换
short st = integer1.shortValue();
// 4.longValue()方法,以short的形式转换
long l = integer1.longValue();

字符串转Integer对象

Integer.parseInt(String str)

// 字符串转Integer
Integer integer8 = Integer.parseInt("100");
System.out.println(integer8);// 100
/*输出：
 *100
  */

以x进制转换Integer.parseInt(String str,int x)

// 以x进制转换
// 以二进制转换
Integer integer9 = Integer.parseInt("100",2);
System.out.println(integer9);// 4
/*输出：
 *4
  */

Integer缓存范围为[-128,127)

// Integer缓存范围为[-128,127)		
Integer test1 = 128;
Integer test2 = 128;
System.out.println(test1 == test2);// false

Character类

使用常量创建对象或构造方法创建对象

Character character1 = 'a';
char ch1 = 'a';
System.out.println(character1 == ch1);// true

Character.isDigit(char ch)方法,判断是否是数字字符

// Character.isDigit(char ch)方法,判断是否是数字字符
Character character2 = '9';
System.out.println(Character.isDigit(character2));// true

Character.isLetterorDigit(char ch)方法,判断是否是数字字符

// Character.isLetterorDigit(char ch)方法,判断是否是数字字符
System.out.println(Character.isLetterOrDigit(ch1));// true
System.out.println(Character.isLetterOrDigit(character2));// true

包装类特性

装箱：基本数据类型装进对象

拆箱：从对象读取数据

自动装箱：JDK5以后基本数据类型都可以自动的转为它对应的包装类而不用调用构造方法和ValueOf方法

自动拆箱：包装类可以自动的从引用数据类型转为基本数据类型

整型数存在缓存其缓存区间为[-128,127)

浮点数没有缓存

数学类

1.数学类的两个常量

1.E自然数底数

System.out.println(Math.E);// E=2.718281828459045
/*输出：
 *2.718281828459045
  */

2.PI圆周率

System.out.println(Math.PI);// PI=3.141592653589793
/*输出：
 *3.141592653589793
  */

2.常用方法

1.开方 sqrt(double x)方法,结果为double型

// 1.开方 sqrt(double x)方法,结果为double型
System.out.println(Math.sqrt(9));// 3.0
/*输出：
 *3.0
 */

2.向上取整 ceil(double x)方法,结果为double型

// 2.向上取整 ceil(double x)方法,结果为double型
System.out.println(Math.ceil(3.14));// 4.0
System.out.println(Math.ceil(-3.14));// -3.0
/*输出：
 *4.0
 *-3.0
 */

3.向下取整 floor(double x)方法,结果为double型

// 3.向下取整 floor(double x)方法,结果为double型
System.out.println(Math.floor(3.14));// 3.0
System.out.println(Math.floor(-3.14));// -4.0
/*输出：
 *3.0
 *-4.0
 */

4.幂运算 pow(double a,double b)取a的b次方,结果为double型

System.out.println(Math.pow(3, 2));
/*输出：
 *9.0
 */

5.取随机数 random()方法，结果为结果为double型,[0,1)

System.out.println(Math.random());

取指定范围的随机数

取[0,15)的随机数

// 取指定范围的随机数
// 取[0,15)的随机数
System.out.println((int)(Math.random()*15));

静态导入

import static java.lang.Math.*;

大量计算，可以直接使用方法名调用static方法

Random类获取随机数

// Random类获取随机数
Random random = new Random();
// 获取指定范围的int型随机数
System.out.println(random.nextInt(15));
// 获取随机boolean值
System.out.println(random.nextBoolean());
// 获取随机float值
System.out.println(random.nextFloat());
// 获取随机double值
System.out.println(random.nextDouble());

日期类

Jdk8以前（Date、Caldar、Format）

保存时间使用long型数据

Date类

获取当前时间

1.无参构造方法创建当前系统时间的对象

// 1.无参构造方法创建当前系统时间的对象
Date date1 = new Date();
System.out.println(date1);
/*输出：
 *Mon Sep 27 21:03:22 CST 2021
 */

2.有参构造创建创建当前系统时间的对象

Date date2 = new Date(System.currentTimeMillis());
System.out.println(date2);
/*输出：
 *Mon Sep 27 21:03:22 CST 2021
 */

以1970-01-01 00:00:00为基准

Date date3 = new Date(0);
System.out.println(date3);// Thu Jan 01 08:00:00 CST 1970
/*输出：
 *Thu Jan 01 08:00:00 CST 1970
 */

获取指定时间的日期对象

月份范围[0,12)

已弃用,会有千年虫bug

// 获取指定时间的日期对象
// 月份范围[0,12)
// 已弃用,会有千年虫bug
Date date4 = new Date(2012-1900, 11, 31, 0, 0, 0);
System.out.println(date4);// Mon Dec 31 00:00:00 CST 2012
/*输出：
 *Mon Dec 31 00:00:00 CST 2012
 */

getTime()方法获取时间,以时间戳的形式

// getTime()方法获取时间,以时间戳的形式
System.out.println(date1.getTime());
/*输出：
 *1632747802378
 */

setYear设置年份（已弃用）

// setYear设置年份
date1.setYear(2022-1900);
System.out.println(date1);
/*输出：
 *Tue Sep 27 21:03:22 CST 2022
 */

Calendar类

Calandra类是一个抽象类,可以通过getInstance()方法创建对象

// Calandra类是一个抽象类,可以通过getInstance()方法创建对象
Calendar calendar = Calendar.getInstance();
Calendar calendar1 = Calendar.getInstance();

使用set()方法创建指定日期的日历对象

// 使用set()方法创建指定日期的日历对象
calendar1.set(2021, 11, 31);
Calendar calendar2 = Calendar.getInstance();
calendar2.set(2021, 11, 31);
System.out.println(calendar);
/*输出：
 *java.util.GregorianCalendar[time=1632748269003,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=2021,MONTH=8,WEEK_OF_YEAR=40,WEEK_OF_MONTH=5,DAY_OF_MONTH=27,DAY_OF_YEAR=270,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=9,HOUR_OF_DAY=21,MINUTE=11,SECOND=9,MILLISECOND=3,ZONE_OFFSET=28800000,DST_OFFSET=0]
 */

使用getTime()方法将日历对象转为日期

// 使用getTime()方法将日历对象转为日期
System.out.println(calendar.getTime());
System.out.println(calendar1.getTime());
System.out.println(calendar2.getTime());
/*输出：
 *Mon Sep 27 21:11:09 CST 2021
 *Fri Dec 31 21:11:09 CST 2021
 *Fri Dec 31 21:11:09 CST 2021
 */

日期格式化类DateFromat

DateFromate是一个抽象类可以使用它的子类创建格式化对象

// 日期格式化类DateFromat
// DateFromate是一个抽象类可以使用它的子类创建格式化对象
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
System.out.println(dateFormat.format(calendar.getTime()));
System.out.println(dateFormat.format(calendar1.getTime()));
System.out.println(dateFormat.format(calendar2.getTime()));
/*输出：
 *2021-09-27
 *2021-12-31
 *2021-12-31
 */

在当前日期的基础上添加几天/几月（Calendar.MOUNTH_OF_YEAR）

add(int DAY_OF_MONTH ,int x)方法

// 在当前日期的基础上添加几天/几月（Calendar.MOUNTH_OF_YEAR） 
// add(int DAY_OF_MONTH ,int x)方法
calendar.add(Calendar.DAY_OF_MONTH, 1);
calendar1.add(Calendar.DAY_OF_MONTH, 1);

在当前日期的基础上添加几天 roll(int DAY_OF_MONTH ,int x)方法

当日期到下一个月或年时，回到本年的第一个月

// 在当前日期的基础上添加几天 roll(int DAY_OF_MONTH ,int x)方法
// 当日期到下一个月或年时，回到本年的第一个月
calendar2.roll(Calendar.DAY_OF_MONTH, 1);
// 未格式化前的
System.out.println(calendar.getTime());
// 格式化后的
System.out.println(dateFormat.format(calendar.getTime()));
System.out.println(dateFormat.format(calendar1.getTime()));
System.out.println(dateFormat.format(calendar2.getTime()));
/*输出：
 *Tue Sep 28 21:11:09 CST 2021
 *2021-09-28
 *2022-01-01
 *2021-12-01
 */