一,String字符串
1.1,String字符串是引用类型,且不可变
String str1 = "Hello";
String str2 = str1.concat(" World"); // 使用concat方法连接字符串，返回一个新的字符串对象
System.out.println(str1); // 输出：Hello，原始字符串对象并未改变
System.out.println(str2); // 输出：Hello World，新的字符串对象被创建并赋给str2
str1="test";
System.out.println(str1);//输出test
也就是说,String字符串并不会被修改,只是会重新找一个内存来存储,相当于新建一个引用类型的数据.
1.2,字符串的比较必须使用equals()方法而不能用
String str1 = "Hello";
String str2 = "world";
String str3 = "world";
System.out.println(str1==str2); // 输出：false
System.out.println(str2==str3); // 输出：true,//Java编译器在编译期，会自动把所有相同的字符串当作一个对象放入常量池，自然s1和s2的引用就是相同的。
System.out.println(str1.equals(str2)); // 输出：false
1.3,字符串的其他常用方法
// 是否包含子串:
"Hello".contains("ll"); // true
//其他搜索字串
"Hello".indexOf("l"); // 2
"Hello".lastIndexOf("l"); // 3
"Hello".startsWith("He"); // true
"Hello".endsWith("lo"); // true
//提取字串
"Hello".substring(2); // "llo"
"Hello".substring(2, 4); //"ll"
//去除首尾空格
" \tHello\r\n ".trim(); // "Hello"
//字符串判空
"".isEmpty(); // true，因为字符串长度为0
" ".isEmpty(); // false，因为字符串长度不为0
" \n".isBlank(); // true，因为只包含空白字符
" Hello ".isBlank(); // false，因为包含非空白字符
//替换字符replace或者正则表达式
String s = "hello";
s.replace('l', 'w'); // "hewwo"，所有字符'l'被替换为'w'
s.replace("ll", "~~"); // "he~~o"，所有子串"ll"被替换为"~~"
//分割字符串
String s = "A,B,C,D";
String[] ss = s.split("\\,"); // {"A", "B", "C", "D"}
//拼接字符串
String[] arr = {"A", "B", "C"};
String s = String.join("***", arr); // "A***B***C"
//其他类型转化为字符串：String.valueOf
String.valueOf(123); // "123"
String.valueOf(45.67); // "45.67"
String.valueOf(true); // "true"
//char []和String本质上同个东西，可以相互转化
char[] cs = "Hello".toCharArray(); // String -> char[]
String s = new String(cs); // char[] -> String
1.4,StringBuilder类
在在上文中,我们说过STring对象不可修改,而是不断新分配内存给它,那字符串操作频繁了,每次都会创建新的字符串对象，然后扔掉旧的字符串。这样，绝大部分字符串都是临时对象，不但浪费内存，还会影响GC效率。
于是,java标准库提供了StringBuilder，它是一个可变对象，可以预分配缓冲区，这样，往StringBuilder中新增字符时，不会创建新的临时对象,而且它还支持链式操作:
StringBuilder sb = new StringBuilder(1024);
sb.append("Mr ")
.append("Bob")
.append("!")
.insert(0, "Hello, ");
System.out.println(sb.toString());
1.5,StringJoiner拼接数组
分隔符拼接数组的需求很常见，所以Java标准库还提供了一个StringJoiner:
String[] names = {"Bob", "Alice", "Grace"};
StringJoiner sj = new StringJoiner(", ");
for (String name : names) {
sj.add(name);
}
System.out.println(sj.toString());//Bob, Alice, Grace
二,包装类
我们已经知道，Java的数据类型分两种：
基本类型：byte，short，int，long，boolean，float，double，char
引用类型：所有class和interface类型
引用类型可以赋值为null，表示空，但基本类型不能赋值为null,为了实现把int基本类型变成一个引用类型，我们可以定义一个Integer类，它只包含一个实例字段int，这样，Integer类就可以视为int的包装类（Wrapper Class）：
public class Integer {
private int value;
public Integer(int value) {
this.value = value;
}
public int intValue() {
return this.value;
}
public static Integer valueOf(int intValue){
Integer instance=new Integer(intValue);
return instance;
}
}
实际上,因为包装类型非常有用，Java核心库为每种基本类型都提供了对应的包装类型:
我们可以直接使用，并不需要自己去定义,对于包装类型,使用的方式如下:
//创建使用Integer.valueOf方法
Integer n2 = Integer.valueOf(100);
//访问使用该实例的intValue()方法
System.out.println(n2.intValue());
因为int和Integer可以相互转化,所以可以利用这一点让编译器自动拆箱:
Integer n = 100; // 编译器自动使用Integer.valueOf(int)
int x = n; // 编译器自动使用Integer.intValue()
但是因为包装类型是引用类型,所以需要使用equals()进行比较:a.equals(b)
三,枚举类
枚举类的定义使用关键字enum来进行:
enum Weekday {
SUN, MON, TUE, WED, THU, FRI, SAT;
}
定义的enum实际上就是一个class类.
因为enum是一个class，每个枚举的值都是class实例，因此，这些实例有一些方法：
//name()方法返回常量名
String s = Weekday.SUN.name(); // "SUN"
//ordinal()方法返回索引值
int n = Weekday.MON.ordinal(); // 1
枚举类的实例,还可以定义一些属性值:
enum Weekday {
MON(1, "星期一"), TUE(2, "星期二"), WED(3, "星期三"), THU(4, "星期四"), FRI(5, "星期五"), SAT(6, "星期六"), SUN(0, "星期日");
public final int dayValue;
private final String chinese;
private Weekday(int dayValue, String chinese) {
this.dayValue = dayValue;
this.chinese = chinese;
}
@Override
public String toString() {
return this.chinese;
}
}
枚举通常会和switch一起使用:
public class HelloWorld {
public static void main (String[] args){
Weekday day = Weekday.SUN;
switch(day.dayValue) {
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("Today is " + day + ". Work at office!");
break;
case 6:
case 0:
System.out.println("Today is " + day + ". Work at home!");
break;
default:
throw new RuntimeException("cannot process " + day);
}
}
}
enum Weekday {
MON(1, "星期一"), TUE(2, "星期二"), WED(3, "星期三"), THU(4, "星期四"), FRI(5, "星期五"), SAT(6, "星期六"), SUN(0, "星期日");
public final int dayValue;
private final String chinese;
private Weekday(int dayValue, String chinese) {
this.dayValue = dayValue;
this.chinese = chinese;
}
//覆写toString，定义枚举类的实例值返回内容
@Override
public String toString() {
return this.chinese;
}
}
四,记录类record
我们平时非常常用的一种类,在我们想要定一个类的时候,肯定是先定义需要的属性和获取该值的方法,每次都写就很麻烦,于是我们就想把它简化掉,让编辑器自动帮我们写,于是就有了记录类:使用record方法进行修饰.
public final class Point {
private final int x;
private final int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int x() {
return this.x;
}
public int y() {
return this.y;
}
}
等价于:
record Point(int x, int y) {}
过使用record类，可以更加简洁地定义数据传输对象，并且省去了编写大量重复代码的工作。
五,大数类
BigInteger类,java.math.BigInteger就是用来表示任意大小的整数。BigInteger内部用一个int[]数组来模拟一个非常大的整数：
对BigInteger做运算的时候，只能使用实例方法，例如，加法运算：
BigInteger i1 = new BigInteger("1234567890");
BigInteger i2 = new BigInteger("12345678901234567890");
BigInteger sum = i1.add(i2); // 12345678902469135780
那要是浮点数呢?我们可以使用BigDecimal表示一个任意大小且精度完全准确的浮点数。
BigDecimal bd = new BigDecimal("123.4567");
System.out.println(bd.multiply(bd)); // 15241.55677489
六,Math类
提供了一些数学的计算方法.
//绝对值
Math.abs(-100); // 100
//求最大或者最小
Math.max(100, 99); // 100
Math.min(1.2, 2.3); // 1.2
//求x的y次方
Math.pow(2, 10); // 2的10次方=1024
//求根号
Math.sqrt(2); // 1.414...
//求e的x次方
Math.exp(2); // 7.389...
//三角函数
Math.sin(3.14); // 0.00159...
Math.cos(3.14); // -0.9999...
Math.tan(3.14); // -0.0015...
Math.asin(1.0); // 1.57079...
Math.acos(1.0); // 0.0
//几个常量
double pi = Math.PI; // 3.14159...
double e = Math.E; // 2.7182818...
Math.sin(Math.PI / 6); // sin(π/6) = 0.5
