第九章常用类

winter25

已于 2022-03-21 16:15:18 修改

阅读量463

点赞数

分类专栏： Java 文章标签： java

于 2022-03-21 16:14:26 首次发布

本文链接：https://blog.csdn.net/winter25/article/details/123636048

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一、字符串相关类

1.String类

2.StringBuffer类、StringBuilder类

二、JDK8之前的日期时间API

1.System类

2.java.util.Date类

3.SimpleDateFormat类、Calendar类

三、idea Debug

四、JDK8中新日期时间API

LocalDateTime、Instant类、DateTimeFormatter类

五、Java比较器

1.自然排序：java.lang.Comparable

2.定制排序：java.util.Comparator

六、System类

七、Math类

一、字符串相关类

1.String类

/*
String:字符串，使用一对""引起来表示。
1.String声明为final的，不可被继承
2.String实现了Serializable接口：表示字符串是支持序列化的。
【序列化：io流，讲到对象流-->序列化。面向对象，数据都封装到对象里，对象是可以传输的。传输过程中：是流，字节方式传。传到目的地，再变成对象。
Serializable接口让String类的对象能网络传输】
        实现了Comparable接口：表示String可以比较大小

3.String内部定义了final char[] value用于存储字符串数据
4.String:代表不可变的字符序列。简称：不可变性。
    数组不能再被重新赋值，数组的元素也不能再被修改了
    体现：1.当对字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的value进行赋值。
         2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
         【连接操作 +】
         3. 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
         不可变性总结：只要对字符串的内容有改变，都必须重新造，原有的都不能动


5.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
  【字面量方式，区别于new方式】
6.字符串常量池中是不会存储相同内容的字符串的。
 */

    @Test
    public void test1(){
        String s1 = "abc";//字面量的定义方式
        //【String类的对象不用new，可以直接赋值】
        String s2 = "abc";
        s1 = "hello";

        System.out.println(s1 == s2);//比较s1和s2的地址值
        //【两个对象用==，比较的是它们的地址值。equals（如果该类重写了equals方法）比较的是内容】

        System.out.println(s1);//hello
        System.out.println(s2);//abc

        System.out.println("*****************");

        String s3 = "abc";
        s3 += "def";//【在现有的基础上，后面拼了一个内容，是在原有的位置往后加吗？不是。看s2变没变就知道了。
        // 那放在哪里呢？常量池又新建了一个abcdef】
        System.out.println(s3);//abcdef
        System.out.println(s2);//【abc】

        System.out.println("*****************");

        String s4 = "abc";
        String s5 = s4.replace('a', 'm');//【提示构造器参数：ctrl+alt+/】
        System.out.println(s4);//【abc】【s4没变】
        System.out.println(s5);//mbc

    }

（1）String类实例化方式

String的实例化方式：
方式一：通过字面量定义的方式
方式二：通过new + 构造器的方式

 面试题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？
        两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"

    @Test
    public void test2(){
        //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的【字符串常量池】中。
        String s1 = "javaEE";
        String s2 = "javaEE";
        //通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在【堆空间】中开辟空间以后对应的地址值。
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false

        System.out.println("***********************");
        Person p1 = new Person("Tom",12);
        Person p2 = new Person("Tom",12);

        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name == p2.name);//true
        // 【name是String类型的（引用数据类型），只能保存地址值或null】
        //【直接传"Tom"，String name = "Tom"，是字面量定义，地址相同】

        p1.name = "Jerry";
        System.out.println(p2.name);//Tom

        System.out.println("***********************");
        //【这个是我自己想的】
        Person p3 = new Person(new String("Tom"),12);
        Person p4 = new Person(new String("Tom"),12);
        System.out.println(p3.name);
        System.out.println(p3.name == p4.name);
    }

（2）String的拼接

/*
结论：
1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中有一个是变量，结果就在堆中。
//【有变量就是new的】
3.如果拼接的结果调用intern()方法，返回值就在常量池中
 */

    @Test
    public void test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";//【连接符左右都是字面量，链接后后也在常量池中】
        String s5 = s1 + "hadoop";//【连接符，有一个及以上，变量名参与了。就不再常量池了，在堆空间中。相当于new】
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;
        //【相当于new，s5、s6、s7记录的都是堆中对象的地址值，都不一样】

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false

        String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
        System.out.println(s3 == s8);//true


    }

    @Test//【爆红就alt+enter】
    public void test4(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";//【其中一个是变量】
        //【s2是变量】
        System.out.println(s1 == s3);//false

        final String s4 = "javaEE";//s4:常量
        //【加了final，s4就是常量】
        String s5 = s4 + "hadoop";//【常量与常量的拼接】
        System.out.println(s1 == s5);//【true】

    }

（3）参数值传递与String不可变

public class StringTest {

    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}

（4）

（5）String的常用方法

public class StringMethodTest {

    /*
替换：
String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
//【替换一个字符】

String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
//【替换字符串】

String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
//【regex：正则表达式，将web页面的时候再讲】
String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
匹配:
boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
切片：
String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

     */
    @Test
    public void test4(){
        String str1 = "北京尚硅谷教育北京";
        String str2 = str1.replace('北', '东');

        System.out.println(str1);
        System.out.println(str2);


        String str3 = str1.replace("北京", "上海");
        System.out.println(str3);

        System.out.println("*************************");
        String str = "12hello34world5java7891mysql456";
        //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
        //String string = str.replaceAll("\\d+", ",");
        //,hello,world,java,mysql,

        //如果开头或者结尾有逗号，去掉
        String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
        //hello,world,java,mysql
        //【d：数字 ，+：多个数字 ，^：开头，$：结尾】
        System.out.println(string);


        System.out.println("*************************");
        str = "12345";
        //判断str字符串中是否全部有数字组成，即有1-n个数字组成
        boolean matches = str.matches("\\d+");
        System.out.println(matches);
        String tel = "0571-4534289";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\\d{7,8}");//【规定开头0571-，后面数字是7到8位】
        //【注册邮箱时，通过正则，给出规则，看注册的邮箱是否合规，调了matches】
        System.out.println(result);


        System.out.println("*************************");
        str = "hello|world|java";
        String[] strs = str.split("\\|");//【以|进行切割，strs = {hello,world,java}】
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        System.out.println();
        str2 = "hello.world.java";
        String[] strs2 = str2.split("\\.");//【以.进行切割，strs = {hello,world,java}】
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }

    }

    /*
boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始

boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
//【String类实现了CharSequence接口。多态】

int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
//【字符串底层是数组，从0~...，所以没找到就返回-1
//数据库是从1~...，所以没找到就返回0】

int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
//【可以用来找指定字符串在字符串中出现了几次，先用indexOf，看有没有，有就返回索引。
假设字符串中不止一个，索引加指定字符串长度，就可以得到fromIndex，就可以继续找】

int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
//【前两个是从前往后找，后两个是从后往前找。返回的索引还是从前往后的索引】
int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注：indexOf和lastIndexOf方法如果未找到都是返回-1

     */
    @Test
    public void test3(){
        String str1 = "hellowworld";
        boolean b1 = str1.endsWith("rld");
        //【没说结尾的指定字符串多长】
        System.out.println(b1);

        boolean b2 = str1.startsWith("He");
        //【没说开始的指定字符串多长】
        System.out.println(b2);

        boolean b3 = str1.startsWith("ll",2);
        System.out.println(b3);//【true】

        String str2 = "wor";
        System.out.println(str1.contains(str2));

        System.out.println(str1.indexOf("lol"));

        System.out.println(str1.indexOf("lo",5));

        String str3 = "hellorworld";

        System.out.println(str3.lastIndexOf("or"));
        System.out.println(str3.lastIndexOf("or",6));

        //【什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？
        //情况一：存在唯一的一个str。情况二：不存在str】
    }


    /*
int length()：返回字符串的长度： return value.length
【本质上是底层数组长度】

char charAt(int index)： 返回某索引处的字符return value[index]
boolean isEmpty()：判断是否是空字符串：return value.length == 0
String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
String trim()：返回字符串的副本，忽略前导空白和尾部空白
//【输入用户名时有用】

boolean equals(Object obj)：比较字符串的内容是否相同
//【回顾==比较运算符和equals()方法之间的区别】

boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
//【字符串严格区分大小写，大小写是不一样的】

String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
//【一般直接用连接符号】

int compareTo(String anotherString)：比较两个字符串的大小
//【String类实现了Comparable接口：表示String可以比较大小】

String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
//【string的s小写】
String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
//【左闭右开】

     */
    @Test
    public void test2() {
        String s1 = "HelloWorld";
        String s2 = "helloworld";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));

        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4);

        String s5 = "abc";//【c:99】
        String s6 = new String("abe");//【e:101】
        System.out.println(s5.compareTo(s6));//-2
        //涉及到【字符串排序】
        //【手机联系人，按abcd排序，就是调了compareTo方法】

        String s7 = "北京尚硅谷教育";
        String s8 = s7.substring(2);
        System.out.println(s7);
        System.out.println(s8);

        String s9 = s7.substring(2, 5);
        System.out.println(s9);
    }

    @Test
    public void test1() {
        String s1 = "HelloWorld";
        System.out.println(s1.length());
        System.out.println(s1.charAt(0));
        System.out.println(s1.charAt(9));
//        System.out.println(s1.charAt(10));
//        s1 = "";
        System.out.println(s1.isEmpty());

        String s2 = s1.toLowerCase();
        System.out.println(s1);//s1不可变的，仍然为原来的字符串
        //【String 不可变性的体现，没对s1本身修改】
        System.out.println(s2);//改成小写以后的字符串

        String s3 = "   he  llo   world   ";
        String s4 = s3.trim();
        System.out.println("-----" + s3 + "-----");
        System.out.println("-----" + s4 + "-----");
    }
}

（6） String与基本数据类型转换

/*
复习：
String 与基本数据类型、包装类之间的转换。

String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
基本数据类型、包装类 --> String:调用String重载的valueOf(xxx)
                       基本数据类型变量+""
 */

@Test
    public void test1(){
        String str1 = "123";
//        int num = (int)str1;//错误的。【只有子父类关系才能强转，基本数据类型之间没有子父类关系】
        int num = Integer.parseInt(str1);

        String str2 = String.valueOf(num);//"123"
        String str3 = num + "";
        //【这不就是之前的s1 + "字面量"吗？变量+字面量。
        // 在堆里new了一个values数组，str3指向values数组，
        // values再指向常量池里的"123"】

        System.out.println(str1 == str3);//false
    }

（7）String与字符数组转换

/*
String 与 char[]之间的转换

String --> char[]:调用String的toCharArray()
char[] --> String:调用String的构造器
 */

    @Test
    public void test2(){
        String str1 = "abc123";  //题目： 把字符串"abc123" 改成 a21cb3
        //【相当于让bc12反转：把String变成char[]，char[]讲过如何反转。然后把反转过的数组转成String】

        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }

        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        //【str1是声明字面量创建字符串，str1直接指向常量池中的abc123
        // str2是构造器创建字符串，str2指向堆中new的values数组，values指向常量池中的hello】
        System.out.println(str2);
    }

（8）String与字节数组转换

/*
String 与 byte[]之间的转换
【和字节数组的转换，后面讲到io流的时候，就会涉及这些操作】

编码：String --> byte[]:调用String的getBytes()
解码：byte[] --> String:调用String的构造器
【String和char[]之间的转换不叫编码解码，因为都看得懂】

编码：字符串 -->字节  (看得懂 --->看不懂的二进制数据)
解码：编码的逆过程，字节 --> 字符串 （看不懂的二进制数据 ---> 看得懂）
【比如下载电影，下下来，说没有解析，看不了。此时这个下载的电影文件是字节的，都还是二进制】

说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。
 */

    @Test
    public void test3() throws UnsupportedEncodingException {


        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码。
        System.out.println(Arrays.toString(bytes));//【数组的遍历，除了for循环，还可以直接Arrays.toString(数组名)】
        //【输出结果[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]】
        //【ascii码，a：97，b：98，c：97，1：49，2：50，3：51，
        // 汉字不在ascii码中。utf-8，一个汉字三位，中：-28 -72 -83，国：-27 -101 -67】

        byte[] gbks = str1.getBytes("gbk");//【会抛异常】
        //使用gbk字符集进行编码。【gbk是专门的汉字编码集】
        //【指定编码集。编码集等到io流再讲】
        System.out.println(Arrays.toString(gbks));
        //[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]【一个汉字两位】

        //【utf-8包括全世界的文字，gbk仅针对汉字】
        System.out.println("******************");

        String str2 = new String(bytes);//使用默认的字符集，进行解码。
        System.out.println(str2);

        String str3 = new String(gbks);
        System.out.println(str3);//出现【乱码】。原因：编码集和解码集不一致！
        //【讲web时，浏览器-后台服务器-数据库
        // 浏览器发送数据给后台，后台把数据存到数据库里，编码集必须相同；
        // 数据库提取数据给后台，后台传给前端，编码集必须相同，否则会出现乱码】


        String str4 = new String(gbks, "gbk");
        System.out.println(str4);//没有出现乱码。原因：编码集和解码集一致！


    }