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);//false
3.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以内