JavaSE 之 基本常用类

一、Class Object

1.概念：

​ 类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

2.特点：

​ a. Object定义在java.lang包，lang是java的核心包，此包中所有类在使用时不需要import

​ b. 有且只有一个无参构造方法

​ c. 没有构造方法，只能用对象来调用

3.方法（method - 11）：

1）toString（）：字符串形式输出内容

a. 默认实现：

​ 完整类名（全限定类名）@十六进制的hashCode值（地址值）

b. 方法重写：

​ 自定义输出格式

2）equals（）：比较两个对象是否相等

a. 方法重写：

​ 自定义对象的比较方式

b. 步骤：

​ ① 判断是不是同一个对象

​ ② 判断是不是同一种类型

​ ③ 判断是不是同一种类型但不同对象

3）hashCode（）：计算内存地址

a. native关键词：

​ Java Native Interface - Java本地接口

b. 本地方法：

​ 方法定义上使用native关键词修饰

c. 默认实现：

​ 底层代码是c语言进行计算内存位置，new对象时会根据提供的对象属性计算位置

4）getClass（）：获取类的字节码对象

​ a. 类加载

​ ① 位置：加载到JVM的方法区

​ ② 类加载次数：Only One Time

​ ③ 触发类加载的条件：

​ ：实例化对象

​ ：调用静态变量 / 方法

​ ：调用getClass()，获取类的字节码对象

​ 类名.class，获取类的字节码对象

​ ：Class.forName(“全限定类名”) – 手动加载指定类

5）clone（）：克隆（深克隆与浅克隆？）

​ a. 深克隆（深拷贝）：复制对象，对象的读写

​ 实现：

​ ① 克隆对象的Class实现Cloneable接口

​ ② 克隆对象的Class实现Serilizable接口

​ ③ 使用开源工具，JSON

​ b. 浅克隆（浅拷贝）：复制引用

6）finalize（）：垃圾回收机制 GC（内存溢出 & 内存泄漏）

​ a. finalize的作用

​ 构造函数：创建对象时调用

​ 析构函数：回收对象时调用

​ b. 对象的finalize（）的特点

​ ① 垃圾回收机制执行时间不固定，不确定

​ ② 垃圾回收机制是自动调用，自动回收的，但是也可以手动回收，使用System.gc（）进行手动回收垃圾

​ c. JVM中，什么东西是垃圾？

​ 堆中没有引用指向的对象，称为垃圾

​ 计算没有引用的对象的算法：

​ ① 可达性分析法

​ ② 引用计数法

​ d. 内存溢出 & 内存泄漏

​ 内存溢出：内存中没有存储的位置

​ ① 方法区溢出：加载类到达内存上限

​ ② 栈溢出：无限递归调用

​ ③ 堆溢出：java堆内存不够、程序中有死循环

​ 内存泄漏：内存被无效对象或变量占用

​ ① 静态集合类

​ ② 各种连接情况，例如：数据库的连接，网络连接，IO连接

​ ③ 变量不合理的使用域

​ 结论：内存泄漏的堆积最终会导致内存溢出，也就是内存逐渐减少，从而减低程序性能

7）wait（）* 3：休眠 - 线程

8）notify / notifyAll（）：唤醒 - 线程

---

二、常用包

java.lang：基础类

​ String StringBuilder 包装类 线程类

java.util：工具类

​ Date Calendar Collection Map

java.text：格式化类

​ SimpleDateFormat

java.io：文件读写类

​ FileInputStream FileOutputStream

java.net：网络编程（TCP / IP）

java.sql：数据库相关

---

三、时间相关类

1.long类型

​ a. 获取当前系统时间

​ long time = System.currentTimeMillis();

​ b. 作用：常用来做计时，计算效率，以及简单的时间计算（七天内）

​ c. 注意：整型默认为int，超出int类型范围就会溢出，回变成负数，所以需要在计算之前先标记是long类型，添加 l / L

2.Date类型

1）概念：

​ Date表示系统特定的时间类，可以精确到毫秒值。允许把日期解释为年、月、日、小时、分钟、秒

2）创建方式：

​ a. 获取当前系统时间

​ new Date

​ b. 获取指定系统时间

​ new Date(long )

3)常用API

	boolean after(Date when)

​	boolean before(Date when)

​	date 转换成 long：

​		long time = date.getTime()

​	long 转换成 date:

​		Date date = date.setTime(long)

3.Calendar类型

1）概念：

• Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

2）作用：

​ 用于时间的推算或跳转

3）创建方式

​ Calender cal = Calender.getInstance();

4）常用API

a.和时间类转换相关方法

  Calendar -> Date
    Date date = cal.getTime();     
  Date -> Calendar
    cal.setTime(Date date);

  Calendar -> long
    long millis = cal.getTimeInMillis();
  long -> Calendar
    cal.setTimeInMillis(long);

b.时间推算与跳转
获取时间字段: get(字段)
设置时间字段: set(字段,value)
添加或者减少时间(跳转时间): add(字段,数量)

4.SimpleDateFormat类型

1）概念：

​ 一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

2）创建方式：

​ 默认：

​ SimpleDateFormat()

​ 指定：

​ SimpleDateFormat(String pattern)

3）常用API：

Date -> String
   String format(Date date)
String -> Date  
   Date parse(String source) 

---

四、大数运算类

1.BigInteger类 - 和整形相关

1)创建方式

	new BigInteger(int)

​	new BigInteger(String)

2)常用API

	BigInteger add(BigInteger val):加法

​	BigInteger subtract(BigInteger val):减法

​	BigInteger multiply(BigInteger val):乘法

​	BigInteger divide(BigInteger val):除法

2.BigDecimal类 - 和浮点型相关

1)创建方式

	new BigDecimal(double)

​	new BigDecimal(String)

2)常用API

	BigDecimal add(BigDecimal val):加法

​	BigDecimal subtract(BigDecimal val):减法

​	BigDecimal multiply(BigDecimal val):乘法

​	BigDecimal divide(BigDecimal val):除法

3)注意:

<u>**存在问题**</u>:
  在使用除法的时候有可能出现除不尽的情况,会产生ArithmeticException异常.
<u>**解决方式**</u>:
  明确规定,要保留的精度,和舍入模式
  divide(BigDecimal divisor, int scale, int roundingMode) 
  	参数1:要相除的数据
  	参数2:要保留的精度位数
  	参数3:舍入模式

---

五、包装类

1.概念：

​ 将基本数据类型封装成类的形式

2.好处：

​ 在类中可以定义多功能的方法，然后以对象调用

​ 常见方法：用于基本数据类型和字符串之间的转换

​ 例如：

​ int -> String

​ double -> String

3.基本数据类型对应の包装类：

​ byte - Byte

​ short - Short

​ int - Integer

​ long - Long

​ float - Float

​ double - Double

​ char - Character

​ boolean - Boolean

1）Integer类

a.特点:

​ ① 包装类是 final 修饰的

​ ② 包装类数值可以进行运算，但是数值不可变

​ ③ 包装类和基本数据类型使用基本一致，包装类多了一个 null

b.装箱与拆箱

​ ① 装箱：

​ int -> Integer

​ 编译器自动调用 Integer.valueOf(int)

​ ② 拆箱：

​ Integer -> int

​ 编译器自动调用 integer.intValue()

c.常量池

​ ① 常量池范围:
直接赋值的方式并且符合byte范围的整数会存储到常量池中.
byte范围(-128 ~ 127)

​ ② 注意:
基本数据类型不需要存储到常量池中,因为基本数据类型不存在引用这个说法,所以就是一个实际的值随着方法的存在而存在栈中,随着方法的消失而消失.

​ ③ 不同包装类的常量池范围
Byte、Short、Integer、Long范围：-128 ~ 127
Charater范围：0 ~ 127
Boolean范围：true和fasle都会进入常量池
Float、Double范围：都不会进入常量池

	Integer中有个静态内部类IntegerCache，里面有个cache[]，也就是Integer常量池。常量池的大小为一个字节（-128~127）。

​ 1、当赋值在这个区间时，不会创建新的Integer对象，而是从缓存中获取已经建立好的Integer对象；
​ 2、当超出这个范围时，直接new Integer来创建对象。

public static void main(String[] args) {
	Integer a1 = 127;
	Integer a2 = 127;
	Integer b1 = 128;
	Integer b2 = 128;
	System.out.println(a1 == a2);
	System.out.println(b1 == b2);
}

​ 输出：
​ true
​ false

​ 正是因为有了常量池的存在，才会出现输出结果不同的情况。

d.包装类 / 基本数据类型 <——> String

Integer -> String  
  i1.toString()
String -> Integer
  方式一: new Integer(String)
  方式二: Integer.valueOf(String)

int -> String  
  Integer.toString(int);
String -> int
  Integer.parseInt("10");

---

六、字符串类（String）

1.概述

​ String类代表字符串类，Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
​ 字符串是常量，它们的值在创建之后不能更改。
​ String存在java.lang包下，使用是不需要进行导包。

2.特点

a.字符串类是final修饰的,不可被继承的类.

b.字符串不可变,它们的值在创建之后不能更改。

c.字符串虽不可变,但是可以被共享。

d.字符串本质上就是一个字符序列(字符数组)

3.创建方式

a.直接赋值创建

​ String str = " "

b.构造方法创建

	new String():不携带任何内容

​	new String(String):通过字符串构建

​	new String(char[]):通过字符数组构建

​	new String(byte[]):通过字节数组构建,默认编码集

​	new String(byte[],charset):通过字节数组构建,指定编码集

4.常量池

a.常量池中存放的都是常量

b.只要是直接赋值的字符串,都是指向常量池

5.字符串的比较

1）==的作用:

比较基本数据类型: 比较的是具体的值

比较引用数据类型: 比较的是对象的地址值

2）equlas的作用:

专门用于比较两个对象是否相等

6.常用API

1）内存编码问题

a.编码方式

​ Java使用的字符集：Unicode字符集，在JVM中读取

​ 1 字符 = 2 字节

​ 操作系统编码：

​ UTF-8：1 字符 = 3 字节

​ GBK：1 字符 = 2 字节

b.编码&解码

​ 编码：字符 -> 字节

​ getByte(String) - 默认 utf-8 编码

​ getByte(String , “字符集”) - 指定编码方式

​ 解码：字节 -> 字符

​ new String(byte[ ]) - 默认解码方式

​ new String(byte[ ] , “字符集”) - 指定解码方式

c.乱码问题

​ ① 原因：

​ 编码与解码采用的编码集不一致

​ ② 解决：

​ 按错误的解码字符集进行编码 -> 用正确的编码字符集进行解码

---

七、可变字符串类（StringBuilder/StringBuffer)

背景：字符串不可改变，频繁拼接导致创建多对象

1.概念

​ StringBuilder / StringBuffer 属于可变长字符串（改变字符串时，不产生新对象）

​ 发行版本：

​ StringBuilder：JDK1.5

​ StringBuffer：JDK1.0

2.创建方式 - 构造方法

new StringBuilder():默认容量 - 16
new StringBuilder(int):指定容量
new StringBuilder(String):在原有的字符串基础上进行创建

3.常用API

StringBuilder append(long lng) :追加
StringBuilder delete(int start, int end) : 删除
StringBuilder insert(int offset, Object obj) : 插入
StringBuilder replace(int start, int end, String str) : 替换
StringBuilder reverse()  :反转

4.String 和 StringBuilder 和 StringBuffer 的区别

1）String：

​ String 是不可变的字符串，在拼接字符串时会产生很多无用的中间对象，这样的频繁操作会对性能有所影响

2）StringBuffer

​ StringBuilder 在 JDK1.0 出现，带有锁机制，多作用于多线程，所以线程安全，但效率比较低，解决了共同争夺一个资源的问题

3）StringBuilder：

​ StringBuilder 的出现就是为了解决上述问题，给拼接提供了一个append方法，在拼接时不会产生新的对象

​ StringBUilder 多作用于单线程，它所有方法不带锁机制（同步），所以线程不安全，但效率比较高

​ StringBuilder 在 JDK1.5 出现，取代了StingBuffer的存在

分析：

​ a. 出现的版本

​ b. 线程安全

​ c. 使用场景

​ String: 少量拼接使用

​ StringBuffer: 多线程

​ StringBuilder: 单线程

​ d.效率(从小到大排列)

---

八、正则表达式

1.概念

​ 正则表达式又称为正规表示法，在代码中一半用 regex 显示（简称 RE ）

​ 正则表达式是一种字符串的处理工具，可以对字符串进行查找，提取，分割，替换等操作

2.写法

1）字符

​ x 字符 x

​ \\ 反斜线字符

2）字符类

[ ]一个字符

[abc] a、b 或 c（简单类）

[^abc] 任何字符，除了 a、b 或 c（否定）

[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）

[a-z&&[def]] d、e 或 f（交集）

3）预定义字符类

. 任何字符（与行结束符可能匹配也可能不匹配）

\d 数字 [0-9]

\s 空白字符 [ \t\n\x0B\f\r]

\w 单词字符 [a-zA-Z_0-9]

4）数量词

?     0 或 1
*     0 或 n 
+     1 或 n
{n}   刚好出现n次
{n,}  至少 n 次 
{n,m} 至少 n 次，但是不超过 m 次 

5）边界匹配器

^ 行的开头
$ 行的结尾