java 字符串

ayuecry

于 2022-06-29 19:08:07 发布

阅读量205

点赞数

文章标签： java

本文链接：https://blog.csdn.net/ayuecry/article/details/125502436

版权

字符串是一个字符序列

引用数据类型

且字符串一旦创建内容就不可再变！

构造字符串方式：

① String newString = new String("aaa") 创建一个新的对象

② String newString1 = "aaa"

③ char[] charArray = {'G', 'o', 'o', 'd'}

String newString = new String(charArray)

因为字符串在程序设计中是不可变的，但同时有会频繁的使用，所以java虚拟机为了提高效率并节约内存，对具有相同字符序列的字符串字面值使用同一个实例，这样的实例称为驻留字符串，例如：

public class StringTest04 {
    public static void main(String[] args) {
        String s1 = "Welcome to Java";

        String s2 = new String("Welcome to Java");

        String s3 = "Welcome to Java";

        String s4 = new String("Welcome to Java");

        System.out.println("s1 == s2 is " + (s1 == s2));  // s1 == s2 is false
        System.out.println("s1 == s3 is " + (s1 == s3));  // s1 == s3 is true
        System.out.println("s2 == s4 is " + (s2 == s4));  // s2 == s4 is false
    }
}

1. 常用的实例方法：

方法	描述
length()	返回字符串中的字符数
charAt(index)	返回字符串中指定位置的字符
concat(s1)	将本字符串和字符串s1连接，返回一个新的字符串
toUpperCase()	返回一个新字符串，其中所有的字母大写
toLowerCase()	返回一个新字符串，其中所有的字母小写
trim()	返回一个新字符串，去掉了两边的空白字符

public class StringTest {
    public static void main(String[] args) {
        // length() 获取字符串长度
        String string = "hello everyone";
        System.out.println("这个字符串" + string + "的长度是：" + string.length());  // 这个字符串hello everyone的长度是：14

        // charAt(index) 获取指定位置的字符
        System.out.println("本字符串的第一个字符是：" + string.charAt(0));  // 本字符串的第一个字符是：h
        //System.out.println(string.charAt(14));  // java.lang.StringIndexOutOfBoundsException: String index out of range: 14

        // concat(s1) 拼接字符串，返回一个新的字符串
        String s1 = "!";
        System.out.println("拼接后的字符串是：" + string.concat(s1));  // 拼接后的字符串是：hello everyone!
        System.out.println("此字符串仍然是：" + string);  // 此字符串仍然是：hello everyone

        // toUpperCase() 使字符串字母全部大写,返回一个新的字符串
        System.out.println("使字符串中的字母全部大写：" + string.toUpperCase());  // 使字符串中的字母全部大写：HELLO EVERYONE

        // toLowerCase() 使字符串字母全部小写,返回一个新的字符串
        System.out.println("使字符串中的字母全部小写：" + string.toLowerCase());  // 使字符串中的字母全部小写：hello everyone

        String msg = "   aaa aaa ";
        System.out.println("去除空格前的字符串：" + msg);  // 去除空格前的字符串：   aaa aaa 
        System.out.println("去除空格后的字符串：" + msg.trim());  // 去除空格后的字符串：aaa aaa
    }
}

2.字符串比较

String对象的比较方法
方法	描述
equals(s1)	如果该字符串等于字符串s1，返回true
equalsIgnoreCase(s1)	如果该字符串等于字符串s1，返回true，不区分大小写
compareTo(s1)	返回一个大于0、等于0、小于0的整数，表明该字符串是否大于、等于或者小于s1
compareToIgnoreCase(s1)	同compareTo(s1)一样，除了比较的是不区分大小写
startsWith(prefix)	如果字符串以特定的前缀开始，返回true
endsWith(suffix)	如果字符串以特定的后缀结束，返回true
contains(s1)	如果s1是该字符串的子串，返回true

public class StringTest01 {
    public static void main(String[] args) {
        // equals(s1) 比较两个字符串的内容是否相等
        // equalsIgnoreCase(s1) 忽略大小写的比较两个字符串内容是否相等
        String s1 = new String("aaa");
        String s2 = new String("aaa");
        String s3 = new String("aAa");
        // 在判断引用数据类型时：==，判断的是两个等号两边对象地址是否一样（判断是不是表示统一对象）
        //                   equals，是判断两个字符串对象的内容是否一样
        System.out.println(s1==s2);  // false
        System.out.println(s1.equals(s2));  // true
        System.out.println(s1.equalsIgnoreCase(s3));  // true

        // compareTo(s1) 比较两个字符串的大小
        // compareToIgnoreCase(s1) 忽略大小写的情况下，比较两个字符串的大小
        // 返回大于0的整数表示大于s1，等于0表示两者相等，小于0的整数表示小于s1
        String s4 = "a";
        String s5 = "b";
        System.out.println(s4.compareTo(s5));  // -1
        String s6 = "1";
        String s7 = "0";
        System.out.println(s6.compareTo(s7));  // 1
        String s8 = "我";
        String s9 = "我";
        System.out.println(s8.compareTo(s9));  // 0
        String s10 = "我的";
        System.out.println(s8.compareTo(s10));  // -1

        // startsWith(prefix) 判断字符串是否以特定前缀开始
        // endsWith(suffix) 判断字符串是否以特定后缀结束, 没有第二个参数
        String s11 = "skip unstable case";
        System.out.println(s11.startsWith("skip"));  // true
        System.out.println(s11.startsWith("skip", 1));  // false  public boolean startsWith(String prefix, int toffset)  toffset是偏移量的意思，表示从某个特定的位置开始
        System.out.println(s11.endsWith("case"));  // true

        // contains(s1) 判断s1是否是该字符串的子串
        System.out.println(s11.contains("unstable"));  // true
        System.out.println(s11.contains("unstabla"));  // false
    }
}

3.截取字符串

获取字符串的子串
方法	描述
substring(beginIndex)	返回该字符串的子串，从指定位置beginIndex的字符开始到字符串的结尾
substring(beginIndex, endIndex)	返回该字符串的子串，从指定位置beginIndex的字符开始到下标为endIndex-1的字符，位于endIndex位置的字符不属于该字符串的一部分

public class StringsTest02 {
    public static void main(String[] args) {
        // 获取（截取）字符串  substring(beginIndex, endIndex) endIndex是可选参数。
        // beginIndex表示要截取的字符串开始位置下标，endIndex表示要截取的字符串的结束位置的下标，默认值是最后一个
        // 返回该字符串的子串，从指定位置beginIndex的字符开始到下标为endIndex-1的字符
        String str = "Welcome to Java";
        System.out.println(str.substring(0, 10));  // Welcome to
        System.out.println(str.substring(0));  // Welcome to Java
        System.out.println(str.substring(0, 20));  // java.lang.StringIndexOutOfBoundsException: String index out of range: 20
    }
}

4. 获取字符串中指定字符或子串的下标

方法	描述
indexOf(ch)	返回字符串出现的第一个ch的下标。如果没有匹配的，返回-1.
indexOf(ch, fromIndex)	返回字符串中fromIndex之后出现的第一个ch的下标。如果没有匹配的，返回-1.
indexOf(s)	返回字符串中出现的第一个字符串s的下标。如果没有匹配的，返回-1.
indexOf(s, fromIndex)	返回字符串中fromIndex之后出现的第一个字符串s的下标。如果没有匹配的，返回-1.
lastIndexOf(ch)	返回字符串出现的最后一个ch的下标。如果没有匹配的，返回-1.
lastIndexOf(ch, fromIndex)	返回字符串中fromIndex之前出现的最后一个ch的下标。如果没有匹配的，返回-1.
lastIndexOf(s)	返回字符串出现的最后一个字符串s的下标。如果没有匹配的，返回-1.
lastIndexOf(s, fromIndex)	返回字符串中fromIndex之前出现的最后一个字符串s的下标。如果没有匹配的，返回-1.

源码：

public class StringTest03 {
    public static void main(String[] args) {

        String str = "String index out of range: 20";
        // indexOf(ch)
        System.out.println(str.indexOf('i'));  // 3
        // indexOf(ch, fromIndex)
        System.out.println(str.indexOf('i', 3));  // 3
        System.out.println(str.indexOf('i', 4));  // 7
        // indexOf(s)
        System.out.println(str.indexOf("in"));  // 3  返回的是i的下标
        // indexOf(s, fromIndex)
        System.out.println(str.indexOf("in", 4));  // 7  返回的是i的下标
        // lastIndexOf(ch)
        System.out.println(str.lastIndexOf('i'));  // 7
        // lastIndexOf(ch, fromIndex)
        System.out.println(str.lastIndexOf('i', 20));  // 7
        System.out.println(str.lastIndexOf('i', 6));  // -1
        // lastIndexOf(s)
        System.out.println(str.lastIndexOf("in"));  // 7
    }
}

5.替换、匹配、拆分字符串(几个方法都可以搭配正则表达式来使用)

字符串的替换、拆分、匹配方法
方法	描述
replace(oldChar: char, newChar: char): String	将字符串中所有匹配的字符（或字符串）替换成新的字符（或字符串），然后返回新的字符串
replaceFirst(oldString, newString): String	将字符串中第一个匹配的子字符串替换成新的子字符串，然后返回新的字符串
replaceAll(oldString, newString): String	将字符串中所有匹配的子字符串替换成新的子字符串，然后返回新的字符串
split(delimiter: String): String[]	返回一个字符串数组，其中包含被分隔符拆分的子字符串集
matches( regular expression：String )	当给的参数能够匹配字符串，返回true，否则返回flase

import java.util.Arrays;

public class StringTest05 {
    public static void main(String[] args) {
        String str = "Welcome";
        String str1 = "我的啊的姑的娘";
        String str2 = "Welecome";
        char ch = 0;
        // replace(oldChar: char, newChar: char): String
        System.out.println(str.replace('e', 'A'));  // WAlcomA
        System.out.println(str.replace("e", "a"));  // Walcoma

        // replaceFirst(oldString, newString): String
        System.out.println(str.replaceFirst("e", "a"));  // Walcome

        // replaceAll(oldString, newString): String
        System.out.println(str.replaceAll("e", "a"));  // Walcoma

        // split(delimiter: String): String[]
        System.out.println(Arrays.toString(str1.split("的")));  // [我, 啊, 姑, 娘]
        System.out.println(Arrays.toString(str2.split("e")));  // [W, l, com]

        // matches()
        System.out.println("Java is fun".matches("Java.*"));  // true

    }
}

6.字符串与数组之间的转换

① 字符串转化成数组

public class StringTest06 {
    public static void main(String[] args) {
        char[] chars = "java".toCharArray();
        char[] chars1 = {'j', 'a', 'v', 'a'};
        // char[] chars2 = "java";  这种方式不行
        System.out.println(chars);  // java
        System.out.println(chars1);  // java
        System.out.println("java".toCharArray());  // java
        
    }
}

② valueOf() 静态方法

方法	描述
valueOf(c: char) : String	返回包含字符c的字符串
valueOf(data: cha[]) : String	返回包含数组中字符的字符串
valueOf(d: double) : String	返回double值的字符串表示
valueOf(f: float) : String	返回float值的字符串表示
valueOf(i: int) : String	返回int值的字符串表示
valueOf(l: long) : String	返回long值的字符串表示
valueOf(b: boolean) : String	返回boolean值的字符串表示

7. 格式化字符串：format的使用静态方法

语法：String.format(format, item1, item2, ... ,itemk)

表1 常规转换符
转换符	说明	示例
%b、%B	格式化为布尔类型	false
%h、%H	格式化为散列码	A05A5198
%s、%S	格式化为字符串类型	"abc"
%c、%C	格式化为字符类型	'w'
%d	格式化为十进制数	26
%0	格式化为八进制整数	12
%x、%X	格式化为十六进制整数	4b 1
%e	格式化为用计算机科学计数法表示的十进制数	1.700000e+01
%a	格式化为带有效位数和指数的十六进制浮点值	0X1.C000000000001P4
%n	结果为特定于平台的行分隔符
%%	结果为字面值％，	%

示例

使用 String 类的 format 方法实现将“400/2”返回结果类型转换为字符串，并将“3>5”返回结果格式化为布尔类型。

String str = String.format("%d",400/2);
String str2 = String.format("%b",3>5);

将字符串 str 与 str2 在控制台上输出，输出结果如下：
200
false

表2 常见的日期和时间转换符
转换符	说明	示例
%te	一个月中的某一天（1〜31）	12
%tb	指定语言环境的月份简称	Jan （英文）、一月（中文）
%tB	指定语言环境的月份全称	February （英文）、二月（中文）
%tA	指定语言环境的星期几全称	Monday （英文）、星期一（中文）
%ta	指定语言环境的星期几简称	Mon （英文）、星期一（中文）
%tc	包括全部日期和时间信息	星期三十月 25 13:37:22 CST 2008
%tY	4位年份	2008
%tj	一年中的第几天（001〜366）	060
%tm	月份	05
%td	一个月中的第几天（01〜31）	07
%ty	两位年份	08

典型应用

String 类的 format 方法可以格式化日期和时间，本示例实现将当前日期以 4 位年份、月份全称、两位日期形式输出。

本示例的关键代码如下：

public static void main(String[] args){
    Date date=new Date();//定义Date类对象
    Locale form=Locale.US;
    String year=String.format(form,"%tY",date);//将当前年份进行格式化
    String month=String.format(form,"%tB",date);//将当前月份进行格式化
    String day=String.format(form,"%td",date);//将当前日期进行格式化
    System.out.println("今年是:"+year+"年");//将格式化后的日期输出
    System.out.println("现在是:"+month);
    System.out.println("今天是:"+day+"号");
}

运行结果：

今年是:2022年
现在是:June
今天是:29号