Java篇String类的常见方法

最新推荐文章于 2025-03-08 16:28:36 发布

爱编程的小新☆

最新推荐文章于 2025-03-08 16:28:36 发布

阅读量1.6w

点赞数 209

分类专栏： JavaSE 文章标签： java 开发语言学习

本文链接：https://blog.csdn.net/2402_86304740/article/details/143365403

版权

JavaSE 专栏收录该内容

7 篇文章

订阅专栏

3.3.2 compare To( )方法

3.3.3 compare ToIgnoreCase( )方法

3.4 字符串替换

3.4.1 replace( )方法

3.4.2 replaceFrist( )方法

3.4.3 replaceAll( )方法

3.5 字符串拆分

3.5.1 String[] split(String regex)

3.5.2 String[] split(String regex, int limit)

3.6 字符串截取

3.6.1 String substring(int beginIndex)

3.6.2 String substring(int beginIndex, int endIndex)

编辑四.StringBuilder和StringBuffer

4.1 append(String str)

4.2 setCharAt(int index, char ch)

4.3 reverse( )

4.4 capacity( )

4.5 ensureCapacity(int mininmumCapacity)

4.6 insert(int offset, String str)

4.7 deleteCharAt(int index)

4.8 replace(int start, int end, String str)

结语

一. String类的概念

在Java中 String类是用于表示和操作字符串的类，字符串是Java中常用的数据类型，用于存储文本信息，并且String类中提供了许多方法用来执各种字符串操作，那么我们随着下文来学习一下常见的方法。

1.1 String类的特性

1. 不可变性：

String 对象是不可变的，一旦创建了 String 对象，其里面的内容就不能被修改，对 String的任何操作实际上都是创建了一个新的 String 对象。

注意：不能修改指的是：String对象的内容不能修改，而指向String对象的引用是可以修改的

2. 常量池的概念

字符串常量池是Java中用于存储字符串字面量的内存区域，为了节省内存，Java使用字符常量池来存储字符串字面量，当创建相同的字符串字面量时，它们会引用常量池中的同一个对象，从而降低程序内存的开销。

二. 字符串的构造方式

1. 使用字符串字面量构造


public class Test {
    public static void main(String[] args) {
        String s1 = "hello world"; //直接使用字符串字面量进行构造
        System.out.println(s1);
    }
}

2. 通过new关键字创建一个String对象

public class Test {
    public static void main(String[] args) {
        String s2 = new String("hello world");//通过new关键字创建对象
        System.out.println(s2);
    }
}

3.使用字符数组进行构造

public class Test {
    public static void main(String[] args) {
        char[] str = {'h','e','l','l','o','w','o','r','l','d'};
        String s3 = new String(str); //使用字符数组进行构造
        System.out.println(s3);
    }
}

以上就是最常见的最常见的字符串构造方式。

三. 常用方法

3.1 字符串查找

（1）char charAt( int index)

public class Test {
    public static void main(String[] args) {
        String str="hello world";
        char ch=str.charAt(1);
        System.out.println(ch);//e
    }
}

如果输入一个不合法的下标位置，就会发生报错：

（2）int indexOf( int ch)

public class Test {
    public static void main(String[] args) {
        String str="hello world";
        int n=str.indexOf('l');
        System.out.println(n); //2
    }
}

（3）int indexOf(int ch, int fromIndex)

public class Test {
    public static void main(String[] args) {
        String str="hello world";
        int n=str.indexOf('o',6);
        //从下标为6的位置(w)开始往后查找o的位置,7
        System.out.println(n);
    }
}

（4）int indexOf(String str)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.indexOf("wor");
        // 返回wor第一次出现的位置，没有返回-1,所以返回值为6
        System.out.println(n);
    }
}

（5）int indexOf(String str, int fromIndex)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.indexOf("wor",8);
        //从下标为8的位置开始找wor第一次出现的位置，没有返回-1,所以这里返回值为11
        System.out.println(n);
    }
}

（6）int lastIndexOf(int ch)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.lastIndexOf('w');
        //从后往前找，返回w第一次出现的位置，没有返回-1,所以返回值为11
        System.out.println(n);
    }
}

（7）int lastIndexOf(int ch, int fromIndex)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.lastIndexOf('w',10);
        //从下标10的位置开始找，从后往前找w第一次出现的位置，没有返回-1，所以返回值为6
        System.out.println(n);
    }
}

（8）int lastIndexOf(String str)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.lastIndexOf("wor");
        //从后往前找，返回wor第一次出现的位置，没有返回-1,返回值为11
        System.out.println(n);
    }
}

（9）int lastIndexOf(String str, int fromIndex)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.lastIndexOf("wor",10);
        //从下标为10的位置开始找，从后往前找wor第一次出现的位置，没有则返回-1，这里返回值为6
        System.out.println(n);
    }
}

3.2 字符串转换

（1）数值和字符串转化

数值转换成字符串，用String.valueOf( )进行转换：

public class Test {
    public static void main(String[] args) {
        // 数字转字符串
        String s1 = String.valueOf(123456);
        String s2 = String.valueOf(13.14521);
        System.out.println(s1);
        System.out.println(s2);
    }
}

数字字符串转换成数字，用 Interger.valueOf( )进行转换：

public class Test {
    public static void main(String[] args) {
        // 字符串转数字
        int n= Integer.valueOf("1234");
       double m= Double.valueOf("12.13");
        System.out.println(n);
        System.out.println(m);
    }
}

并且我们也可以传数字字符串，所需要转换的进制数：

public class Test {
    public static void main(String[] args) {
        // 字符串转数字
       int n=Integer.valueOf("1111",2);
       //后面的2表示，前面的数字字符串中的数字是2进制的形式，我们转换成10进制形式
        //就是15
        System.out.println(n);
    }
}

（2）字母的大小写转换

字母大小写转换我们使用String.toUpperCase----小写转大写和 String.toLowerCase----大写转小写

public class Test {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
    // 小写转大写
        System.out.println(s1.toUpperCase());//HELLO
    // 大写转小写
        System.out.println(s2.toLowerCase());//hello
    }
}

（3）字符串转数组

我们还可以将一个字符串转换成一个数组，使用String.toCharArray( )方法进行转换：

public class Test {
    public static void main(String[] args) {
        String s = "hello";
        // 字符串转数组
        char[] ch = s.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            System.out.print(ch[i]);
        }
    }
}

（4）格式化字符串

我们可以使用String.format( )方法进行字符串的格式化：

public class Test {
    public static void main(String[] args) {
        String s = String.format("%d-%d-%d", 2024, 10,30);
        System.out.println(s);
        //打印2024-10-30
    }
}