文章目录
Java 常用类
一、包装类
（一）概念
基本数据类型不是对象，不能使用类的方法。因此，java针对基本数据类型提供了它们相应的包装类。八大基本数据类型，对应了八种包装类，以对象的形式来调用。包装类有了类的特点，使我们可以调用包装类中的方法。
包装类属于java.base模块，java.lang包下。在形式上，除了Integer和Character这两个包装类外，其他六个包装类的类名均是对应的基本数据类型首字母大写后得到的。
（二）装箱和拆箱
（1）概念
1.装箱
基本类型 —> 包装类型（或者叫对象类型、引用类型）
2.拆箱
包装类型 —> 基本类型
（2）手动拆装箱
JDK5.0之前，拆装箱均是手动完成的。
手动装箱，可以使用包装类的构造器来完成，也可以使用valueOf()方法。
手动拆箱，以Integer类为例，需要用到intValue()方法。
示例
以Integer包装类为例，代码如下：
public class Test {
public static void main(String[] args) {
int temp = 19;
//手动装箱（基本类型 ---> 包装/引用类型）
Integer i0 = new Integer(temp);
Integer i1 = new Integer(11);
Integer i2 = Integer.valueOf(temp);
//手动拆箱（包装/引用类型 ---> 基本类型）
int tempInt = i0.intValue();
System.out.println("-----------------");
System.out.println("i0:" + i0);
System.out.println("i1:" + i1);
System.out.println("i2:" + i2);
System.out.println("tempInt:" + tempInt);
System.out.println("-----------------");
}
}
（3）自动拆装箱
JDK5.0开始，Java提供了自动拆装箱的机制。（不需要手动调用构造器或者方法了）
1.自动拆箱
实际上底层仍然调用了valueOf()方法。
2.自动装箱
实际上底层仍然调用了intValue()方法（此处是以Integer包装类为例）。
示例
public class Test {
public static void main(String[] args) {
//自动装箱
//我们看似是直接把一个int数据赋给了Integer包装类
//实际上Java在底层仍然帮我们调用了valueOf()方法
Integer i = 199;
//自动拆箱
//看似是直接把一个Integer包装类赋值给了int变量
//实际上Java在底层仍然帮我们调用了intValue()方法
int tempInt = i;
System.out.println("-------------------");
System.out.println("i:" + i);
System.out.println("tempInt:" + tempInt);
System.out.println("-------------------");
}
}
3.一个比较特殊的情况
关于valueOf()方法，Integer类中的valueOf()方法源码如下：
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCode.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
注意，这里的valueOf()方法中有一个if条件语句的判断，它的意思是，如果传入的int基本类型的值在这个范围内，我就不new新的Integer对象，而是调用底层的缓冲数组。通过追溯源码，我们可以得知这里的low和high的实际范围是-128 ~ 127。
（三）八大包装类的常用成员方法
1.Byte类
//Byte类常用方法
public class ByteTest {
public static void main(String[] args) {
//1.byte byteValue(): 返回当前Byte对象对应的值，以byte类型作接收
Byte b = 127; //自动装箱
byte bb = b.byteValue();
System.out.println("byte类型变量bb = " + bb);
System.out.println("----------------------");
//2.static int compare(byte x, byte y):比较两个byte变量的值，返回值为前面byte变量的值减去后面byte变量的值
byte b0 = 5;
byte b1 = 1;
int i = Byte.compare(b0, b1);
System.out.println("b0 - b1:" + i);
System.out.println("----------------------");
//3.int compareTo(Byte anotherByte):比较两个Byte类对象的值，返回值同方法2
Byte B0 = 55;
Byte B1 = 11;
int i1 = B0.compareTo(B1);
System.out.println("B0 - B1:" + i1);
System.out.println("----------------------");
//4.double doubleValue():与方法1同理
double bb1 = b.doubleValue();
System.out.println("double类型变量bb1=" + bb1);
System.out.println("----------------------");
//5.int intValue():与方法1同理
int bb2 = b.intValue();
System.out.println("int类型变量bb2=" + bb2);
System.out.println("----------------------");
//6.static int parseByte(String xxx):字符串类型 --> byte类型
byte b2 = Byte.parseByte("1");
System.out.println("byte类型变量b2=" + b2);
System.out.println("----------------------");
//7.String toString():将当前byte对象的值转换为String类型
Byte B2 = 127;
String str0 = B2.toString();
System.out.println("Byte类型对象B2的字符串形式为：" + str0);
System.out.println("----------------------");
//8.static String toString(byte b):将指定的byte值转换为String对象
byte b3 = 2;
String str1 = Byte.toString(b3);
System.out.println("byte类型变量b3的字符串形式为：" + str1);
System.out.println("----------------------");
//9.static Byte valueOf(...):转Byte类型
Byte B3 = Byte.valueOf("11");
System.out.println("Byte类型对象B3的值=" + B3);
}
}
2.Short类
//Short类常用方法
public class ShortTest {
//1.short shortValue():返回当前Short对象的值，以short基本类型作接收
Short S0 = 128; //自动装箱
short s0 = S0.shortValue();
System.out.println("short类型变量s0=" + s0);
//另：int intValue()
//另：double doubleValue()
//...等方法，同方法1的用法、原理相同
System.out.println("----------------------");
//2.static int compare(short x, short y):比较两个short变量的值，返回值为前面short变量的值减去后面short变量的值
short s1 = 6;
short s2 = 3;
int i = Short.compare(s1, s2);
System.out.println("s1 - s2 = " + i);
System.out.println("----------------------");
//3.int compareTo(Short anotherShort):比较两个Short类对象的值，返回值同方法2
Short S1 = 66;
Short S2 = 33;
int i1 = S1.compareTo(S2);
System.out.println("S1 - S2 = " + i1);
System.out.println("----------------------");
//4.static short parseShort(String xxx):字符串类型 --> short基本类型
short s3 = Short.parseShort("128");
System.out.println("short类型变量s3 = " + s3);
System.out.println("----------------------");
//5.String toString():将当前Short对象的值转换为String类型
Short S3 = 1277;
String str0 = S3.toString();
System.out.println("Short类型对象S3的字符串形式为：" + str0);
System.out.println("----------------------");
//6.static String toString(short s):将指定的short值转换为String对象
short s4 = 2;
String str1 = Short.toString(s4);
System.out.println("Short类型变量s4的字符串形式为：" + str1);
System.out.println("----------------------");
//7.static Short valueOf(...):转Short类型
Short S4 = Short.valueOf("1111");
System.out.println("Short类型对象S4的值 = " + S4);
}
3.Integer类
//Integer类常用方法
public class IntegerTest {
public static void main(String[] args) {
//1.int intValue():返回当前Integer对象的值，以int基本类型作接收
Integer I0 = 1280; //自动装箱
int i0 = I0.intValue();
System.out.println("int类型变量i0 = " + i0);
//另：double doubleValue()
//...等方法同方法1的原理、用法相同
System.out.println("----------------------");
//2.static int compare(int x, int y):比较两个int变量的值，如果前一个数大，返回1；如果前一个数小，返回-1；相等返回0
int i1 = 7;
int i2 = 11;
int i = Integer.compare(i1, i2);
System.out.println("i1与i2比较的结果：" + i);
System.out.println("----------------------");
//3.int compareTo(Integer anotherInteger):比较两个Integer对象的值，返回值同方法2
Integer I1 = 77;
Integer I2 = 11;
int i1 = I1.compareTo(I2);
System.out.println("I1与I2比较的结果：" + i1);
System.out.println("----------------------");
//4.static int parseInt(String xxx):字符串类型 --> int基本类型
int i3 = Integer.parseInt("4444");
System.out.println("int类型变量i3 = " + i3);
System.out.println("----------------------");
//5.String toString():将当前Integer对象的值转换为String类型
Integer I3 = 11217;
String str0 = I3.toString();
System.out.println("Integer类型对象I3的字符串形式为：" + str0);
System.out.println("----------------------");
//6.static String toString(int s):将指定的int值转换为String对象
int i4 = 111111;
String str1 = Integer.toString(i4);
System.out.println("int类型变量i4的字符串形式为：" + str1);
System.out.println("----------------------");
//7.static Integer valueOf(...):转Integer类型
Integer I4 = Integer.valueOf("111");
System.out.println("Integer类型对象I4的值 = " + I4);
System.out.println("----------------------");
//8.static int max(int x, int y) 和 min(int x, int y):获取两个数中的最大值或最小值
System.out.println("100和101哪个数更大？" + Integer.max(100, 101));
System.out.println("200和201哪个数更小？" + Integer.min(200, 201));
System.out.println("----------------------");
//9.static int sum(int x, int y):返回(x + y)的值
System.out.println("100 + 201 = " + Integer.sum(100, 201));
}
}
4.Long类
//Long类常用方法
public class LongTest {
public static void main(String[] args) {
//1.long longValue():返回当前Long对象的值，以long基本类型作接收
Long L0 = 2224L; //自动装箱
long l0 = L0.longValue();
System.out.println("long类型变量l0 = " + l0);
//另：int intValue()
//另：double doubleValue()
//...等方法同方法1原理、用法相同
System.out.println("----------------------");
//2.static int compare(long x, long y):比较两个long变量的值，如果前一个数大，返回1；如果前一个数小，返回-1；相等则返回0
long l1 = 222L;
long l2 = 111L;
int i = Long.compare(l1, l2);
System.out.println("l1与l2比较的结果：" + i);
System.out.println("----------------------");
//3.int compareTo(Long anotherLong):比较两个Long对象的值，返回值同方法2
Long L1 = 773L;
Long L2 = 113L;
int i1 = L1.compareTo(L2);
System.out.println("L1和L2比较的结果：" + i1);
System.out.println("----------------------");
//4.static long parseLong(String xxx):字符串类型 --> long基本类型
long l3 = Long.parseLong("35252");
System.out.println("long类型变量l3 = " + l3);
System.out.println("----------------------");
//5.String toString():将当前Long对象的值转换为String类型
Long L3 = 11217L;
String str0 = L3.toString();
System.out.println("Long类型对象L3的字符串形式为：" + str0);
System.out.println("----------------------");
//6.static String toString(long l):将指定的long值转换为String对象
long l4 = 22222;
String str1 = Long.toString(l4);
System.out.println("long类型变量l4的字符串形式为：" + str1);
System.out.println("----------------------");
//7.static Long valueOf(...):字符串类型 --> Long类型
Long L4 = Long.valueOf("111241");
System.out.println("Long类型对象L4的值 = " + L4);
System.out.println("----------------------");
//8.static long max(long x, long y) 和 min(long x, long y):获取两个数中的最大值或最小值
System.out.println("10000和10100哪个数更大？" + Long.max(10000, 10100));
System.out.println("20000和20100哪个数更小？" + Long.min(20000, 20100));
System.out.println("----------------------");
//9.static long sum(long x, long y):返回(x + y)的值
System.out.println("111111 + 888889 = " + Long.sum(111111, 888889));
}
}
5.Character类
//Character类常用方法
public class CharacterTest {
//1.装箱拆箱：valueOf() 和 charValue()
Character C0 = Character.valueOf('S');
char c0 = C0.charValue();
System.out.println("Character类对象C0的字符是：" + C0);
System.out.println("char基本类型变量c0 = " + c0);
System.out.println("----------------------");
//2.static int compare(char x, char y):返回前面字符ASCII码值 - 后面字符ASCII码值
int i1 = Character.compare('A', 'F');
System.out.println("ASCII码值'A' - 'F' = " + i1);
System.out.println("----------------------");
//3.int compareTo(Character anotherCharacter):比较两个Character类对象的字符，返回值同方法2
Character C1 = 'a'; //自动装箱
Character C2 = 'd';
int i2 = C1.compareTo(C2);
System.out.println("C1 - C2 = " + i2);
System.out.println("----------------------");
//4.static boolean isDigit(char c1):判断该字符是不是数字
//5.static boolean isLetter(char c2):判断该字符是不是字母
//6.static boolean isUpperCase(char c3):判断该字符是不是大写形式
//7.static boolean isLowerCase(char c4):判断该字符是不是小写形式
//8.static boolean isWhiteSpace(char c5):判断该字符是不是空格
System.out.println("\'A\'是不是数字 : " + Character.isDigit('A'));
System.out.println("\'A\'是不是字母 : " + Character.isLetter('A'));
System.out.println("\'A\'是不是大写形式 : " + Character.isUpperCase('A'));
System.out.println("\'A\'是不是小写形式 : " + Character.isLowerCase('A'));
System.out.println("\'A\'是不是空格 : " + Character.isWhitespace('A'));
System.out.println("-------------------");
//9.static char toUpperCase(char c):将该字符转换为大写形式，以char类型作接收
//10.static char toLowerCase(char c):将该字符转换为小写形式，以char类型作接收
char c1 = Character.toUpperCase('n');
char c2 = Character.toLowerCase('B');
System.out.println("\'n\'字符的大写形式为：" + c1);
System.out.println("\'B\'字符的小写形式为：" + c2);
}
6.Float类
//Float类常用方法
public class FloatTest {
public static void main(String[] args) {
//1.float floatValue():返回当前Float对象的值，以float基本类型作接收
Float F0 = 1024.11F; //自动装箱
float f0 = F0.floatValue();
System.out.println("float类型变量f0 = " + f0);
//另：int intValue()
//另：double doubleValue()
//...等方法同方法1用法、原理一样
System.out.println("-------------------");
//2.static int compare(float x, float y):比较两个float变量的值，如果前一个数大，返回1；如果前一个数小，返回-1；相等返回0
float f1 = 222.11F;
float f2 = 222.11F;
int i = Float.compare(f1, f2);
System.out.println("f1与f2比较的结果：" + i);
System.out.println("-------------------");
//3.int compareTo(Float anotherFloat):比较两个Float对象的值，返回值同方法2
Float F1 = 222.11F;
Float F2 = 123.11F;
int i1 = F1.compareTo(F2);
System.out.println("F1与F2比较的结果：" + i1);
System.out.println("-------------------");
//4.static float parseFloat(String xxx):字符串类型 --> float基本类型
float f3 = Float.parseFloat("35252.11125");
System.out.println("float类型变量f3 = " + f3);
System.out.println("-------------------");
//5.String toString():将当前Float对象的值转换为String类型
Float F3 = 12144217.12F;
String str0 = F3.toString();
System.out.println("Float类型对象F3的字符串形式为：" + str0);
System.out.println("-------------------");
//6.static String toString(float f):将指定的float值转换为String对象
float f4 = 22222.11F;
String str1 = Float.toString(f4);
System.out.println("float类型变量f4的字符串形式为：" + str1);
System.out.println("-------------------");
//7.static float valueOf(...):转float类型
Float F4 = Float.valueOf("111241.1235");
System.out.println("Float类型对象F4的值 = " + F4);
System.out.println("-------------------");
//8.static float max(float x, float y) 和 min(float x, float y):获取两个数中的最大值 或 最小值
System.out.println("10000.00 和 10100.11，哪个数更大？" + Float.max(10000.00F, 10100.11F));
System.out.println("200.00 和 201.88，哪个数更小？" + Float.min(200.00F, 201.88F));
System.out.println("-------------------");
//9.static float sum(float x, float y):返回(x + y)的值
System.out.println("11111.11 + 8889.022 = " + Float.sum(11111.11F, 8889.022F));
}
}
7.Double类
//Double类常用方法
public class DoubleTest {
public static void main(String[] args) {
//1.double doubleValue():返回当前Double对象的值，以double基本类型作接收
Double D0 = 1024.5; //自动装箱
double d0 = D0.doubleValue();
System.out.println("double类型变量d0 = " + d0);
//另：int intValue()
//另：double doubleValue()
//...等方法同方法1用法、原理相同
System.out.println("-------------------");
//2.static int compare(double x, double y):比较两个double变量的值，如果前一个数大，返回1；如果前一个数小，返回-1；相等返回0
double d1 = 888.88;
double d2 = 888.88;
int i = Double.compare(d1, d2);
System.out.println("d1和d2比较的结果：" + i);
System.out.println("-------------------");
//3.int compareTo(Double anotherDouble):比较两个Double类对象的值，返回值同方法2
Double D1 = 123.1234;
Double D2 = 1234.123;
int i1 = D1.compareTo(D2);
System.out.println("D1和D2比较的结果：" + i1);
System.out.println("-------------------");
//4.static double parseDouble(String xxx):字符串类型 --> double基本类型
double d3 = Double.parseDouble("35252.11125");
System.out.println("double类型变量d3 = " + d3);
System.out.println("-------------------");
//5.String toString():将当前Double对象的值转换为String类型
Double D3 = 3333144217.12;
String str0 = D3.toString();
System.out.println("Double类型对象D3的字符串形式为：" + str0);
System.out.println("-------------------");
//6.static String toString(double d):将指定的double值转换为String对象
double d4 = 233.333333;
String str1 = Double.toString(d4);
System.out.println("double类型d4的字符串形式为：" + str1);
System.out.println("-------------------");
//7.static double valueOf(...):转double类型
Double D4 = Double.valueOf("66666.1235");
System.out.println("Double类型对象D4的值：" + D4);
System.out.println("-------------------");
//8.static double max(double x, double y) 和 min(double x, double y)
System.out.println("134.23 和 111.11，哪个数更大？" + Double.max(134.23, 111.11));
System.out.println("222.111 和 111.222，哪个数更小？" + Double.min(222.111, 111.222));
System.out.println("-------------------");
//9.static double sum(double x, double y):返回(x + y)的值
System.out.println("11111.11 + 8889.022 = " + Double.sum(11111.11, 8889.022));
}
}
8.Boolean类
//Boolean类常用方法
public class BooleanTest {
public static void main(String[] args) {
//1.boolean booleanValue():返回当前Boolean对象的值，以boolean基本类型作接收
Boolean B0 = true; //自动装箱
boolean b0 = B0.booleanValue();
System.out.println("boolean类型变量b0 = " + b0);
System.out.println("-------------------");
//2.static int compare(boolean x, boolean y):比较两个boolean变量的值，两个变量真值相同返回0，否则返回值取决于传入第一个boolean变量的真值，true返回1，false返回-1
boolean b1 = false;
boolean b2 = true;
int i = Boolean.compare(b1, b2);
int ii = Boolean.compare(b2, b1);
int iii = Boolean.compare(b2, b2);
System.out.println("b1与b2的比较结果为：" + i);
System.out.println("b2与b1的比较结果为：" + i);
System.out.println("b2与b2的比较结果为：" + i);
System.out.println("-------------------");
//3.int compareTo(Boolean anotherBoolean):比较两个Boolean类对象的值，返回值同方法2
Boolean B1 = false;
Boolean B2 = false;
int i1 = B1.compareTo(B2);
System.out.println("B1和B2的比较结果为：" + i1);
System.out.println("-------------------");
//4.static int parseBoolean(String xxx):字符串类型 ---> boolean基本类型
boolean b3 = Boolean.parseBoolean("666");
System.out.println("boolean类型变量b3 = " + b3);
System.out.println("-------------------");
//5.String toString():将当前Boolean对象的值转换为String类型
Boolean B3 = false;
String str0 = B3.toString();
System.out.println("Boolean类型对象B3的字符串形式为：" + str0);
System.out.println("-------------------");
//6.static String toString(boolean b):将指定的boolean值转换为String对象
boolean b4 = true;
String str1 = Boolean.toString(b4);
System.out.println("boolean类型变量b4的字符串形式为：" + str1);
System.out.println("-------------------");
//7.static Boolean valueOf(...):转Boolean类型
Boolean B4 = Boolean.valueOf("false");
System.out.println("Boolean类型对象B4的值 = " + B4);
}
}
二、String类
（一）概念
不同于C语言中的字符数组，在Java中，String类就是一种符合面向对象思想的字符串类。
String类是不可变的，这意味着一旦创建了一个字符串对象，就不能修改其内容。每当对字符串进行修改操作时，实际上是创建了一个新的字符串对象。这种设计是为了确保字符串的不可变性，以提高性能和安全性。因此如果在频繁的字符串拼接或修改场景中，建议使用StringBuilder类或StringBuffer类，它们提供了可变的字符串操作方法，可以避免不必要的对象创建。
（二）构造方法
String类提供了多个构造方法来创建字符串对象。
1.String()：创建一个空字符串对象
String str = new String();
2.String(String original)：通过将指定的字符串复制一份来创建一个新的字符串对象
String str = new String("Hello");
3.String(char[] value)：通过字符数组创建一个新的字符串对象
char[] chars = {'H', 'e', 'l', 'l', 'o'};
String str = new String(chars);
4.String(char[] value, int offset, int count)：通过字符数组的指定部分创建一个新的字符串对象，offset表示起始索引，count表示要复制的字符数量
char[] chars = {'H', 'e', 'l', 'l', 'o'};
String str = new String(chars, 1, 3); //输出："ell"
5.String(byte[] bytes)：通过字节数组创建一个新的字符串对象，使用默认的字符集编码字节数组
byte[] bytes = {72, 101, 108, 108, 111};
String str = new String(bytes); //输出："Hello"
6.String(byte[] bytes, int offset, int length)：通过字节数组的指定部分创建一个新的字符串对象，使用默认的字符集解码字节数组。offset表示起始索引，length表示要复制的字节数量
byte[] bytes = {72, 101, 108, 108, 111};
String str = new String(bytes, 1, 3); //输出："ell"
7.直接赋值：通过直接赋值一个常量字符串来创建一个新的字符串对象
String str = "Hello";
注意：
1）String类型是引用类型，内部储存的并不是字符串本身，还有其他内容。
2）在Java中使用""引起来的字符串也是String类型对象。
（三）常用方法
（1）String类对象之间的比较
1.使用equals()方法
equals()方法用于比较两个字符串的内容是否相等。它是在Object类中定义的，因此所有的Java对象都可以使用该方法。在String类中，equals()方法已经被重写，以便比较字符串的内容而不是引用。
2.使用compareTo()方法
compareTo()方法用于比较两个字符串的大小关系。它是在Comparable接口中定义的，String类实现了Comparable接口，因此可以使用该方法进行比较。compareTo()方法返回一个整数值，表示字符串之间的比较结果。
如果返回值为负数，表示当前字符串小于被比较字符串；
如果返回值为0，表示两个字符串相等；
如果返回值为正数，表示当前字符串大于被比较字符串。
3.使用equalsIgnoreCase()方法
equalsIgnoreCase()方法用于比较两个字符串的内容是否相等，但忽略大小写。
4.使用==运算符
==运算符用于比较两个字符串对象的引用是否相等。它判断两个字符串对象是否指向同一个内存地址。如果两个字符串对象引用的是同一个对象，则返回true，否则返回false。
需要注意的是，对于字符串的比较，通常使用equals()方法进行内容比较，而不是使用==运算符，因为==运算符比较的是对象的引用，而不是内容。只有在比较字符串的引用时才会使用==运算符。
（2）字符串查找
String类提供了多个用于字符串查找的方法。
1.indexOf(String str)：返回指定子字符串在原字符串中第一次出现的索引位置。如果找不到子串，则返回-1。
2.indexOf(String str, int fromIndex)：从指定的起始索引位置开始，在原字符串中查找指定子字符串的第一次出现位置。
3.lastIndexOf(String str)：返回指定子字符串在原字符串中最后一次出现的索引位置。如果找不到子字符串，则返回-1。
4.lastIndexOf(String str, int fromIndex)：从指定的起始索引位置开始，从后往前在原字符串中查找指定子字符串的最后一次出现位置。
5.startsWith(String prefix)：检查原字符串是否以指定的前缀开头，返回布尔值。
6.endsWith(String suffix)：检查原字符串是否以指定的后缀结尾，返回布尔值。
7.charAt(int index)：返回index位置处的字符，如果index为负数或者越界，抛出IndexOutOfBoundsException异常。
（3）字符串转换
String类提供了多个用于字符串转换的方法。
1.toCharArray()：将字符串转换为字符数组，返回一个新的char[]数组。
2.getBytes()：将字符串转换为字节数组，使用默认的字符集编码。
3.toLowerCase()：将字符串中的所有字符转换为小写形式，返回一个新的字符串。
4.toUpperCase()：将字符串中的所有字符转换为大写形式，返回一个新的字符串。
5.trim()：去除字符串开头和结尾的空白字符（空格、制表符、换行符等），返回一个新的字符串。
6.valueOf()：将其他类型的数据转换为字符串。valueOf()是一个静态方法， 可以通过类名直接调用。它接受不同类型的参数，包括基本数据类型和对象类型，返回相应类型的字符串表示。
（4）字符串替换
String类提供了多个用于字符串替换的方法。
1.replace(char oldChar, char newChar)：将字符串中所有的指定字符oldChar替换为新的字符newChar，并返回替换后的新字符串。
2.replace(CharSequence target, CharSequence replacement)：将字符串中所有的指定子字符串target替换为新的子字符串replacement，并返回替换后的新字符串。CharSequence是一个接口，String类实现了该接口，因此可以接收字符串作为参数。
3.replaceAll(String regex, String replacement)：使用正则表达式regex匹配字符串中的内容，并将匹配到的部分替换为指定的字符串replacement，并返回替换后的新字符串。正则表达式可以用于更复杂的模式匹配和替换。
4.replaceFirst(String regex, String replacement)：使用正则表达式regex匹配字符串中的第一个匹配项，并将其替换为指定的字符串replacement，并返回替换后的新字符串。
（5）字符串拆分
String类提供了多个用于字符串拆分的方法。
1.split(String regex)：根据正则表达式regex将字符串拆分成子字符串数组，并返回拆分后的结果。拆分时将字符串按照匹配正则表达式的部分进行分割。
2.split(String regex, int limit)：根据正则表达式regex将字符串拆分成子字符串数组，并返回拆分后的结果。拆分时将字符串按照匹配正则表达式的部分进行分割。limit参数指定了拆分的限制，即最多拆分出多少个子字符串。如果超过限制，剩余的部分将作为最后一个元素包含在结果中。
（6）字符串截取
String类提供了多个用于字符串截取的方法。
1.substring(int beginIndex)：从指定的索引位置开始截取字符串，截取从beginIndex到字符串末尾的部分，并返回截取后的新字符串。
2.substring(int beginIndex, int endIndex)：截取字符串中从beginIndex开始到endIndex（不包括endIndex）之间的部分，并返回截取后的新字符串。
（四）字符串常量池
字符串常量池是Java中的一种特殊存储区域，用于存储字符串常量。在Java中，字符串是不可变的，即创建后不能被修改。为了提高性能和节省内存空间，Java使用了字符串常量池来共享字符串常量对象。
当我们创建一个字符串常量时（例如，使用双引号括起来的字符串字面值），Java会首先检查字符串常量池中是否存在相同值的字符串。如果存在，则返回常量池中的引用，而不会创建新的对象。这样可以避免重复创建相同内容的字符串，节省了内存空间。
在Java中，字符串常量池位于堆内存中的特殊区域，与其他对象的存储不同。可以通过调用intern()方法来将一个字符串对象添加到字符串常量池中，或者获取字符串常量池中相同值的字符串对象的引用。intern()方法会返回字符串常量池中的引用，如果常量池中已经存在相同值的字符串，则直接返回该引用。
例如，下面的代码中，通过intern()方法将字符串对象添加到字符串常量池中，并且后续的字符串对象通过==进行比较时，将返回true。
String str1 = new String("Hello").intern();
String str2 = new String("Hello");
System.out.println(str1 == str2); //输出：true
需要注意的是，字符串常量池中的字符串是不可变的，一旦创建就不能修改。如果对字符串进行修改操作，将会创建新的字符串对象，而不会在常量池中进行修改。
（五）字符串的不可变性
在Java中，String类的对象是不可变的，也就是说一旦创建了一个字符串对象，它的值就不能被修改。这意味着对字符串对象进行操作时，实际上是创建了一个新的字符串对象，而原始的字符串对象保持不变。
这种不可变的特性有以下几个方面的作用：
1.线程安全。由于字符串是不可变的，多个线程可以同时访问和共享字符串对象，而不需要担心数据的修改和同步问题。
2.缓存哈希值。由于字符串的值不变，可以在创建字符串对象时计算并缓存其哈希值，以便后续的哈希操作更高效。
3.安全性。字符串作为参数传递给方法时，不可变性确保方法内部无法改变传递的字符串对象，避免了潜在的安全漏洞。
4.字符串常量池。字符串常量池利用字符串的不可变性，可以实现字符串的共享，节省内存空间。
由于字符串的不可变性，对字符串进行拼接、替换、截取等操作时，实际上是创建了一个新的字符串对象，而不是在原始对象上进行修改。这样的设计决策可以避免意外的修改和数据竞争，同时提供了更可靠和可预测的行为。
需要注意的是，尽管字符串对象本身是不可变的，但可以通过引用变量重新指向新的字符串对象来实现对字符串的修改，例如：
String str = "Hello";
str = str + ", World!"; //创建了一个新的字符串对象，并将新的引用赋值给str变量
在这个例子中，原始的字符串对象"Hello"保持不变，而str变量指向了一个新创建的字符串对象"Hello, World!"。这也是字符串不可变性的一种表现形式。
总之，字符串的不可变性在Java中是一个重要的特性，它带来了线程安全性、安全性、哈希缓存等优点，并为字符串常量池的实现提供了基础。
三、StringBuilder和StringBuffer
（一）StringBuilder
StringBuilder是Java中提供的一个可变的字符串类，它允许对字符串进行动态修改，而不会创建多个对象。与String类不同，StringBuilder对象的值是可变的，可以进行插入、追加、替换、删除等操作。
以下是StringBuilder类的一些常用方法：
1.append(String str)：将指定的字符串追加到当前字符串的末尾。
2.insert(int offset, String str)：在指定的偏移量位置插入指定的字符串。
3.replace(int start, int end, String str)：用指定的字符串替换从指定起始位置到结束位置的子字符串。
4.delete(int start, int end)：删除从指定起始位置到结束位置的子字符串。
5.reverse()：反转当前字符串。
StringBuilder类提供了许多其他方法来操作和处理字符串，如查询长度、获取指定位置的字符、获取子字符串等。它的使用类似于String，但具有可变性的特点，适合在需要频繁修改字符串的场景下使用。
需要注意的是，StringBuilder是非线程安全的，如果在多线程环境下使用，应考虑使用线程安全的StringBuffer类代替。
（二）StringBuffer
StringBuffer是Java中提供的一个可变的、线程安全的字符串类，它与StringBuilder类似，可以进行动态修改字符串的操作。与StringBuilder不同的是，StringBuffer的方法是线程安全的，适用于多线程环境。
以下是StringBuffer类的一些常用方法：
1.append(String str)：将指定的字符串追加到当前字符串的末尾。
2.insert(int offset, String str)：在指定的偏移量位置插入指定的字符串。
3.replace(int start, int end, String str)：用指定的字符串替换从指定起始位置到结束位置的子字符串。
4.delete(int start, int end)：删除从指定起始位置到结束位置的子字符串。
5.reverse()：反转当前字符串。
StringBuffer类提供了许多其他方法来操作和处理字符串，类似于StringBuilder和String。不同的是，StringBuffer的方法是同步的，它使用了内部的同步机制来确保线程安全，因此适用于多线程环境下的操作。
由于StringBuffer的同步性，它在性能上可能比StringBuilder稍慢。因此，如果在单线程环境下进行字符串操作，推荐使用StringBuilder；而在多线程环境下，或需要保证线程安全性时，应使用StringBuffer。
（三）String、StringBuffer和StringBuilder的区别
在Java中，String、StringBuffer和StringBuilder是用于操作字符串的三个类，它们之间有以下区别：
1.不可变性
String是不可变的，一旦创建就不能修改，任何对String的操作都会创建新的字符串对象。StringBuffer和StringBuilder是可变的，允许对字符串进行动态修改。StringBuffer是线程安全的，而StringBuilder是非线程安全的。
2.线程安全性
String是不可变的，因此在多线程环境下是线程安全的。StringBuffer是线程安全的，它的方法使用了同步机制来保证线程安全性。StringBuilder是非线程安全的，它的方法没有同步机制，适用于单线程环境。
3.性能
String的不可变性带来了一些性能优化，例如字符串常量池和缓存的哈希值。然而，频繁的字符串拼接和修改会导致大量的临时对象创建，性能较低。StringBuffer和StringBuilder的可变性使得字符串的操作更高效，避免了不必要的对象创建和拷贝。由于StringBuffer的线程安全性，它在性能上可能稍慢于StringBuilder。
4.适用场景
String适用于字符串不需要修改的情况，例如常量、参数传递等。StringBuffer适用于多线程环境或需要线程安全的场景，例如多线程共享字符串的修改。StringBuilder适用于单线程环境，不需要线程安全的场景，例如字符串的拼接、修改等操作。
综上所述，String适用于不需要修改的字符串，StringBuffer适用于多线程环境或需要线程安全的字符串操作，StringBuilder适用于单线程环境下的字符串操作。根据具体的需求和性能要求，选择适合的类来操作字符串。
四、Date类
（一）概念
java.util.Date类，表示一个日期和时间，内部精确到毫秒。
（二）构造方法
1.public Date()
创建当前系统时间对应的日期对象。
2.public Date(long time)
创建以标准基准时间为基准、指定偏移毫秒数，所对应时间的日期对象。
（三）标准基准时间
0时区：1970年1月1日00:00:00 GMT，格林威治标准时间。
东8区：1970年1月1日08:00:00 CST，中国标准时间。
（四）常用方法
1.public long getTime()：获取当前日期对象距离标准基准时间的毫秒值。
2.public void setTime(long time)：设置当前日期对象距离标准基准时间的毫秒值。
3.public boolean after(Date when)：测试此日期是否在指定日期之后。
4.public boolean before(Date when)：测试此日期是否在指定日期之前。
五、SimpleDateFormat类
（一）DateFormat类
java.text.DateFormat类，是日期/时间格式化子类的抽象类。
作用
完成日期和文本之间的转换，也就是在Date对象和String对象之间来回进行转换。
1.格式化。按照指定格式，把Date对象转换为String对象。
2.解析。按照指定格式，把String对象转换为Date对象。
特点
由于DateFormat是抽象类，无法创建对象，所以只能使用其子类SimpleDateFormat类。
（二）SimpleDateFormat类
java.text.SimpleDateFormat类，是日期/时间格式化的类。
（1）作用
可以在Date对象与StringBuffer对象之间来回进行切换。
（2）构造方法
public SimpleDateFormat(String pattern)
创建日期格式化对象，并且通过参数指定日期格式。
| 字符 | 含义 | 示例 |
|---|---|---|
| y | 年 | yyyy年——2024年；yy年——24年 |
| M | 月 | MM月——01月；M月——1月 |
| d | 日 | dd日——06日；d日——6日 |
| E | 星期 | E——星期日（Sun） |
| a | AM或PM标识 | a——下午（PM） |
| H | 小时（24小时制） | HH时——24时 |
| h | 小时（12小时制） | a h时——下午12时 |
| m | 分钟 | HH:mm:ss——12:22:22 |
| s | 秒 | hh(a):mm:ss——12（下午）:22:22 |
（3）常用方法
1.format
String format(Date date)方法可以将给定的date对象所表示的时间按照SimpleDateFormat指定的日期格式转换为字符串。
public class Test {
public static void main(String[] args) {
Date now = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = sdf.format(now);
System.out.println(str); //2024-05-28 19:10:27
}
}
2.parse
Date parse(String str)将给定的字符串按照SimpleDateFormat指定的日期格式解析为一个Date对象。
public class Test {
public static void main(String[] args) throws ParseException {
String str = "2008-04-22 20:12:22";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(str); //parse方法要异常处理
System.out.println(date); //Tue Apr 22 00:00:00 GMT+08:00 2008
}
}
如果字符串的格式与指定的日期格式不匹配，parse方法将抛出异常：java.text.ParseException。
六、Calendar抽象类
（一）概念
创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类。但是它提供了一个getInstance() 方法来获得 Calendar 类的对象。 getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。
（二）方法展示
| 方法 | 描述 |
|---|---|
| void add(int field, int amount) | 根据日历的规则，为给定的日历字段field添加或减去指定的时间量amount |
| boolean after(Object when) | 判断此Calendar表示的时间是否在指定时间when之后，并返回判断结果 |
| boolean befor(Object when) | 判断此Calendar表示的时间是否在指定时间when之前，并返回判断结果 |
| void clear() | 清空Calendar中的日期时间值 |
| int compareTo(Calendar anotherCalendar) | 比较两个Calendar对象表示的时间值（从格林威治时间1970年1月1日00时00分00秒至现在的毫秒偏移量），大则返回1，小则返回-1，相等返回0 |
| int get(int filed) | 返回指定日历字段的值 |
| int getActualMaximum(int field) | 返回指定日历字段可能拥有的最大值 |
| int getActualMinimum(int field) | 返回指定日历字段可能拥有的最小值 |
| int getFirstDayOfWeek() | 获取一星期的第一天。根据不同的国家地区，返回不同的值 |
| static Calendar getInstance() | 使用默认时区和语言环境获得一个日历 |
| static Calendar getInstance(TimeZone zone) | 使用指定时区和默认语言环境获得一个日历 |
| static Calendar getInstance(TimeZone zone, Locale aLocale) | 使用指定时区和语言环境获得一个日历 |
| Date getTime() | 返回一个表示此Calendar的时间值（从格林威治时间1970年1月1日00时00分00秒至现在的毫秒偏移量）的Date对象 |
| long getTimeInMills() | 返回此Calendar的时间值，以毫秒为单位 |
| void set(int field, int value) | 为指定的日历字段设置给定值 |
| void set(int year, int month, int date) | 设置日历字段YEAR、MONTH和DAY_OF_MONTH的值 |
| void set(int year, int month, int date, int hourOfDay, int minute, int second) | 设置字段YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE和SECOND的值 |
| void setFirstDayOfWeek(int value) | 设置一星期的第一天是哪一天 |
Calendar对象可以调用set()方法将日历翻到任何一个时间，当参数year取负数时表示公元前。
Calendar对象调用get()方法可以获取有关年、月、日等时间信息。
参数field的有效值由Calendar的静态常量指定。
（三）常量展示
| 常量名 | 说明 |
|---|---|
| Calendar.YEAR | 年份 |
| Calendar.MONTH | 月份 |
| Calendar.DATE | 日期 |
| Calendar.DAY_OF_MONTH | 日期 |
| Calendar.HOUR | 12小时制的小时 |
| Calendar.HOUR_OF_DAY | 24小时制的小时 |
| Calendar.MINUTE | 分钟 |
| Calendar.SECOND | 秒 |
| Calendar.DAY_OF_WEEK | 星期几 |
（四）日期的格式化输出
| 字符 | 含义 |
|---|---|
| %tF | %tH:%<tM:%<tS |
| %tT | %tY年%<tm月%<td日 %<tp %<tA %<ta %<tb %<tB |
//获取默为当前时间的Calendar日期对象
Calendar c = Calendar.getInstance();
//格式化日期输出当前日期
System.out.printf("%tF %<tT%n",c);
七、System类
（一）概念
System类是一些与系统相关属性和方法的集合，而且在System类中所有的属性都是静态的，要想引用这些属性和方法，直接使用System类调用即可。
（二）常用方法
| 方法 | 描述 |
|---|---|
| void exit(int status) | 终止当前正在运行的java虚拟机，参数用作状态码；根据惯例，非0的状态码表示异常终止 |
| void gc() | 运行垃圾收集机制，调用的是Runtime类中的gc方法 |
| long currentTimeMillis() | 返回以毫秒为单位的当前时间 |
| void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) | 数组复制操作 |
| Properties getProperties() | 取得当前系统的全部属性 |
| String getProperty(String key) | 根据键值取得属性的具体内容 |
八、BigDecimal类
（一）概念
BigDecimal是Java中的一个类，位于java.math包中。它提供了任意精度的有符号十进制数字的表示，以及对这些数字进行算术运算的方法。由于BigDecimal能够精确表示和计算浮点数，因此它在金融、科学计算等领域得到了广泛应用。
（二）常用方法
| 方法 | 描述 |
|---|---|
| BigDecimal add(BigDecimal augend) | 加法运算 |
| BigDecimal subtract(BigDecimal subtrahend) | 减法运算 |
| BigDecimal multiply(BigDecimal multiplicand) | 乘法运算 |
| BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) | 除法运算，可以指定小数位数和舍入方式 |
| BigDecimal setScale(int newScale, RoundingMode roundingMode) | 设置小数位数和舍入方式 |
| int compareTo(BigDecimal val) | 比较两个BigDecimal的大小 |
| String toString() | 将BigDecimal转换为字符串 |
（三）特点
BigDecimal的特点主要包括：
- 精确度高。BigDecimal可以表示任意精度的十进制数，避免了浮点数运算中的精度损失问题。
- 可控的舍入方式。在进行除法运算或设置小数位数时，BigDecimal允许用户指定舍入方式，如四舍五入、向上取整等。
- 不可变性。BigDecimal对象是不可变的，这意味着一旦创建了一个BigDecimal对象，就不能修改它的值。这种特性有助于保证数据的安全性和一致性。
（四）性能问题
BigDecimal的性能问题主要源于以下几点：
- 内存占用：BigDecimal对象的内存占用较大，尤其是在处理大数字时。每个BigDecimal实例都需要维护其精度和标度等信息，这会导致内存开销增加。
- 不可变性：BigDecimal是不可变类，每次进行运算或修改值时都会生成一个新的BigDecimal实例。这意味着频繁的操作可能会导致大量的对象创建和垃圾回收，对性能造成一定的影响。
- 运算复杂性：由于BigDecimal要求精确计算，它在执行加减乘除等运算时会比较复杂。这些运算需要更多的计算和处理时间，相比于原生的基本类型，会带来一定的性能损耗。
（五）示例
1.初始化BigDecimal
BigDecimal通常通过字符串来构造，以避免浮点数的不精确表示。
import java.math.BigDecimal;
public class BigDecimalExample {
public static void main(String[] args) {
//通过字符串构造BigDecimal
BigDecimal bd1 = new BigDecimal("123.456");
BigDecimal bd2 = new BigDecimal("789.123");
//打印BigDecimal的值
System.out.println("bd1:" + bd1);
System.out.println("bd2:" + bd2);
}
}
2.算术运算
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalArithmetic {
public static void main(String[] args) {
BigDecimal bd1 = new BigDecimal("10.00");
BigDecimal bd2 = new BigDecimal("3.00");
BigDecimal bd3;
//加法
bd3 = bd1.add(bd2);
System.out.println("加法结果：" + bd3); //输出：13.00
//减法
bd3 = bd1.subtract(bd2);
System.out.println("减法结果：" + bd3); //输出：7.00
//乘法
bd3 = bd1.multiply(bd2);
System.out.println("乘法结果：" + bd3); //输出：30.00
//除法，指定小数位数和舍入方式
bd3 = bd1.divide(bd2, 2, RoundingMode.HALF_UP); //四舍五入
System.out.println("除法结果：" + bd3); //输出结果：3.33
}
}
3.比较大小
compareTo()方法返回-1、0、1，分别表示第一个BigDecimal小于、等于或大于第二个BigDecimal。
import java.math.BigDecimal;
public class BigDecimalComparison {
public static void main(String[] args) {
BigDecimal bd1 = new BigDecimal("10.0");
BigDecimal bd2 = new BigDecimal("20.0");
BigDecimal bd3 = new BigDecimal("10.0");
//使用compareTo方法比较
int result1 = bd1.compareTo(bd2);
int result2 = bd1.compareTo(bd3);
if (result1 < 0) {
System.out.println("bd1小于bd2");
} else if (result1 > 0) {
System.out.println("bd1大于bd2");
} else {
System.out.println("bd1等于bd2");
}
if (result2 == 0) {
System.out.println("bd1等于bd3");
}
}
}
4.设置小数位数和舍入
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalRounding {
public static void main(String[] args) {
BigDecimal bd = new BigDecimal("123.456789");
//设置小数位数为2，四舍五入
BigDecimal rounded = bd.setScale(2, RoundingMode.HALF_UP);
System.out.println("四舍五入结果：" + rounded); //输出：123.46
//设置小数位数为0，向下取整
rounded = bd.setScale(0, RoundingMode.DOWN);
System.out.println("向下取整结果：" + rounded); //输出：123
}
}
在此例中，setScale()方法用于设置BigDecimal的小数位数，而RoundingMode枚举则用于指定舍入方式。
九、Math类
（一）概念
在Java中，Math类是一个包含了各种数学方法和常量的类。
它提供了许多用于执行数学运算的静态方法，这些方法可以直接通过类名来调用，而不需要创建Math类的实例。
（二）常用方法、常量
Math类包含了各种常用的数学方法，例如：
| 方法 | 说明 |
|---|---|
| int abs(int a) | 返回参数的绝对值 |
| double ceil(double a) | 返回大于等于参数的最小整数 |
| double floor(double a) | 返回小于等于参数的最大整数 |
| int round(float a) | 按照四舍五入返回最接近参数的int |
| int max(int a, int b) | 返回两个int值中的较大值 |
| int min(int a, int b) | 返回两个int值中的较小值 |
| double pow(double a, double b) | 返回a的b次幂的值 |
| double sqrt(double a) | 返回a的平方根 |
| double random() | 返回[0.0, 1.0)区间任意浮点数值 |
Math类还提供了一些常用的数学常量，例如：
| 常量 | 说明 |
|---|---|
| Math.PI | 表示圆周率π的近似值3.141592653589793 |
| Math.E | 表示自然对数的底数e的近似值2.718281828459045 |
此外，Math类还提供了一些三角函数、对数函数、指数函数等高级数学方法，以及处理浮点数舍入、取整、取余等方法，如下展示一部分：
| 方法 | 说明 |
|---|---|
| double exp(double a) | 返回e的a次幂 |
| double cbrt(double a) | 返回a的立方根 |
| double log(double a) | 返回a的自然对数，即lna的值 |
| log10(double a) | 返回以10为底a的对数 |
| //… |
可以通过调用Math类的方法来实现这些数学操作，而无需自己编写复杂的算法。
十、Random类
（一）概念
Random类是java.util下的一个根据随机算法的起源数字进行一些变化，从而得到随机数字的方法。
随机算法的起源数字被称为种子数（seed）。
虽然Random类产生的数字是随机的，但在相同种子数（seed）下的相同次数产生的随机数是相同的。也就是说，两个种子数相同的Random对象，第一次生成的随机数字完全相同、第二次生成的随机数字也完全相同、……。即伪随机，也就是有规则的随机。
（二）对象初始化
Random类中共有两种构造方法。
1.public Random()
此构造方法是以系统自身的时间为种子数来构造Random对象。
2.public Random(long seed)
此构造方法可以自己来选定具体的种子来构造Random对象。
示例：
Random r1 = new Random();
Random r2 = new Random(10);
再次强调，种子数只是随机算法的起源数字，它与生成的随机数字的区间无关。
（三）常用方法
需要说明的是，Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率是军等的。
| 方法 | 说明 |
|---|---|
| boolean nextBoolean() | 生成一个随机的boolean值，生成true和false的几率相等 |
| double nextDouble() | 生成一个随机的double值，该值介于[0.0, 1.0)区间 |
| int nextInt() | 生成一个随机的int值，该值介于int的区间，也就是 − 2 31 -2^{31} −231到 2 31 − 1 2^{31}-1 231−1之间 |
| int nextInt(int n) | 生成一个随机的int值，该值介于[0, n)之间 |
| void setSeed(long seed) | 重新设置Random对象的种子数 |
（四）示例
使用Random类，一般用于生成指定区间的随机数字。
1.初始化Random对象
Random r = new Random();
2.生成[0.0, 1.0)区间的小数
double d1 = r.nextDouble();
3.生成[0.0, 5.0)区间的小数
double d2 = r.nextDouble() * 5;
4.生成[1.0, 2.5)区间的小数
double d3 = r.nextDouble() * 1.5 + 1;
分析：要生成[1.0, 2.5)区间的随机小数，只需要首先生成[0.0, 1.5)区间的随机数字，再加1即可。
将其进行推广，则，要生成任意从非0开始的小数区间[d1, d2)范围的随机数字（其中d1≠0），则只需首先生成[0.0, d2-d1)区间的随机数字，然后再加d1即可。
5.生成任意int整数
int n1 = r.nextInt();
6.生成[0, 10)区间的整数
//方法一
int n2 = r.nextInt(10);
//方法二
int n2 = Math.abs(r.nextInt() % 10);
4423
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
