学习Java的第五天（2024.7.18）

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以内