Java：常用类 – 小飞侠

文章目录

1、Object类
2、Math类
3、Random类
4、File类
5、包装类
6、Date类
7、String类
- 7.1、可变字符串
- 7.2、面试问题
8、BigDecimal
9、BigInteger
10、System
11、正则表达式
12、编码表

学习视频来自于：秦疆（遇见狂神说）

Bilibili地址

他的自学网站：

kuangstudy

生活是属于每个人自己的感受，不属于任何别人的看法

1、Object类

1.1、概述

超类，基类、跟类，所有类的直接或间接父类，位于继承树的最顶层。

任何类，如果没有书写extends显示继承某个类，都默认直接继承Object，否则为间接继承。

在对象实例化的时候，最终找到的父类就是Object。

Object类提供无参构造方法，之所以提供这样的无参构造，是因为在子类对象实例化时都会默认调用父类中的无参构造方法，这样在定义类时即使没有明确定义父类为Object，读者也不会感觉代码的强制性要求。

Object类中所定义的方法，是所有对象都具备的方法。

Object类型可以储存任何对象

作为参数，可接收任何对象。

作为返回值，可返回任何对象。

1.2、hashcode（）

public native int hashCode();

返回该对象的哈希码值

哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值

一般情况下相同对象返回相同哈希码

// s1和s2对象指向不相同，hashCode不相同
s1.hashCode();
s2.hashCode();
// s1和s3对象指向相同，此时s3的hashCode与s1相同
Student s3 = s1;

如果两个对象的哈希码值不同，那这两个对象一定不等；

如果两个对象的哈希码值相同，不能确保这两个对象一定相等。

1.3、toString（）

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型 + @ + 内存地址值。

由于 toString 方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

public class Person {  
    private String name;
    private int age;
	// IDEA重写的快捷键：Alt + Insert
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    // 省略构造器与Getter Setter
}

在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

1.4、clone（）

克隆对象对应的类需要实现Cloneable接口，否则会报错：java.lang.CloneNotSupportedException

protected native Object clone() throws CloneNotSupportedException;

1.5、getClass（）

@Contract(pure = true)
public final native Class<?> getClass();

返回引用中存储的实际对象类型

应用：通常用于判断两个引用中实际存储对象类型是否一致

// 判断s1 和 s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
// getClass返回 class类型

如何获取类的字节码文件对象？

类名.class 说明： JVM将使用类装载器, 将类装入内存(前提是:类还没有装入内存),不做类的初始化工作.返回Class的对象

Class.forName(“类名字符串”) （注：类名字符串是包名+类名）说明：装入类,并做类的静态初始化，返回Class的对象

实例对象.getClass() 说明：对类进行静态初始化、非静态初始化；返回引用o运行时真正所指的对象(因为:子对象的引用可能会赋给父对象的引用变量中) 所属的类的Class的对象

1.6、notify（）

public final native void notify();

1.7、wait（）

public final native void wait(long timeout) throws InterruptedException;

public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }
        if (nanos > 0) {
            timeout++;
        }
        wait(timeout);
    }

public final void wait() throws InterruptedException {
        wait(0);
    }

1.8、equals（）

public boolean equals(Object obj) {
        return (this == obj);
 }

默认实现为(this == obj), 比较两个对象地址是否相同

可进行重写，比较两个对象的内容是否相同

// 判断两个对象是否相等
sout(s1.equals(s2)); // false

Student s4 = new Student("小明", 17);
Student s5 = new Student("小明", 17);
sout(s4.equals(s5)); // false 堆中地址不同

// 重写 改变其比较内容
/*
步骤  1. 比较两个应用是否指向同一个对象
     2. 判断obj是否为null
     3. 判断两个引用指向的实际对象类型是否一致
     4. 强制类型转换
     5. 依次比较各个属性值是否相同
*/
@override
public boolean equals(Object obj){
  // 1.
  if(this == obj){
    return true;
  }
  // 2.
  if(obj == null){
    return false;
  }
  // 3.
  // if(this.getClass() == obj.getClass()){
  //
  // }
  // instanceof 判断对象是否是某种类型
  if(obj instanceof Student){
    // 4.强制类型转换
    Student s = (Student)obj;
    // 5. 比较属性
    if(this.name.equals(s.getName()) && this.age == s.getAge()){
      return true;
    }
  }
  return false;
}

1.8、finalize（）

protected void finalize() throws Throwable { }

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列

垃圾对象：没有有效引用指向此对象时，为垃圾对象

垃圾回收：由gc销毁垃圾对象，释放数据存储空间

自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象

手动回收机制：使用System.gc();通知JVM执行垃圾回收

1.10、Objects类

在
JDK1.7
添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

public static boolean equals(Object a, Object b)
:判断两个对象是否相等。

源码

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

1.11、面试问题

说出一些你常用的方法

常覆写Object类的3个方法：toString()，equals(Object obj)，hashCode()

克隆方法或者克隆接口一些问题

克隆对象对应的类需要实现Cloneable接口，否则会报错：java.lang.CloneNotSupportedException

为什么notify()， wait()等函数定义在Object中，而不是Thread中

?

Object中的wait()，notify()等函数，和synchronized一样，会对“对象的同步锁”进行操作。

wait()会使“当前线程”等待，因为线程进入等待状态，所以线程应该释放它锁持有的“同步锁”，否则其它线程获取不到该“同步锁”而无法运行！

OK，线程调用wait()之后，会释放它锁持有的“同步锁”；而且，根据前面的介绍，我们知道：等待线程可以被notify()或notifyAll()唤醒。

现在，请思考一个问题：notify()是依据什么唤醒等待线程的？或者说，wait()等待线程和notify()之间是通过什么关联起来的？

答案是：依据“对象的同步锁”。

负责唤醒等待线程的那个线程(我们称为“唤醒线程”)，它只有在获取“该对象的同步锁”(这里的同步锁必须和等待线程的同步锁是同一个)，并且调用notify()或notifyAll()方法之后，才能唤醒等待线程。虽然，等待线程被唤醒；但是，它不能立刻执行，因为唤醒线程还持有“该对象的同步锁”。

必须等到唤醒线程释放了“对象的同步锁”之后，等待线程才能获取到“对象的同步锁”进而继续运行。

总之，notify(), wait()依赖于“同步锁”，而“同步锁”是对象锁持有，并且每个对象有且仅有一个！这就是为什么notify(), wait()等函数定义在Object类，而不是Thread类中的原因。

2、Math类

Math类都是static修饰，直接使用

成员方法	作用
abs(int a)	绝对值
ceil(double d)	向上取整
floor(double d)	向下取整
max(int a,int b)	最大值
pow(double a,double b)	a的b次幂
random()	随机数[0.0,1.0]
round(float f)	四舍五入
sqrt(double d)	算术平方根

3、Random类

为什么说Random生成的随机数是伪随机数

？

只要两个Random对象的种子相同，而且方法的调用顺序也相同，产生的随机数相同。

构造方法	作用
Random()	以当前时间毫秒值作为种子，创建Random对象
Random(long seed)	以指定种子创建Random对象

成员方法	作用
nextInt()	生成1个int类型范围的随机数
nextInt(int n)	产生1个[0,n-1]范围内的随机数

// 生成0~n之间的数
(int)Math.random()*(n+1)
// 生成0~n之间的数
Random r = new Random();
//表示生成[0,m-1]之间的随机数，也就是说random.nextInt(m+1)，将生成[0,m]之间的随机整数。
r.nextInt(m);
r.nextInt(n+1);

// 生成n~m之间的随机数
n+(int)(Math.random()*(m+1-n));
// 生成n~m之间的随机数
Random r = new Random();
r.nextInt(m+1-n)+n;

UUID

// 用于做数据库的id
String uuid = UUID.randomUUID().toString();
// 效果：39eb10ce-e8be-49f5-a44b-bfd0aa8c8135

4、File类

Java文件类以抽象的方式代表文件名和目录路径名。

该类主要用于文件和目录的创建、文件的查找和文件的删除等。

File对象代表磁盘中实际存在的文件和目录。

4.1、构造方法

通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。

File(File parent, String child);

通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。

File(String pathname);

根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(String parent, String child);

通过将给定的 file: URI 转换成一个抽象路径名来创建一个新的 File 实例。

File(URI uri)

4.2、添加文件

public boolean mkdir()

创建此抽象路径名指定的目录。

public boolean mkdirs()

创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。

4.3、查看文件

public File[] listFiles()

返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件。

4.4、修改文件

public boolean renameTo(File dest)

重新命名此抽象路径名表示的文件。

4.5、删除文件

public boolean delete()

删除此抽象路径名表示的文件或目录。

5、包装类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能。

如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

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

5.1、装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

  // 装箱， 基本类型 → 引用类型
  // 基本类型
  int num1 = 18;
  // 使用Integer类创建对象
  Integer integer1 = new Integer(num1);
  Integer integer2 = Integer.valueOf(num1);

  // 拆箱， 引用类型 → 基本类型
  Integer integer3 = new Integer(100);
  int num2 = integer3.intValue();

5.2、自动装箱拆箱

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

  int age = 30;
  // 自动装箱
  Integer integer4 = age;
  // 自动拆箱
  int age2 = integer4;

5.3、基本类型与字符串转换

  // 1. 基本类型转成字符串
  int n1 = 100;
  // 1.1 使用+号(推荐)
  String s1 = n1 + "";
  // 1.2 使用Integer中的toString()方法
  String s2 = Integer.toString(n1);
  // 1.3 x为进制要求
  String s2 = Integer.toString(n1, x); 
  
  // 2. 字符串转成基本类型
  String str = "150";
  // 2.1使用Integer.parseXXX();（推荐）
  int n2 = Integer.parseInt(str);
  // 2.2包装类型的构造器
  Integer i = new Integer("2");
  // 2.3返回保存指定的 String 的值的 Integer 对象
  Integer integer2 = Integer.valueOf(num1);
  
  // boolean 字符串形式转成基本类型，"true" ---> true 非“true ———> false
  String str2 = "true";
  boolean b1 = Boolean.parseBoolean(str2);

除了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基本类型。

注意：需保证类型兼容，否则抛出NumberFormatException异常。

5.4、整数缓冲区

Java预先创建了256个常用的证书包装类型对象
实际应用当中，对已创建的对象进行复用

  Integer integer3 = new Integer(100);// 自动装箱
  // 相当于调用 Integer.valueOf(100);
  Integer integer4 = new Integer(100);
  sout(integer3 == integer4); // true
  
  Integer integer5 = new Integer(200);// 自动装箱
  Integer integer6 = new Integer(200);
  sout(integer5 == integer6); // false
  
  // 因为缓存区数组 [-128, 127] 在这之内地址一样

6、Date类

6.1、Date

表示特定的瞬间，精确到毫秒值

构造方法
- Date():以当前时间毫秒值创建Date对象
- Date(long time):以指定的毫秒值创建Date对象，0：1970:01:01 08:00:00,小时不是0，是因为我们处于东八区
成员方法
- long getTime():获取Date对象的毫秒值
- setTime(long time):设置Data对象的毫秒值

6.2、SimpleDateFormat

将日期时间类Date转换为自定义日期时间格式(格式化)

构造方法
- SimpleDateFormat():以默认模式创建对象
- SimpleDateFormat(String pattern):以指定模式创建对象
常用的格式规则为：

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

常成员方法
- String format(Date date):格式化
- Date parse(String time):解析
  
  格式化

// 创建日期对象
Date date = new Date();
// 创建日期格式化解析对象
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 调用格式化方法
String time = format.format(date);
// 打印结果
System.out.println(time);// 结果：2022-05-10 09:46:15

解析

// 创建日期格式化解析对象
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 自定义时间
String str = "2020-05-10 09:46:15";
// 调用解析方法,返回date对象，抛出ParseException异常
Date date = format.parse(str);
// 打印结果
System.out.println(date);// 结果：Sun May 10 09:46:15 CST 2020

练习：请使用日期时间相关的API，计算出一个人已经出生了多少天。
思路：

1.获取当前时间对应的毫秒值

2.获取自己出生日期对应的毫秒值

3.两个时间相减（当前时间– 出生日期）

public static void function() throws Exception {
	System.out.println("请输入出生日期 格式 YYYY-MM-dd");
	// 获取出生日期,键盘输入
	String birthdayString = new Scanner(System.in).next();
	// 将字符串日期,转成Date对象
	// 创建SimpleDateFormat对象,写日期模式
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	// 调用方法parse,字符串转成日期对象
	Date birthdayDate = sdf.parse(birthdayString);	
	// 获取今天的日期对象
	Date todayDate = new Date();	
	// 将两个日期转成毫秒值,Date类的方法getTime
	long birthdaySecond = birthdayDate.getTime();
	long todaySecond = todayDate.getTime();
	long secone = todaySecond-birthdaySecond;	
	if (secone < 0){
		System.out.println("还没出生呢");
	} else {
		System.out.println(secone/1000/60/60/24);
	}
}

6.3、Calendar

该类是一个抽象类，不可以实例化

它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等

日历类，用于获取或者操作日历字段（年月日）

日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

成员方法
- static Calender getInstance():以默认时区和语言创建日历
- int get(int field):获取指定字段的日历值
- set(int field,int value):给指定的日历字段设置指定的值
- set(int year,int month,int date):设置年月日
- Date getTime():获取日历对象的日期
- setTime(Date d):设置日历对象的日期
- add(int field,int amount):对指定的日历字段添加指定的值

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周日为1，可以-1使用）

get/set

// 获取日历类对象
Calendar time = Calendar.getInstance();
// 获取年
int year = time.get(Calendar.YEAR);
// 获取月
int month = time.get(Calendar.MONTH);
// 获取日
int day = time.get(Calendar.DAY_OF_MONTH);
// 获取时
int hour = time.get(Calendar.HOUR_OF_DAY);
// 获取分
int minute = time.get(Calendar.MINUTE);
// 获取秒
int second = time.get(Calendar.SECOND);
// 打印结果：2022-4-10	10:3:59
System.out.println(year+"-"+month+"-"+day+"\t"+hour+":"+minute+":"+second);
 
// 更改时间
time.set(Calendar.YEAR,2003);
// 打印结果：2003-4-10	10:6:25
     }
 }

add

add方法可以对指定日历字段的值进行加减操作，如果第二个参数为正数则加上偏移量，如果为负数则减去偏移量。代码如：

import java.util.Calendar;

public class Demo08CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年1月17日
        // 使用add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, -3); // 减3年
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日; 
    }
}

getTime

Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象。

import java.util.Calendar;
import java.util.Date;

public class Demo09CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        Date date = cal.getTime();
        System.out.println(date); // Tue Jan 16 16:03:09 CST 2018
    }
}

注意：

西方星期的开始为周日，中国为周一。

在Calendar类中，月份的表示是以0-11代表1-12月。

日期是有大小关系的，时间靠后，时间越大。

6.4、Timestamp

7、String类

表示的是字符串，字符串是常量（值定义了之后，不可修改）

字符串可以看出是多个字符的连接

构造方法
- String():创建一个空的字符串
- String(byte[] bys):通过字节数组创建字符串
- String(char[] chs):通过字符数组创建字符串
- String(byte[] bys,int offset,int length):通过字节数组一部分创建字符串
- String(char[] chs,int offset,int length):通过字符数组一部分创建字符串
- String(String original):通过字符串常量值创建字符串
成员方法
- 判断功能
  - equals(Object obj):比较两个字符串是否相等
  - equalsIngnoreCase(Object obj):忽略大小写比较两个字符串是否相等
  - contains(String str):是否包含指定字符串
  - startsWith(String str):是否以指定的字符串开头
  - endWith(String str):是否以指定的字符串结尾
  - isEmpty():是否为空
  - matches(String regex):判断字符串是否匹配给定的正则表达式。
- 获取功能
  - length():获取长度
  - charAt(int index): 获取指定索引位置处的字符
  - indexOf(int ch):获取指定字符第一次出现的索引值(从0开始)
  - indexOf(int ch,int fromIndex):获取从指定索引位置开始，获取指定字符第一次出现的索引值
  - indexOf(String s):获取指定字符串第一次出现的索引值
  - indexOf(String s,int fromIndex):获取从指定索引位置开始，获取指定字符串第一次出现的索引值
  - lastIndexOf(int ch):获取指定字符最后一次出现的索引值
  - substring(int start):从指定位置开始一直截取到末尾
  - substring(int start,int end):截取[start,end-1]范围
- 转换功能
  - byte[] getBytes():将字符串转成字节数组
  - char[] toCharArray():将字符串转成字符数组
  - static valueOf(char[] chs):将char[]转成字符串
  - static valueOf(int num):将int类型转成字符串
  - static valueOf(Object obj):将任意类型转成字符串
  - toLowerCase():转成小写
  - toUpcase():转成大写
  - concat(String str):字符连接
- 其他功能
  - replace(char old,char new):将old字符替换成new字符
  - replace(String old,String new):将old字符串替换成new字符串
  - trim():去除两边空格
  - int compareTo(String s):字典比较，如果前面值小于后面值返回负数，否则返回正数，先比较第一个元素，如果相等再比较第二个元素…返回元素之间的差值；如果比较字符串有包含关系，返回的值是它们长度的差值
  - int compareToIgnoreCase(String s):忽略大小写字典比较
  - String replaceAll(String regex, String replacement):使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
  - String replaceFirst(String regex, String replacement):使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
  - String[] split(String regex): 根据给定正则表达式的匹配拆分此字符串。
  - String[] split(String regex, int limit): 根据匹配给定的正则表达式来拆分此字符串。

/*
* 字符串做连接操作
* 如果是两个变量进行连接，先开辟空间，再连接
* 如果是两个常量进行连接，先连接，获取连接结构值。然后在常量池里面查找有没有这个结果值，如果有，直接给地址值；没有，开辟空间
*/
public class StringTest02 {
	public static void main(String[] args) {
	String s1 = "hello";
	String s2 = "world";
	String s3 = "helloworld";

	System.out.println(s3 == s1+s2); //false
	System.out.println(s3.equals(s1+s2)); //true

	System.out.println(s3 == "hello"+"world"); //true
	System.out.println(s3.equals("hello"+"world")); //true
	}
}

练习

// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串

String content = "java是最好的语言, java no1";
sout(content.length()); // 10
sout(content.charAt(content.length() - 1)); // 言
sout(content.contains("java")); // true

// 4. toCharArray(); 返回字符串对应数组 
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置

sout(content.toCharArray());
sout(content.indexOf"java")); // 0
sout(content.indexOf("java", 4)); // 从索引4开始找 返回12
sout(content.lastIndexOf("java")); // 12

// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str);  判断是否以str 结尾、开头

String ct = " hello world ";
sout(ct.trim()); // "hello world"
sout(ct.toUpperCase()); // HELLO WORLD
sout(ct.toLowerCase()); // hello world
sout(ct.endWith("world")); // true
sout(ct.startWith("hello")) // true
  
// 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分

sout(content.replace("java", "php")); // php是最好的语言, php no1

String say = "java is the best language";
String[] arr = arr.say.split(" "); // "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
sout(arr.length); // 5
for(String string : arr){
  sout(string);
}
// 打印出 
//java
//is
//the 
//best
//language

// 补充两个equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
sout(s1.equalsIgnoreCase(s2));// 忽略大小写比较true

// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值

7.1、可变字符串

StringBuffer：多线程数据量多使用，线程安全

StringBuider：单线程数据量较多使用，线程不安全

效率都比String高且节省内存

构造方法
- StringBuilder():以默认容量创建空的StringBuilder对象
- StringBuilder(int capacity):以指定容量创建空的StringBuilder对象
- StringBuilder(String str):以指定的字符串创建StringBuilder对象
成员方法
- 获取功能
  - int capacity():获取容量
  - int length():获取长度
- 添加功能
  - append(int value):追加。可以追加多种类型
  - insert(int offset,String s):在指定的位置插入指定数据
- 删除功能
  - deleteCharAt(int index):删除指定索引处的元素
  - delete(int start,int end):删除[start,start-1]范围内的元素
- 替换功能
  - replace(int start,int end,String s):将[start,end-1]范围内的元素替换成指定字符串
- 反转功能
  - reverse():元素反转
- 截取功能
  - String subString(int start):截取指定位置一直到末尾
  - String subString(int start,int end):截取[start,end-1]范围

  // StringBuffer 和 StringBuilder 用法一致
  StringBuffer sb = new StringBuffer();
  // 1. append(); 追加
  sb.append("java no1");
  // 2. insert(); 添加、插入
  sb.insert(0, "在第一个位置插入");
  // 3.replace(); 替换
  sb.replace(0, 9, str); // 左闭右开
  // 4. delete(); 删除
  sb.delete(0, 5); // 左闭右开
  // 5. 清空
  sb.delete(0, sb.length());

7.2、面试问题

String、StringBuilder和StringBuffer的区别？

String内容不可改变
StringBuilder和StringBuffer内容可变
StringBuilder是线程不安全的，不同步，效率高
StringBuffer是线程安全的，同步，效率低

8、BigDecimal

位于
java.math.BigDecimal
,不可变的、任意精度的有符号十进制数。(精确的十进制小数)

用于金融行业浮点数计算

构造方法

BigDecimal(String s):通过字符创建BigDecimal对象
成员方法

add(BigDecimal bi):+

subtract(BigDecimal bi):-

multiply(BigDecimal bi)😗

divide(BigDecimal bi, x, BigDecimal.ROUND_HALF_UP)😕

// 参数一
BigDecimal b1 = new BigDecimal(1.0);
// 参数er
BigDecimal b2 = new BigDecimal(0.9);
// 结果
BigDecimal sum = null;
// 加
sum = b1.add(b2);
System.out.println("1.0 + 0.9 = " + sum);
// 减
sum = b1.subtract(b2);
System.out.println("1.0 - 0.9 = " + sum);
// 乘
sum = b1.multiply(b2);
System.out.println("1.0 * 0.9 = " + sum);
// 除 除不尽时 x填保留位数 后面为四舍五入之意
sum = b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP);
System.out.println("1.0 / 0.9 = " + sum);

9、BigInteger

位于
java.math.BigInteger
，不可变的任意精度的整数。

构造方法
- BigInteger(String s):通过字符串创建BigInteger对象
成员方法
- add(BigInteger bi):+
- subtract(BigInteger bi):-
- multiply(BigInteger bi)😗
- divide(BigInteger bi)😕

10、System

System类代表当前Java程序的运行平台，程序不能创建System类的对象， System类提供了一些类变量和类方法，允许直接通过System类来调用这些类变量和类方法。

没有构造方法
成员方法
- currentTimeMills():获取当前时间毫秒值
- exit(int status):退出JVM，0表示非异常退出
- gc():运行垃圾回收处理机制（系统会在某个不确定的时间调用该方法），会调用finalize()，进行垃圾回收
- getProperty(String key):获取指定键指示的系统属性
- arrayCopy(Object[] srcArr,int srcPos,Object[] desArr,int destPos,int len):数组复制

11、正则表达式

负责字符串的匹配处理（一般用于校验字符串格式）

规则

字符

```
x:x字符，a表a字符
```
```
\\:反斜线字符
```
```
\n:换行符
```
```
\r:回车符
```

字符类

[abc]:表示a、b、c中的一个字符

[^abc]:表示除了a、b、c之外的任意一个字符

[a-zA-Z]:表示a~z或A~Z中的一个字符

```
[0-9]:表示数字
```

预定义字符类

```
.:表示任意字符
```
```
\.:表示'.'字符
```
```
\d:表示数字字符，[0-9]
```
```
\w:表示单词字符，[a-zA-Z_0-9]
```

边界匹配器

```
^:表示行的开头
```
```
$:表示行的结尾
```
```
\b:表示单词的边界
```

数量词

```
?:表示0次或者1次
```
```
*:表示0次或者多次
```
```
+:表示1次或者多次
```
```
{n}:表示n次
```
```
{n,}：表示至少n次
```
```
{n,m}:n~m次
```

12、编码表

编码表：由现实世界的字符和对应的数值组成的一张表

常见的有：

ASCII码：最高为是符号为，其他是数值位
ISO-8859-1：拉丁码表
BG2312：中文编码表
GBK：GB2312的升级版，1个汉字对应2个字节
GB18030：GBK的升级版
BIG-5：中文繁体编码表，俗称”大5码”
Unicode：国际标注码。所有字符都有两个字节表示

Java默认使用该编码表
- UTF-8：万国码，一个汉字对应3个字节

tips：所有编码表都兼容ASCII码表

String中与字符集相关的方法
- String(byte[] by,String charset):通过指定的字符集，将指定的字节数组转成字符串(解码)
- byte[] getBytes(String charset):通过指定的字符集，将字符串转成字节数组（编码）

原文链接：https://blog.csdn.net/zhao854116434/article/details/124653001