java常用类String

理解String的不可变性

package com.zx.java;
import org.junit.Test;

/**
 * String的使用
 *
 * @author zx
 * @create 2022-08-17 18:00
 */
public class StringTest {
    /*
     string:字符串，使用一对""引起来表示。
     1.String声明为finaL的，不可被继承
     2.String实现了serializabLe接口:表示字符串是支持序列化的。
     3.实现了Comparable接口:表示String可以比较大小
     4.String内部定义了final char[ ] value用于存储字符串数据
     5.String:代表不可变的字符序列。简称:不可变性。
       体现:1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
           :2．当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值
           :3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值

     6.通过字面量的方式(区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
     7.字符串常量池中是不会存储相同内容的字符串的。
*/
    @Test
    public void test1() {
        String s1 = "abc";//字面量
        String s2 = "abc";
       // s1 = "hello";

        System.out.println(s1 == s2);

        System.out.println(s1);
        System.out.println(s2);

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

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


        System.out.println("**********");
        String s4 = "abc";
        String s5 = s4.replace("a","m");
        System.out.println(s5);
        System.out.println(s4);


    }
}

String不同实例化方式的对比

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

经典面试题

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

String的常用方法

package com.zx.java2;
import org.junit.Test;

/**
 * @author zx
 * @create 2022-08-18 11:02
 */
public class StringMethodTest {
    /*
    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开始截取
     */

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

        String s2 = "";
        System.out.println(s2.isEmpty());

        String s3 = s1.toLowerCase();//小写
        //toUppercase()大写
        System.out.println(s3);
        System.out.println(s1);

        String s4 = "   javaee   ";
        System.out.println(s4);
        System.out.println(s4.trim());//去空格
    }


    public void test2() {
        String s1 = "javaee";
        String s2 = "JAVAEE";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写进行比较

        String s3 = "java";
        System.out.println(s3.concat("se"));

        String s4 = "abc";
        String s5 = new String("abe");
        System.out.println(s4.compareTo(s5));

        String s6 = "自学java第一个月";
        String s7 = s6.substring(2);
        System.out.println(s7);
        System.out.println(s6);

        String s8 = s6.substring(2, 6);
        System.out.println(s8);
    }


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

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

        boolean b3 = str1.startsWith("l", 2);
        System.out.println(b3);

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

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

        String str3 = "hellorworld";
        System.out.println(str3.lastIndexOf("or"));

    }


    /*
    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替换此字符串匹配给定的正则表达式的第一个子字符串。
     */
    @Test
    public void test4() {
        String str1 = "北京尚硅谷教育北京";
        String str2 = str1.replace("北", "东");
        System.out.println(str2);

    }


    /*
    boolean matches(String regex):告知此字符串是否匹配给定的正则表达式
    Stringsplit(String regex):根据给定正则表达式的匹配拆分此字符串。
    Stringsplit(String regex， int limit):根据匹配给定的正则表达式来拆分此字符串，最多不超过liml个，如果超过了，剩下的全部都放到最后一个元素中
     */
    @Test
    public void test5() {
        String str = "hello/world/java";
        String [] strs = str.split("/");
        for (int i = 0; i <strs.length ; i++) {
            System.out.println(strs[i]);
        }

    }
}

String类型与基本数据类型，包装类的转换

package com.zx.java2;
import org.junit.Test;

/**
 * @author zx
 * @create 2022-08-18 14:57
 */
public class StringTest {
    /*
    String与基本数据类型,包装类之间的转换

    String--->基本数据类型，包装类：调用包装类的静态方法:parseXxx(str)
    基本数据类型，包装类--->String：掉用String.valueOf(xxx)；
     */
    @Test
    public void test(){
        String s1 = "123";
        int num = Integer.parseInt(s1);
        System.out.println(num + 2);

        int num1 = 23;
        String str2 = String.valueOf(num1);
        System.out.println(str2);
        String str3 = num1 + "";//这种方式也可以转换为String
        System.out.println(s1 == str3);//false

    }
}

String和char[]的转换

package com.zx.java2;
import org.junit.Test;

/**
 * @author zx
 * @create 2022-08-18 15:08
 */
public class StringTest2 {
    /*
    String 与 char[]之间的转换
    String--> char[] :String的toCharArray()
    char[]--> String :直接把char数组放入到String构造器中

     */
    @Test
    public void test(){
        String str1 = "abc123";
        char[] chars = str1.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

        char[] char2 = new char[]{'h','e','l','l','o'};
        String str2 = new String(char2);
        System.out.println(str2);

        for (int i = chars.length-2; i > 0; i--) {
            System.err.print(chars[i]);
        }


    }

    @Test
    public void test2(){
        String str1 = "abc123";
        char[] chars = str1.toCharArray();

        for ( int i= 0; i < chars.length/2; i++) {
            if(i == 0 || i == chars.length-1){
            }else{
                char temp = chars[i];
                chars[i] = chars[chars.length-i-1];
                chars[chars.length-i-1] = temp;
            }
            }
        System.out.println(chars);

        }
    }

关于StringBuffer和StringBuilder的使用

package com.zx.java2;

import org.junit.Test;

/**
 * 关于StringBuffer和StringBuilder的使用
 *
 * @author zx
 * @create 2022-08-18 17:06
 */
public class StringBufferBuilderTest {

    /*
    String,StringBuffer,StringBuilder三者的异同
    String:不可变的字符序列,底层使用char[门存储;
    StringBuffer:可变的字符序列,线程安全的，效率比较低,底层使用char[门存储;
    StringBuilder:可变的字符序列，非线程安全,效率比较高,底层使用char[门存储;
     */

    @Test
    public void test() {
        StringBuffer buffer = new StringBuffer("abc");
        buffer.setCharAt(0, 'b');
        System.out.println(buffer);

    }


    /*
    StringBuffer的常用方法:
stringBuffer append(xxx):提供了很多的append()方法，用于进行字符串拼接
stringBuffer delete(int start,int end):删除指定位置的内容
stringBuffer replace(int start, int end,String str):把[start,end)位置替换为
strstringBuffer insert(int offset， xxx):在指定位置插入xxx
StringBuffer reverse() :把当前字符序列逆转
public int indexof (String str)
public string substring(int start,int end)public int length()
public char charAt(int n )
public void setCharAt(int n ,char ch)
     */
    @Test
    public void test2() {
        StringBuffer buffer = new StringBuffer("abc");
        buffer.append(1);
        buffer.append('1');
        System.out.println(buffer);
        //buffer.delete(2,4);
        //buffer.replace(2,4,"hello");
        //buffer.insert(2,false);
        buffer.reverse();
        System.out.println(buffer.substring(1, 3));//substring有返回值，沒有在原本的buffer上改變
        System.out.println(buffer);


    }

}

posted @ 2022-08-18 17:03 帆再小也能远航阅读(47) 评论(0) 收藏举报

刷新页面返回顶部

帆再小也能远航

坚持学习，嗨害嗨

java常用类String

java常用类String

理解String的不可变性

String不同实例化方式的对比

经典面试题

String的常用方法

String类型与基本数据类型，包装类的转换

String和char[]的转换

关于StringBuffer和StringBuilder的使用

公告