String类中的常用方法的使用

ゝ一世哀愁。 2023-01-11 09:22 105阅读 0赞

### String ###

*  认识String类
 *   *  常见构建String类的方式
 *  String常见方法
 *   *  length()
     *  charAt()
     *  toCharArray()
     *  indexOf()
     *  lastIndexOf()
     *  substring()
     *  replace()
     *  split()
     *  static join()
     *  toLowerCase()
     *  toUpperCase()
     *  contains()
     *  concat()
     *  statsWith()
     *  endsWith()
     *  trim()
 *  字符串的比较
 *   *  1、==
     *  2、equals()和equalsIgnoreCase()
     *  3、compareTo()和compareToIgnoreCase()
     *  4、isEmpty()
 *  StringBuilder

# 认识String类 #

## 常见构建String类的方式 ##

方式1：

String str1 = "hello world";

方式2：

String str2 = new String("hello world");

方式3：

char[] arr = { 'a', 'b', 'c'};
        String str3 = new String(arr);

注意：  
String是引用类型，str指向一个对象。  
String类型一旦创建，就很难被修改。

# String常见方法 #

## length() ##

获取字符串的长度，这里需要注意的是和数组中长度的length的区别，这里的length（）是方法。

public static void main(String[] args) { 
            String s = "hello world";
            int a = s.length();
            System.out.println(a);
        }

结果是：11

## charAt() ##

获取指定位置的字符，下标从0开始

public static void main(String[] args) { 
            String s = "hello world";
            char a=s.charAt(1);
            System.out.println(a);
        }

结果是：e

## toCharArray() ##

将字符串变为字符数组返回

public static void main(String[] args) { 
            String s = "hello world";
            char[]arr =s.toCharArray();
          
            System.out.println(Arrays.toString(arr));
        }

结果是：\[h, e, l, l, o, , w, o, r, l, d\]

注意  
学会前面三种方式，我们就可以遍历字符串了，可以将字符串转换为字符数组，采用for或者for-each循环遍历字符数组。

## indexOf() ##

（指定位置）从前向后，查找指定字符串的位置，查到了返回其所在位置索引，没找到返回-1

public static void main(String[] args) { 
            String s = "hello world hello java！";
            int a= s.indexOf('h');
            int b=s.indexOf('z');
            int c=s.indexOf("hello");
            int d=s.indexOf("hello",3);
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
            System.out.println(d);
        }

结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70]  
indexOf会找到第一次出现的位置，并返回第一次出现的下标索引。也可以指定位置，从指定位置开始向后查找

## lastIndexOf() ##

（指定位置）从后向前，查找指定字符串的位置，查到了返回其所在位置索引，没找到返回-1

public static void main(String[] args) { 
            String s = "hello world hello java！";
            int a= s.lastIndexOf('h');
            int b=s.lastIndexOf('z');
            int c=s.lastIndexOf("hello");
            int d=s.lastIndexOf("hello",5);
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
            System.out.println(d);
        }

结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 1]  
lastIndexOf同样会找到第一次出现的位置，并返回第一次出现的下标索引。也可以指定位置，从指定位置开始向前查找

## substring() ##

从指定的位置截取到结尾（或截取到指定位置）  
注意：  
索引从0开始，才去前闭区，后开区间的方式，例如substring(0,5),表示包含0号下标，不包含5号下标

public static void main(String[] args) { 
            String s = "hello world hello java！";
            String a = s.substring(3);
            String b = s.substring(2, 10);
            System.out.println(a);
            System.out.println(b);
        }

![在这里插入图片描述][20210126202415432.png]

## replace() ##

字符串的替换，将指定字符或者字符串替换，如果要替换的字符，原字符串中没有，那么则不进行替换

public static void main(String[] args) { 
            String s = "hello world hello java！";
            String a = s.replace("o", "a");
            System.out.println(a);
            String b = s.replace('0', ' ');
            System.out.println(b);
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 2]

## split() ##

字符串的拆分成一个String \[\]的数组，以什么拆分的话，不会包含什么，且最长不超过字符串的长度

public static void main(String[] args) { 
            String s = "hello world hello java！";
            String[] a = s.split(" ");//以空格拆分
            String[] b = s.split("o", s.length());//用o拆分，数组最长不超过字符串长度
            System.out.println(Arrays.toString(a));
            System.out.println(Arrays.toString(b));
        }

![在这里插入图片描述][20210126203617748.png]

## static join() ##

将字符串拆分后，还会以什么拼接起来；  
注意这是一个静态方法，直接通过类名.join()调用

public static void main(String[] args) { 
            String s = "hello world hello java！";
            String[] a = s.split(" ");//以空格拆分
            String b = String.join("/", a);
    
            System.out.println(Arrays.toString(a));
            System.out.println(b);
        }

![在这里插入图片描述][20210126204254380.png]

## toLowerCase() ##

字符串转小写,将字符串中大写的字母转换成小写

public static void main(String[] args) { 
            String s = "Hello World Hello Java！";
            String a = s.toLowerCase();
            System.out.println(a);
        }

结果是：

> hello world hello java！

## toUpperCase() ##

字符串转大写，将字符串中小写的字母转换成大写

public static void main(String[] args) { 
            String s = "Hello World Hello Java！";
            String a = s.toUpperCase();
            System.out.println(a);
        }

结果：HELLO WORLD HELLO JAVA！

## contains() ##

当且仅当此字符串包含指定的char值序列时才返回true。  
即：查找该序列，如果其中包含有所查找的内容返回true。

public static void main(String[] args) { 
            String s = "Hello World Hello Java！";
            boolean a = s.contains("o");
            System.out.println(a);
        }

结果是：true

## concat() ##

将两个字符串拼接起来，相当于“+”

public static void main(String[] args) { 
            String s = "Hello World";
            String t="Hello Java！";
            String a = s.concat(t);
    
            System.out.println(a);
        }

![在这里插入图片描述][20210126210636758.png]

## statsWith() ##

（从指定位置开始）判断是否以指定字符串开头

public static void main(String[] args) { 
            String s = "Hello World Hello Java！";
            boolean a = s.startsWith("he");
            boolean b = s.startsWith("He");
            boolean c = s.startsWith("ll", 2);
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 3]

## endsWith() ##

判断是否以指定字符串结尾

public static void main(String[] args) { 
            String s = "Hello World Hello Java！";
            boolean a = s.endsWith("java！");
            boolean b = s.endsWith("Java！");
    
            System.out.println(a);
            System.out.println(b);
        }

结果：  
![在这里插入图片描述][20210126211450332.png]

## trim() ##

去掉字符串左右空格，换行等，保留中间的空格

public static void main(String[] args) { 
            String s = " |Hello World| |Hello Java！| \n";
            String a = s.trim();
            System.out.println(a);
    
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 4]

# 字符串的比较 #

## 1、== ##

==比较两个字符串的时候，比较的是他们是否指向同一个对象

public static void main(String[] args) { 
            String a="hello";
            String b="hello";
            System.out.println(a==b);
            String c=new String("hello");
            System.out.println(a==c);
        }

结果：

> true  
> false

因为相同内容会被java优化放在字符常量池中，所以第一个是true，因为他们都指向一个对象，第二个指向不同对象，所以是false

## 2、equals()和equalsIgnoreCase() ##

比较两个字符串的内容是否相等，前者区分大小写，后者不区分大小写，返回boolean值

public static void main(String[] args) { 
            String a = "hello";
            String b = "Hello";
            String c = "Hello";
            boolean st1 = a.equals(b);
            boolean st2 = a.equalsIgnoreCase(c);
            boolean st3 = b.equalsIgnoreCase(c);
            System.out.println(st1);
            System.out.println(st2);
            System.out.println(st3);
        }

结果：

> false  
> true  
> true

## 3、compareTo()和compareToIgnoreCase() ##

比较两个字符串的内容是否不相等，前者区分大小写，后者不区分大小写，返回值等于0表示相等，大于0 表示大于，小于0 表示小于  
例如：

public static void main(String[] args) { 
            String a = "hello";
            String b = "Hello";
            String c = "Hello";
            int st1 = a.compareTo(b);
            int st4 = b.compareTo(a);
            int st2 = b.compareTo(c);
            int st3 = a.compareToIgnoreCase(c);
            System.out.println(st1);
            System.out.println(st2);
            System.out.println(st3);
            System.out.println(st4);
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 5]

## 4、isEmpty() ##

判断是否为空字符串，但不是null，而是长度为0，即 length()==0;

public static void main(String[] args) { 
            String s1=" ";
            String s2="";
            boolean a=s1.isEmpty();
            boolean b=s2.isEmpty();
            System.out.println(a);
            System.out.println(b);
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 6]

# StringBuilder #

因为String的类型一旦创建就很难修改，而当我们想要修改的时候，就是让引用指向新的对象，这样会造成很大的空间浪费  
例如：

public static void main(String[] args) { 
            String s = "H";     // 创建一个对象 "H"
    
            for (int i = 0; i < 10; i++) { 
                s = s + i;      // 创建一个新的对象
            }
    
            System.out.println(s);
        }

结果是：H0123456789  
我们不停地让s指向新的对象。这里新创建了9个对象

解决办法：

public static void main(String[] args) { 
            StringBuilder sb = new StringBuilder("H");     // 创建一个对象 "H"
    
            for (int i = 0; i < 10; i++) { 
                sb.append(i);      // 创建一个新的对象
            }
    
            String s = sb.toString();
    
            System.out.println(s);
        }

结果是：H0123456789  
通过 StringBuilder 创建一个对象，然后用append加入内容，最后通过toString转成String类型，这样就不会造成空间的浪费了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70]: /images/20221119/9155c38337484a63a04dc6d75232ddc8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 1]: /images/20221119/bffbd19d84fc4f95b6b40476d149f57d.png
[20210126202415432.png]: /images/20221119/35662e0150864971ae3a10d3e0b75579.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 2]: /images/20221119/f01cc94dc980415e9e09fd9c6b1d95e4.png
[20210126203617748.png]: /images/20221119/c41a74082b294a6e8cb02d1297a2b397.png
[20210126204254380.png]: /images/20221119/0392ae3361524275ad9f0aa5fcab9101.png
[20210126210636758.png]: /images/20221119/747fef5b0e48456493cebe78a7cc12d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 3]: /images/20221119/13ee2dcffe8f48fd803ffc9296577ce3.png
[20210126211450332.png]: /images/20221119/e0500c5bdc0c4693b0f9f5dde36ebdbe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 4]: /images/20221119/49d8a9602658492bb9b9b38835a99c83.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 5]: /images/20221119/1af6b33951b647aa9566d14d0268e5d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MjE0MjczMQ_size_16_color_FFFFFF_t_70 6]: /images/20221119/96582537be9f428dbc45073b3a750a4c.png