1.字符串类：String类
String类：是引用类型，默认值为null（注意不是空串" ")
字符串的声明：
public static void main(String[] args) {
//声明字符串
String str = "abc你好";
System.out.println(str);
str = new String("");
//和 str new String();输出结果都显示不出来，一个为""一个为null
System.out.println(str);
str = new String("你好");
System.out.println(str);
char[] arr = {'q','w','e','r'};
str = new String(arr);
System.out.println(str)
}字符串的拼接：
public static void main(String[] args) {
//字符串的拼接 + 加号在做字符串拼接或数学运算时的优先级是一样的
//字符串和所有类型相加+（拼接）后，得到的结果都是字符串
str = "123"+"abc";
System.out.println(str);//123abc
str = "123"+45;
System.out.println(str);//12345
str = "123"+new Object();//"123"+这个对象的toString()方法的结果
System.out.println(str);
str = "123"+new int[]{1,2,3};
//数组是引用类型 "123"+toString()方法的结果
System.out.println(str);
System.out.println("123"+123+123);
//123123123 字符串123和123以及123拼接，生成字符串"123123123"
System.out.println(123+123+"123");
//246123 数学运算从左到右，先将两个int型123相加得到246再和字符串123拼接成246123
}字符串的比较：
public static void main(String[] args) {
//字符串比较 使用equals方法比较字符串
boolean bool = "123".equals("123");
System.out.println(bool);//true
System.out.println("123".equals("123"));//true
String strA = new String("123");
String strB = new String("123");
bool=strA.equals(strB);
System.out.println(bool);//true
}一种就近原则：
public static void test(String str){
System.out.println("string");
}
public static void test(Object obj){
System.out.println("object");
}
public static void main(String[] args) {
test(null);
//String类和Object类都是引用类型，默认值都为null，但是String类是Object的子类
//根据就近原则，这里跳转到test(String str)方法中，输出"string"
}2.String类型的常用方法：
（1）valueOf()方法:将传进的类型转化成字符串（是静态方法，要创建对象点.出来）
str = String.valueOf(12);//将传进的类型转化成字符串
System.out.println(str);//输出字符串12（2）indexOf()方法：查找子串出现的位置
int index1="123456".indexOf("34");
System.out.println(index1);//从第0项开始查找，查找到第2项找到字符串"34",故输出2
int index2="123456".indexOf("5");
System.out.println(index2);//从第0项开始查找，查找到第4项找到字符串"5"，输出4
int index3="123456".indexOf("7");
System.out.println(index3);//找不到该值就返回-1
int index4="123123123".indexOf("1");//0
int index5="123123123".lastIndexOf("1");//6
System.out.println(index4);
//第0项就找到字符串"1",只输出第一次找到该字符串的位置，输出1
System.out.println(index5);
//开始查找最后一次出现字符串"1"的位置，找到第六项为最后一次，输出6（3）charAt():查找第几项的值
public static void main(String[] args) {
char item="123456".charAt(4);//'5'，直接摘出第4项的值，只不过这里要用char型存储
System.out.println(item);
}
（4）substring()方法：截取字符串，截取一部分字符串输出
str = "123456".substring(3);//从下标为3开始截取
System.out.println(str);//456
str = "123456".substring(1,4);//包含开始截取位置1，不包含最后的截取位置4；截取结果为234；
System.out.println(str);//输出234，注意从下标为1截取到下标为4，但是不取下标为4的项
str = "123456".substring(1,6);//虽然6以及超出长度，但是取不到6，所以没越界
System.out.println(str);
//str = "123456".substring(1,7);//下标越界（5）replace()方法：替换字符串
str = "12345634".replace("34","AAA");
System.out.println(str);//12AAA56AAA
str = "123123".replaceAll(".","A");//此时.表示任意字符，所以全替换成A,(regex是正则表达式)
System.out.println(str);//AAAAAA（6）split()方法：分割字符串，将某个字符串看成间隔，将其余的字符串以字符串的类型输出
String[] strArr="123123123".split("2");//利用2把剩下的数据分割出来1,31,31,3
System.out.println(Arrays.toString(strArr));//[1, 31, 31, 3]
String[] strArrB="1231231231".split("1");//1在首位时，切除一刀来作为空串，末尾的1不管
System.out.println(Arrays.toString(strArrB));//[, 23, 23, 23]（7）length()方法：求字符串长度
int l="123123".length();
System.out.println(l);//该字符串长度为6（8）trim():去除空白符
String strC = "\n\r \t 123 \n\r ";
System.out.println(strC);
System.out.println("---上下分割---");
System.out.println(strC.trim());//除掉空白位的字符串（9）toUpperCase()：小写字母转化成大写字母toLowerCase()：大写字母转化成小写字母
str = "123abc".toUpperCase();//把小写字母转化成大写
System.out.println(str);//123ABC
str = "123ABCabc".toLowerCase();//把大写字母转化成小写
System.out.println(str);//123abcabc（10）isEmpty()方法：判断字符串是否为空
boolean b = "123".isEmpty();
System.out.println(b);//false3.String对象：
String对象定义后就不可改变，永远存储到内存中（private final 修饰value数组）
4.字符串常量池：
池：容器，里面的字符串数据可以重用（只要常量池中原来已有该字符串）
字符串怎样加入到常量池中：通过量的方式定义如String str = "123";
双引号引起来就是量的方式定义的字符串，这样就加入到字符串常量池中（这样可以优化运行内存，因为原本定义字符串占用空间非常大），程序中第一次使用量的形式定义"123",会将这个字符串对象存入<字符串常量池中>，之后再使用量的形式使用该对象，就执行使用常量池中的对象（从常量池中引用，完成了代码的重用）
public static void main(String[] args) {
int a=12;
String str="abc";//这种方法就是量的形式定义字符串
Integer.valueOf("23");//双引号直接引起来的就是量的形式
char[] arr={'a','b','c'};
str = new String(arr);//此种形式没有直接用双引号引起来，不是量的形式，不会加入到常量池中
String strA="123";
String strB="123";
System.out.println(strA==strB);//==判断的是地址是否相同，因为strA和strB引用的是同一个对象（常量池中的对象），地址相同，结果是true
String strC = new String("123");
String strD = new String("123");
System.out.println(strA==strC);//false
System.out.println(strC==strD);//false
System.out.println("--------------------");
String strE = "12"+"3";
String strF = "1"+"2"+"3";
String item = "12";
String strG = item+3;
String strGG = item +"3";
System.out.println((strG==strGG)+"--------");//只要有变量都是false
String strH = "12"+3;
System.out.println(strA==strE);//true在解析文件的时候（编译成字节码文件时，在程序运行之前），已经解析成"123",所以为true
System.out.println(strA==strF);//true同理
System.out.println(strE==strF);//true同理
System.out.println(strA==strG);//false 只要是计算出来的，都会生成一个新的对象（因为不确定item的量，只有运行了程序才能确定变量的值，这时候还不确定能不能从常量池中引用，所以不是从常量池中引用）
System.out.println(strA==strH);//true 确定了加上的值是3（固定不变的）
final String aa="12";
String strI = aa+"3";
System.out.println(strA==strI);//true明确了值是常量，12是不会变化的常量，计算优化
String bb = new String("12");//构造方法只有在系统运行时才能知道运行结果
String strJ=bb+3;
System.out.println(strA==strJ);//false，程序运行前不知道bb的值
}5.intern()方法： 将原本不在常量池中的字符串放到常量池中
intern()作用：检查str是否在字符串常量池中存在副本，如果不存在，就复制一份存入到常量池中，然后返回常量池中的副本对象，如果已经存在副本对象，直接返回副本对象。
public static void main(String[] args) {
str.intern();
//返回：str对象在字符串常量池中的副本对象（若在常量池没有，就先复制进常量池，再返回常量池中复制完的，若常量池中有，则直接返回常量池中的）
strA = new String("123");
strB = new String("123");
System.out.println(strA.equals(strB));//true判断两个字符串内容相同与否
System.out.println(strA==strB);//false判断两个字符串地址是否相同（地址不相同才能验证）
System.out.println(strA.intern()==strB.intern());//true验证两个字符串的副本对象是否相同，此处即"123";
//常见笔试题：
//new String("abc"); 创建了几个对象：1个（常量池中已经有副本）或2个（常量池中原本没有副本）
}6.StringBuilder:减少字符串对内存的占用
public class EasyStringBuilder {
public static void main(String[] args) {
//字符串定义后就不可改变 存在常量池里面（等着被重用）
String str="";
for (int i=0;i<10;i++){
str+=i;
}
//0 01 012 0123 ... 0123456789 这样非常消耗内存
}
}StringBuilder的作用：将字符串放到数组中进行拼接，这中间没有产生中间字符串，不会占用大量内存
public class EasyStringBuilder {
public static void main(String[] args) {
//在拼接字符串时不要产生中间串 StringBuilder StringBuffer
StringBuilder strB = new StringBuilder();
strB.append("123");//append意为追加
strB.append("abc");
strB.append("456");
//调用append()方法，往StringBuilder数组中追加元素
//其中没有产生字符串对象，所以不会产生中间字符串
System.out.println(strB);//输出123abc456
//StringBuilder的默认容量为16
//StringBuilder的扩容
//追加字符时容量不够就需要扩容（对value数组进行扩容，默认扩到（原容量*2+2））
//StringBuffer是线程安全的
Objects.isNull(null);//true
Objects.equals(strB,null);//
}
}
7.StringBuilder的扩容：StringBuilder的默认容量为16，追加字符时容量不够就需要扩容（对value数组进行扩容，默认扩到（原容量*2+2））
public class EasyStringBuilder {
public static void main(String[] args) {
//StringBuilder的默认容量为16
//StringBuilder的扩容
//追加字符时容量不够就需要扩容（对value数组进行扩容，默认扩到（原容量*2+2））
//StringBuffer是线程安全的
}
}
8.StringBuilder和StringBuffer的共同与不同：
StringBuilder和StringBuffer的底层原理是相同的，都是拼接字符串到数组中，再返回字符串，不同点是StringBuffer是线程安全的
9.Date类：
long 1970-1-1 00:00:00 000 开始累加
这里的000是一个long类型的整数，记录了从上面元时间开始的每一毫秒，1秒是1000毫秒
可以利用getTime()方法来获取记录每一毫秒的long类型的记录
public static void main(String[] args) {
Date date = new Date();//获取当前时间对象（执行程序时的时间）
System.out.println(date);//输出当前的时间Thu Jul 18 20:19:53 CST 2024
long time = date.getTime();//获取long值累加到多少了
System.out.println(time);
time=time+2*24*60*60*1000;//加上两天时间的毫秒
date = new Date(time);//将加完两天的毫秒放进date对象中
System.out.println(date);//输出两天整后的时间
System.out.println(date.getMonth());//输出月份（0~11），7月即返回数字6
//时间格式化
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
String sdfStr = sdf.format(date);
System.out.println(sdfStr);
System.out.println(sdf.format(date));//两种输出方式相同
LocalDateTime ldf = LocalDateTime.now();//当地时间
ZonedDateTime zdt = ZonedDateTime.now();//时区
Object obj = zdt.getZone();//返回时区的值
System.out.println(obj);
}10.Date类中的时间格式化
public static void main(String[] args) {
//时间格式化
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
// 年-月-日 时：分：秒 毫秒
String sdfStr = sdf.format(date);
System.out.println(sdfStr);
System.out.println(sdf.format(date));//两种输出方式相同，但下面直接输出的方法是面向过程编程的思想
}11.当地时间，时区
public static void main(String[] args) {
LocalDateTime ldf = LocalDateTime.now();//当地时间
System.out.println(ldf);//2024-07-18T20:33:48.087278700
ZonedDateTime zdt = ZonedDateTime.now();//时区
System.out.println(zdt);//2024-07-18T20:34:54.276209500+08:00[Asia/Shanghai]
Object obj = zdt.getZone();//返回时区的值
System.out.println(obj);//Asia/Shanghai
}12.Math类
public class EasyMath {
public static void main(String[] args) {
double ran = Math.random();//[0~1)直间的随机数
double ranNum = ran*82+8;//[8~90)
System.out.println(ranNum);//此时会输出一个[8~90)的整数
}
}13.Math.round()方法：四舍五入取整
要注意返回的数的类型！！！
public class EasyMath {
public static void main(String[] args) {
double ran = Math.random();//[0~1)直间的随机数
double ranNum = ran*82+8;//[8~90)
System.out.println(ranNum);//此时会输出一个[8~90)的整数
//四舍五入
ranNum = 12.77;
long num = Math.round(ranNum);
System.out.println(num);//输出long型的整数13
int intNum = Math.round(12.33f);//若传入float类型，则返回的结果为int
System.out.println(intNum);//输出int型的整数12
}
}14.Math.ceil()方法和Math.floor()方法：
Math.ceil()方法为向上取整，Math.floor()方法为向下取整
public class EasyMath {
public static void main(String[] args) {
//向上取整
double ceil = Math.ceil(12.77);//注意这里返回类型是double型（小数部分只是去除掉了）
System.out.println(ceil);//13.0因为为double型，所以是13.0
//向下取整
double floor = Math.floor(12.77);//返回类型为double型
System.out.println(floor);12.0
}
}
15.Random类：假随机
Random ranObj = new Random(12);
Random ranObj2 = new Random(12);
int a = ranObj.nextInt();
int b = ranObj2.nextInt();
System.out.println(a+"====="+b);//a和b的值相同
a = ranObj.nextInt();//ranObj.nextInt()方法意为存储住下一个int类型的数
b = ranObj2.nextInt();
System.out.println(a+"==="+b);//a和b的值相同
a=ranObj.nextInt(200);//限制随机数到200之内
System.out.println(a);//被限制到200以内