java — 认识String类的常用方法（上）

痛定思痛。 2023-10-05 23:30 1阅读 0赞

#### 文章目录 ####

*   *  1 字符串构造
     *  2 String对象的比较
     *  3 字符串查找
     *  4 转化
     *  5 字符串替换
     *  6 字符串拆分
     *  7 字符串截取
     *  8. 其他操作方法

### 1 字符串构造 ###

String类提供的构造方式非常多，常用的就以下三种：

*  使用常量串构造。
 *  直接newString对象。
 *  使用字符数组进行构造。

public static void main(String[] args) {
        
        // 使用常量串构造
        String s1 = "hello world";
        System.out.println(s1);
            
        // 直接newString对象
        String s2 = new String("hello world");
        System.out.println(s1);
            
        // 使用字符数组进行构造
        char[] array = {
        'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'};
        String s3 = new String(array);
        System.out.println(s1);
    }

1.  String是引用类型，内部并不存储字符串本身。

public static void main(String[] args) {
        
         // s1和s2引用的是不同对象 s1和s3引用的是同一对象
         String s1 = new String("hello");
         String s2 = new String("world");
         String s3 = s1;
         // 获取字符串长度---输出5
         System.out.println(s1.length()); 
         // 如果字符串长度为0，返回true，否则返回false
         System.out.println(s1.isEmpty());
    }

![b12b72708b2f462e8db5a15357cb717e.png][]  
  
  
![7e21ff09fac7417c8d6c1ee0223dc361.png][]

1.  在Java中“”引起来的也是String类型对象。

// 打印"hello"字符串(String对象)的长度
    System.out.println("hello".length());

### 2 String对象的比较 ###

1.  **==比较是否引用同一个对象**。

注意：

对于内置类型，== 比较的是变量中的值；

对于引用类型 == 比较的是引用中的地址。

public static void main(String[] args) {
        
            int a = 100;
            int b = 200;
            int c = 100;
    
            // 对于基本类型变量，== 比较两个变量中存储的值是否相同
            System.out.println(a == b); // false
            System.out.println(a == c); // true
    
            // 对于引用类型变量，== 比较两个引用变量引用的是否为同一个对象
            String str1 = new String("abcdef");
            String str2 = new String("abcdef");
            String str3 = new String("abc");
            String str4 = str1;
            System.out.println(str1 == str2); // false
            System.out.println(str2 == str3); // false
            System.out.println(str1 == str4); // true
    }

![74424f1a324a419f8b7db0c920cbfc77.png][]

1.  **boolean equals(Object anObject) 方法：按照字典序比较**。

字典序：字符大小的顺序

public static void main(String[] args) {
        
         String s1 = new String("abcdef");
         String s2 = new String("abcdef");
         String s3 = new String("abc");
    
         // s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
         System.out.println(s1 == s2); // false
         System.out.println(s1 == s3); // false
    
         // equals比较：String对象中的逐个字符
         // 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
         // s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
         System.out.println(s1.equals(s2)); // true
         System.out.println(s1.equals(s3)); // false
    }

![535f4a91518f48528f4237d5b478512a.png][]

1.  **int compareTo(String s) 方法: 按照字典序进行比较**。、

与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：

*  . 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值。
 *  如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值。

public static void main(String[] args) {
        
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("abc");
        String s4 = new String("abcdef");
        System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
        System.out.println(s1.compareTo(s3)); // 相同输出 0
        System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
    }

![b661d8700d084d16951a5afa1f31b3e0.png][]

1.  **int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较**。

public static void main(String[] args) {
        
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("ABc");
        String s4 = new String("abcdef");
        System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
        System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
        System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
    }

![03c2dc746dd349a5b2cb030296a9624b.png][]

### 3 字符串查找 ###

> **char charAt(int index)** 返回index位置上字符，如果index为负数或者越界，抛出IndexOutOfBoundsException异常

> **int indexOf(int ch)** 返回ch第一次出现的位置，没有返回-1

> **int indexOf(int ch, int fromIndex)** 从fromIndex位置开始找ch第一次出现的位置，没有返回-1

> **int indexOf(String str)** 返回str第一次出现的位置，没有返回-1

> **int indexOf(String str, int fromIndex)** 从fromIndex位置开始找str第一次出现的位置，没有返回-1

> **int lastIndexOf(int ch)** 从后往前找，返回ch第一次出现的位置，没有返回-1

> **int lastIndexOf(int ch, int fromIndex)** 从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1

> **int lastIndexOf(String str)** 从后往前找，返回str第一次出现的位置，没有返回-1

> **int lastIndexOf(String str, intfromIndex)** 从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

public static void main(String[] args) {
        
         String s = "abcdefghijkopqrstovwxyz";
         System.out.println(s.charAt(3)); //d
         System.out.println(s.indexOf('c')); //2
         System.out.println(s.indexOf('c', 10)); //-1
         System.out.println(s.indexOf("bbb")); //-1
         System.out.println(s.indexOf("bbb", 10)); //-1
         System.out.println(s.lastIndexOf('c')); //2
         System.out.println(s.lastIndexOf('c', 10)); //2
         System.out.println(s.lastIndexOf("bbb")); //-1
         System.out.println(s.lastIndexOf("bbb", 10));//-1
    }

![fc5454c8f871456088d8db544e0903d8.png][]  
  
上述方法都是实例方法。

### 4 转化 ###

1.  **数值和字符串转化**

public static void main(String[] args) {
        
            //数字转字符串
            String s1 = String.valueOf(1234);
            String s2 = String.valueOf(12.34);
            String s3 = String.valueOf(true);
            String s4 = String.valueOf(false);
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);
            System.out.println("=================================");
            //字符串转数字
            //注意：Integer、Double等是Java中的包装类型，这个后面会讲到
            int data1 = Integer.parseInt("1234");
            double data2 = Double.parseDouble("12.34");
            System.out.println(data1);
            System.out.println(data2);
    }

![4fbb22daaa214814ba53d529a9930a97.png][]

1.  **大小写转换**

public static void main(String[] args) {
        
          String s1 = "abc";
          String s2 = "ABC";
          //将s1转成大写输出
          System.out.println(s1.toUpperCase());
          //将s2转成小写输出
          System.out.println(s2.toLowerCase());
    }

![0c170abf711b4a3dbba2f5199bd800c6.png][]

1.  **字符串转数组**

public static void main(String[] args) {
        
         String str = "abcdef";
         // 字符串转数组
         char[] ch = str.toCharArray();
         for (int i = 0; i < ch.length; i++) {
        
             //输出字符串的每一个字符
             System.out.print(ch[i]);
         }
         System.out.println();
         // 数组转字符串
         String s2 = new String(ch);
         System.out.println(s2);
    }

1.  **格式化**

public static void main(String[] args) {
        
        String str = String.format("%d-%d-%d", 2022, 9,12);
        System.out.println(str);
    }

### 5 字符串替换 ###

用一个新的字符串替换掉一个旧的字符串。

![4c2a35122cff42e28cd0f891422cef3c.png][]

public static void main(String[] args) {
        
        String str = "ILoveChiina ILoveFriend";
        System.out.println(str.replaceAll("I", "You"));
        System.out.println(str.replaceFirst("I", "You"));
    }

System.out.println(str.replaceAll(“I”, “You”));  
这段代码的意思是，将字符串中所有的"I"字母全部转变为"You"。

System.out.println(str.replaceFirst(“I”, “You”));  
这段代码的意思是，将字符串中的第一个"I"字母转变为"You"。  
  
![f67ac24dadad417d87f636c52b9d7e82.png][]  
  
**注意事项:**

由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串

### 6 字符串拆分 ###

将一个完整的字符串按照指定的分隔符划分为若干个子字符串

> **String\[\] split(String regex)** 将字符串全部拆分

> **String\[\] split(String regex, int limit)** 将字符串以指定的格式，拆分为limit组

按空格拆分

public static void main(String[] args) {
        
         String str = "hello world hello LiHua" ;
         String[] result = str.split(" ") ; //按照空格拆分
         for(String s: result) {
        
             System.out.println(s);
         }
    }

![01ab55965445463d8857ba500abcb231.png][]  
  
  
按字符串部分拆分

String\[\] result = str.split(" ",2) ;  
这段代码中的双引号表示根据什么分隔符拆分；数字表示根据当前分隔符拆成多少个字符串。

public static void main(String[] args) {
        
            String str = "hello world hello LiHua" ;
            String[] result = str.split(" ",2) ;
            for(String s: result) {
        
                System.out.println(s);
            }
        }

![3e5ba896859441909cb67c27d8d67959.png][]  
  
有些特殊字符作为分割符可能无法正确切分，需要加上转义。

拆分一个IP地址

public static void main(String[] args) {
        
            String str = "192.168.10.10" ;
            String[] result = str.split("\\.") ;
            for(String s: result) {
        
                System.out.println(s);
            }
    }

![dd6f4c9ba5b249dfbfd11f99ec0d6c97.png][]  
  
注意事项:

*  字符"|“,”\*“,”+"都得加上转义字符，前面加上 “\\” 。
 *  而如果是 “” ，那么就得写成 “\\\\” 。
 *  如果一个字符串中有多个分隔符，可以用"|"作为连字符。

public static void main(String[] args) {
        
        String str = "name=zhangsan&age=19";
        String[] result = str.split("&");
        for (int i = 0; i < result.length; i++) {
        
            String[] temp = result[i].split("=");
            System.out.println(temp[0] + " = " + temp[1]);
    
        }
     }

![04163be36b7340e58f139b67f029a3f4.png][]

### 7 字符串截取 ###

从一个完整的字符串之中截取出部分内容。

> **String substring(int beginIndex)** 从指定索引截取到结尾

> **String substring(int beginIndex, int endIndex)** 截取部分内容

public static void main(String[] args) {
        
        String str  = "helloworld";
        System.out.println(str.substring(5));
           
    }

截取结尾5个字符

![0f269088ee264767a7d8f7fd97d90610.png][]

指定截取部分

public static void main(String[] args) {
        
         String str  = "helloworld";
         System.out.println(str.substring(0, 5));
     }

![ad95147ada784685999e506ef0008fcf.png][]

第一个参数表示从第0个字符开始截取；第二个参数表示到第5个字符截取结束。

注意事项:

*  索引从0开始
 *  注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标

### 8. 其他操作方法 ###

![fc895ead7c0443059ba8e9075f7baec1.png][]  
  
trim()方法的使用

public static void main(String[] args) {
        
         String str1 = " zhang san " ;
         String str2 = " hello java ";
         System.out.println("["+str1+"]");//去除前str1
         System.out.println("["+str2+"]");//去除前str2
         System.out.println("----------------------------");
         System.out.println("["+str1.trim()+"]");//去除后str1
         System.out.println("["+str2.trim()+"]");//去除后str2
     }

![5b111fa03a8c40b48aa3e2e1d47d9fbb.png][]

trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等)。

toUpperCase()的使用

将字符串中的所有字母转成大写，这里注意是所有的字母并不是所有的字符。

public static void main(String[] args) {
        
        String str = "hello world&111222&java!";
        System.out.println(str.toUpperCase());
            
    }

![4facd68448d846509c67c5b644510143.png][]

toLowerCase()的使用

将字符串中的所有字母转成小写，这里注意是所有的字母并不是所有的字符。

public static void main(String[] args) {
        
         String str = "HELLO WORLD&111222&JAVA!";
         System.out.println(str.toLowerCase());
     }

![b793642a8f78483c89505ba72c83cccb.png][]

[b12b72708b2f462e8db5a15357cb717e.png]: https://img-blog.csdnimg.cn/b12b72708b2f462e8db5a15357cb717e.png
[7e21ff09fac7417c8d6c1ee0223dc361.png]: https://img-blog.csdnimg.cn/7e21ff09fac7417c8d6c1ee0223dc361.png
[74424f1a324a419f8b7db0c920cbfc77.png]: https://img-blog.csdnimg.cn/74424f1a324a419f8b7db0c920cbfc77.png
[535f4a91518f48528f4237d5b478512a.png]: https://img-blog.csdnimg.cn/535f4a91518f48528f4237d5b478512a.png
[b661d8700d084d16951a5afa1f31b3e0.png]: https://img-blog.csdnimg.cn/b661d8700d084d16951a5afa1f31b3e0.png
[03c2dc746dd349a5b2cb030296a9624b.png]: https://img-blog.csdnimg.cn/03c2dc746dd349a5b2cb030296a9624b.png
[fc5454c8f871456088d8db544e0903d8.png]: https://img-blog.csdnimg.cn/fc5454c8f871456088d8db544e0903d8.png
[4fbb22daaa214814ba53d529a9930a97.png]: https://img-blog.csdnimg.cn/4fbb22daaa214814ba53d529a9930a97.png
[0c170abf711b4a3dbba2f5199bd800c6.png]: https://img-blog.csdnimg.cn/0c170abf711b4a3dbba2f5199bd800c6.png
[4c2a35122cff42e28cd0f891422cef3c.png]: https://img-blog.csdnimg.cn/4c2a35122cff42e28cd0f891422cef3c.png
[f67ac24dadad417d87f636c52b9d7e82.png]: https://img-blog.csdnimg.cn/f67ac24dadad417d87f636c52b9d7e82.png
[01ab55965445463d8857ba500abcb231.png]: https://img-blog.csdnimg.cn/01ab55965445463d8857ba500abcb231.png
[3e5ba896859441909cb67c27d8d67959.png]: https://img-blog.csdnimg.cn/3e5ba896859441909cb67c27d8d67959.png
[dd6f4c9ba5b249dfbfd11f99ec0d6c97.png]: https://img-blog.csdnimg.cn/dd6f4c9ba5b249dfbfd11f99ec0d6c97.png
[04163be36b7340e58f139b67f029a3f4.png]: https://img-blog.csdnimg.cn/04163be36b7340e58f139b67f029a3f4.png
[0f269088ee264767a7d8f7fd97d90610.png]: https://img-blog.csdnimg.cn/0f269088ee264767a7d8f7fd97d90610.png
[ad95147ada784685999e506ef0008fcf.png]: https://img-blog.csdnimg.cn/ad95147ada784685999e506ef0008fcf.png
[fc895ead7c0443059ba8e9075f7baec1.png]: https://img-blog.csdnimg.cn/fc895ead7c0443059ba8e9075f7baec1.png
[5b111fa03a8c40b48aa3e2e1d47d9fbb.png]: https://img-blog.csdnimg.cn/5b111fa03a8c40b48aa3e2e1d47d9fbb.png
[4facd68448d846509c67c5b644510143.png]: https://img-blog.csdnimg.cn/4facd68448d846509c67c5b644510143.png
[b793642a8f78483c89505ba72c83cccb.png]: https://img-blog.csdnimg.cn/b793642a8f78483c89505ba72c83cccb.png