【Day24】常用类

目录

1、关于StringBuffer和StringBuilder的使用

2、String的使用

3、字符串的相关使用

4、涉及到String类与其他结构之间的转换

---

1、关于StringBuffer和StringBuilder的使用

public class StringBufferBuilderTest {

    /*
    String、StringBuffer、StringBuilder三者的异同
    String：不可变的字符序列；底层使用char[]存储

    StringBuffer：可变的字符序列，线程安全，效率低；底层使用char[]存储
    StringBuilder：可变的字符序列，线程不安全，效率高：JDK5.0新增；底层使用char[]存储
     */


    /*
    StringBuffer的常用方法：
    StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
    StringBuffer delete(int start,int end)：删除指定位置的内容
    StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
    StringBuffer insert(int offset, xxx)：在指定位置插入xxx
    StringBuffer reverse() ：把当前字符序列逆转

    public int indexOf(String str) 返回指定字符在字符串中首次出现的位置
    public String substring(int start,int end)返回一个从start开始到end索引结束的左闭右开区间的子字符串
    public int length()数组长度
    public char charAt(int n )查找指定字符
    public void setCharAt(int n ,char ch)将指定的位置字符改为新的

    总结：
    增：append
    删:delete
    改：setCharAt(int n,char ch)
    查:charAt();
    长度:length()
    遍历:for()+charAt()/toString()

     */
    @Test
    public void test1(){
        StringBuffer str=new StringBuffer("abc");
        str=str.append("ll");
        System.out.println(str);
//        str.delete(1,3);//前面包括，后面不包括
//        System.out.println(str);
//        str.replace(1,3,"bb");
//        str.reverse();
        str.insert(2,"hahah");
        System.out.println(str);

        System.out.println(str.charAt(2));
    }

}

2、String的使用

/*
String:字符串，使用一对“”引起来表示
1、String声明为final的，不可能被继承
2、String实现了Serializable接口：表示字符串是支持序列化的。
    实现了Comparable接口：表示String可以比较大小
3、String内部定义了final char[] value用于存储字符串数据
4、String:代表不可变的字符序列。简称：不可变性。
    体现：1、对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
         2、对原有的字符串进行链接操作时，也需要重新指定内存区域赋值，能使用原有的value进行赋值。
         3、当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，能使用原有的value进行赋值。
5、通过字面量的方式（区别与new）给一个字符串赋值，此时的字符串声明子啊字符串常量池中
6、字符串常量池中是不会存储相同内容的字符串的
 */

person类

public class Person {

    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

}

测试代码

public class StringTest {
    
    @Test
    public void test1(){
        String s1="abc";    //字面量，不需要new，String是一个类
        String s2="abc";
        System.out.println(s1==s2);     //比较地址值true

        s1="hello";

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

        System.out.println("***********************************");
        String s3="abc";
        s3+="def";
        System.out.println(s3);     //abcdef
        System.out.println(s2);     //abc
        System.out.println("*********************");

        String s4="abc";
        String s5=s4.replace('a','m');
        System.out.println(s4);     //abc
        System.out.println(s5);     //mbc
    }

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

     */
    @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

        p1.name="jerry";
        System.out.println(p1.name);//jerry
        System.out.println(p1.name == p2.name);//false

    }

    /*
    结论：
    1、常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
    2、只要其中有一个是变量，结果就在堆中
    3、如果拼接的结果调用intern()方法，返回值就在常量池中
     */
    @Test
    public void test3(){
        String s1="javaEE";
        String s2="hadoop";

        String s3="javaEEhadoop";
        String s4="javaEE"+"hadoop";
        String s5=s1+"hadoop";
        String s6="javaEE"+s2;
        String s7=s1=s2;

        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(s6==s7);//false

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

}

3、字符串的相关使用

/**
 * 
 * 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)：比较字符串的内容是否相同
 *  boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大
 * 小写
 *  String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
 *  int compareTo(String anotherString)：比较两个字符串的大小
 *  String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从
 * beginIndex开始截取到最后的一个子字符串。
 *  String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字
 * 符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
 * 
 */

public class StringMethodTest {
    @Test
    public void test(){
        String s1="HelloWord";
        String s2="   hell owo  rd   ";
        System.out.println(s1.length());
        System.out.println(s1.charAt(1));
        System.out.println(s1.charAt(5));
        System.out.println(s1.isEmpty());
        System.out.println(s1.toLowerCase(Locale.ROOT));
        System.out.println(s1.toUpperCase(Locale.ROOT));
        System.out.println(s2.trim());

    }
    @Test
    public void test2(){
        String s1="HELLOWORD";
        String s2="helloword";
        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";
        String s6=new String("abe");
        System.out.println(s5.compareTo(s6));

        String s7="北大青鸟北大青鸟北大青鸟";
        String s8=s7.substring(1);
        System.out.println(s8);

        String s9=s7.substring(1,3);
        System.out.println(s9);
    }

    /*
     boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
     boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
     boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的
子字符串是否以指定前缀开始
     */
    @Test
    public void test3(){
        String str1="helloword";
        boolean b1=str1.endsWith("word");
        System.out.println(b1);

        boolean b2=str1.startsWith("hll");
        System.out.println(b2);

        boolean b3=str1.startsWith("ll",2);//判断从第二个开始，是否以ll开头，ll为指定前缀
        System.out.println(b3);
    }

    /*
     boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列
    时，返回 true
     int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
     int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出
    现处的索引，从指定的索引开始
     int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
     int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后
    一次出现处的索引，从指定的索引开始反向搜索

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

     */
    @Test
    public void test4(){
        String str1="helloword";
        System.out.println(str1.contains("llo"));//是否包含字符串

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

        System.out.println(str1.indexOf("ll",3));//从指定位置往后找，包含指定位置

        String str2="helloword";
        System.out.println(str2.lastIndexOf("l",4));//从后往前找，输出的数据依然是下标值
    }

    /*
     String replace(char oldChar, char newChar)：返回一个新的字符串，它是
    通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
     String replace(CharSequence target, CharSequence replacement)：使
    用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
     String replaceAll(String regex, String replacement) ： 使 用 给 定 的
    replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
     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 test5(){
        String str1="北大青鸟北大青鸟";
        String str2=str1.replace("北","东");
        System.out.println(str1);
        System.out.println(str2);

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

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

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

        String str3 = "12345";
        //判断str字符串中是否全部有数字组成，即有1-n个数字组成
        boolean matches = str3.matches("\\d+");
        System.out.println(matches);
        String tel = "0571-4534289";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\\d{7,8}");
        System.out.println(result);

        System.out.println("****************************");
        str = "hello|world|java";
        String[] strs = str.split("\\|");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        System.out.println();
        str2 = "hello.world.java";
        String[] strs2 = str2.split("\\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }

    }
}

4、涉及到String类与其他结构之间的转换

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

String-->基本数据类型、包装类：调用包装类的静态方法：parsexxx(str)
基本数据类型、包装类-->String:调用String重载的valuOf(xxx)
 */

public class StringTest1 {
    
    @Test
    public void test(){
        String str1="123";

        int num=Integer.parseInt(str1);

        String str2=String.valueOf(num);
        String str3=num+"";

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

    /*
    String 与 char[]之间的转换
    String --->char[]
     */
    @Test
    public void test2(){
        String str1="abc123";
        char[] charArray=str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);

        }
    }
}