当前位置：首页 > article >正文

Java篇String类的常见方法

article 2024/11/19 15:09:26

一. String类的概念

1.1 String类的特性

二. 字符串的构造方式

三. 常用方法

3.1 字符串查找

3.2 字符串转换

3.3 字符串比较

3.3.1 equals( )方法

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
    }
}