Java 常用类——String类常用方法

String 字符串常用方法

常用系列一：

int length()： 返回字符串的长度： return value.length
char charAt(int index)： 返回某索引处的字符return value[index]
boolean isEmpty()： 判断是否是空字符串： return value.length == 0

String toLowerCase()： 使用默认语言环境， 将 String 中的所有字符转换为小写
String toUpperCase()： 使用默认语言环境， 将 String 中的所有字符转换为大写

String trim()： 返回字符串的副本， 忽略前导空白和尾部空白

boolean equals(Object obj)： 比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString)： 与equals方法类似， 忽略大小写

String concat(String str)： 将指定字符串连接到此字符串的结尾。 等价于用“+”
int compareTo(String anotherString)： 比较两个字符串的大小

String substring(int beginIndex)： 返回一个新的字符串， 它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex) ： 返回一个新字符串， 它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

　　Demo：

    @Test
    public void test() {
        String s1 = "HelloWorld";
        String s2 = "helloworld";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));

        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4);

        String s5 = "abc";
        String s6 = new String("abe");
        System.out.println(s5.compareTo(s6));//涉及到字符串排序

        String s7 = "北京东京南京西京";
        String s8 = s7.substring(2);
        System.out.println(s7);
        System.out.println(s8);

        String s9 = s7.substring(2, 5);
        System.out.println(s9);
    }

常用系列二：

boolean endsWith(String suffix)： 测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix)： 测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)： 测试此字符串从指定索引开始的子字符串是否以指定前缀开始

　　

boolean contains(CharSequence s)： 当且仅当此字符串包含指定的 char 值序列时，返回 true

int indexOf(String str)： 返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex)： 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str)： 返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex)： 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
注： indexOf和lastIndexOf方法如果未找到都是返回-1

　　Demo：

    @Test
    public void test(){
        String str1 = "hellowworld";
        boolean b1 = str1.endsWith("rld");
        System.out.println(b1);

        boolean b2 = str1.startsWith("He");
        System.out.println(b2);

        boolean b3 = str1.startsWith("ll",2);
        System.out.println(b3);

        String str2 = "wor";
        System.out.println(str1.contains(str2));

        System.out.println(str1.indexOf("lol"));

        System.out.println(str1.indexOf("lo",5));

        String str3 = "hellorworld";

        System.out.println(str3.lastIndexOf("or"));
        System.out.println(str3.lastIndexOf("or",6));

        //什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？
        //情况一：存在唯一的一个str。情况二：不存在str
    }

常用系列三：

String replace(char oldChar, char newChar)： 返回一个新的字符串， 它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)： 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String replaceAll(String regex, String replacement) ： 使用给定的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement) ： 使用给定的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。


boolean matches(String regex)： 告知此字符串是否匹配给定的正则表达式。
String[] split(String regex)： 根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit)： 根据匹配给定的正则表达式来拆分此字符串， 最多不超过limit个， 如果超过了， 剩下的全部都放到最后一个元素中。

　　Demo：　

    @Test
    public void test(){
        String str1 = "北京东京南京西京";
        String str2 = str1.replace('北', '东');

        System.out.println(str1);
        System.out.println(str2);


        String str3 = str1.replace("北京", "上海");
        System.out.println(str3);

        System.out.println("*************************");
        String str = "12hello34world5java7891mysql456";
        //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
        String string = str.replaceAll("\d+", ",").replaceAll("^,|,$", "");
        System.out.println(string);

        System.out.println("*************************");
        str = "12345";
        //判断str字符串中是否全部有数字组成，即有1-n个数字组成
        boolean matches = str.matches("\d+");
        System.out.println(matches);
        String tel = "0571-4534289";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\d{7,8}");
        System.out.println(result);


        System.out.println("*************************");
        str = "hello|world|java";
        String[] strs = str.split("\|");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        System.out.println();
        str2 = "hello.world.java";
        String[] strs2 = str2.split("\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }

    }

　

String 字符串常见操作

一、字符串的连接

　　1、连接多个字符串

　　　　使用“+”运算符可以实现连接多个字符串的功能。“+” 运算符可以连接多个运算符并产生一个 String 对象。

　　2、连接其他数据类型

　　　　字符串与其他基本数据类型进行连接，会将这些数据直接转换成字符串。

　　3、concat() 方法

public String concat(String str)：将指定的字符串连接到该字符串的末尾。

　　　　Demo：

 1 public static void main(String[] args) {
 2         String  str1 = "Hello";
 3         String  str2 = "Java";
 4 
 5         // 使用"+" 运算符连接
 6         System.out.println(str1+" "+str2);              // Hello Java
 7 
 8         int booktime = 4;
 9         double practice = 4.5;
10         // 连接不同数据类型的字符串
11         System.out.println("我每天花费"+booktime+"小时看书，"+practice+"小时练习");  // 我每天花费4小时看书，4.5小时练习
12 
13         // concat:将字符串连接到该字符串尾部。
14         System.out.println(str1.concat(" World"));      // Hello World
15 
16     }

二、字符串的比较

　　1、==：比较对象的地址

　　　　只有两个字符串的常量对象比较时才会返回 true，其他的都是 false。

　　2、equals 方法

public boolean equals( Object anObject) 
此方法将此字符串与指定对象进行比较，严格区分大小写。因为 String 类型重写了 Object的 equals。

　　

　　3、equalsIgnoreCase 方法

public boolean equalsIgnorCase(String anOtherString)
将此字符串与指定字符串对象比较，忽略大小写。

　　　　Demo：

 1 public static void main(String[] args) {
 2 
 3 　　// 创建字符串对象
 4 　　String s1 = "hello";
 5 　　String s2 = "hello";
 6 　　String s3 = "HELLO";
 7 
 8 　　// boolean equals(Object obj):比较字符串的内容是否相同
 9 　　System.out.println(s1.equals(s2)); // true
10 　　System.out.println(s1.equals(s3)); // false
11 
12 　　//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
13 　　System.out.println(s1.equalsIgnoreCase(s2)); // true
14 　　System.out.println(s1.equalsIgnoreCase(s3)); // true
15 
16 }

 　　　　注意：

　　　　　　a、== 是进行对象的地址值比较，比较字符串的内容用 equal 方法。

　　　　　　b、在使用 equal 的时候，如果比较双方一个常量一个变量，推荐把常量字符串写在前面，因为一旦变量为 null ，会报空指针异常。

　　　　扩展：Object 是” 对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中

　　4、大小比较

　　　　String 类型实现了 Comparable 接口，重写了 compareTo 方法，严格区分大小写，会依次比较对应位置的字符。

　　　　如：hello和Hello，先[0]位置的h和H，h>H，就直接认定为hello>Hello

　　　　       hello和hella，先[0][1][2][3]比较，都一样，最后到[4]o>a，认定hello>hella

　　　　　　hello和helloworld，发现前面都一样，长的大

　　　　String 类同时海豚提供了一个方法 compareToIgnoreCase，可以忽略大小写比较

　　5、按照每个国家的语言校对顺序

　　　　java.text.Collator：Collator 类执行区分语言环境的 String 比较。使用此类可为自然语言文本构建搜索和排序例程。

　　　　Collator实现了Comparator接口 ，Collator是抽象类，不能直接创建对象，它有一个直接子类RuleBasedCollator。

　　　　Collator内部提供了一个静态方法，可以获取一个它的子类对象。

　　　　Demo：

 1 　　@Test
 2     public void test1(){
 3         String[] arr = {"张三","李四","王五","赵六","钱七"};
 4         //希望按照拼音顺序，字典顺序
 5         Arrays.sort(arr, Collator.getInstance());//默认语言环境，因为现在的操作系统的平台是中文win
 6         System.out.println(Arrays.toString(arr));
 7     }
 8 
 9 　　@Test
10     public void test2(){
11         String[] arr = {"张三","李四","王五","赵六","钱七"};
12         //希望按照拼音顺序，字典顺序
13         Arrays.sort(arr, Collator.getInstance(Locale.CHINA));//Locale.CHINA指定语言环境
14         System.out.println(Arrays.toString(arr));
15     }

三、获取字符串长度与查找的方法

public int length()：返回此字符串的长度，因为String的内部（JDK1.9之前）用char[]实现，这个长度就是value数组的长度。

public int indexof(String str)：返回指定子字符串第一次出现在该字符串内的索引，如果没有检索到，返回 -1。

public int lastIndexof(String str)：返回指定子字符串在此字符串中最后一次出现处的索引位置，如果没有检索到，返回 -1。

public boolean contains(CharSequence str)：当且仅当此字符串包含指定的 char 值序列时，返回 true。

　　Demo：

 1 public static void main(String[] args) {
 2    String s = "Hello World";
 3 
 4    // int length :获取字符串的长度，其实也就是字符个数
 5    System.out.println(s.length());            // 11
 6 
 7    //char charAt(int index) 获取指定索引处的字符
 8    System.out.println(s.charAt(0));           // H
 9 
10    //int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
11    System.out.println(s.indexOf("o"));        // 4
12 
13    //int lastIndexOf(String str):获取str在字符串对象中最后一次出现的索引,没有返回‐1
14    System.out.println(s.lastIndexOf("rl"));   // 8
15 
16    //boolean contains(String str):查看指定的字符串是否在该字符串中，存在为true，不存在为 false
17    System.out.println(s.contains("Wo"));      //  true
18 }

四、与 char 相关

char[] toCharArray()：将此字符串转换为新的字符数组

char charAt(index)：返回指定索引处的 char 值

String(char[] arr)：通过一个 char数组构建一个字符串对象

String(char[] arr, int offset, int count)：通过一个 char 数组，截取其中的一端，构建一个字符串对象

　　

五、与 Byte 相关（编码与解码相关）

　　1、byte[] getBytes() 编码方法

byte[] getBytes():编码的方法，使用平台默认的字符编码进行编码

byte[] getBytes(编码方式)：使用指定的编码格式进行编码

　　　　编码：对于ASCII码范围内（0~127），无论用什么编码方式，结果都是一样的，一个字符对应一个字节的编码值

　　　　对于其他的字符，编码，结果不一定是几个字节，例如汉字：

　　　　① ISO8859-1：不支持中文，所有字符都变为1个字节；

　　　　② GBK、GB2312：固定2个字节；

　　　　③ UTF-8：变长的，但是大多数汉字都是3个字节；

　　　Demo：

 1 @Test
 2 public void test01(){
 3     String str = "abc";
 4     byte[] bytes = str.getBytes();
 5     System.out.println(Arrays.toString(bytes));//[97, 98, 99]
 6 }
 7 
 8 @Test
 9 public void test02() throws UnsupportedEncodingException{
10     String str = "你好，世界";
11     byte[] bytes = str.getBytes("GBK");
12     System.out.println(Arrays.toString(bytes));
13         
14     String string = new String(bytes,"GBK");
15     System.out.println(string);
16 }

　　2、new String() 解码方法

new String(字节数组)

new String(字节数组，编码方式)

　　　　扩展：产生乱码原因：

　　　　（1）编码与解码字符集不一致；

　　　　（2）缺字节，如使用ISO8859-1编码不支持中文，就会造成缺字节现象。

六、转换大小写的方法

public String toLowerCase()：使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

public String toUpperCase()：使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

　　Demo：

 1 　　public static void main(String[] args) {
 2         String str = "abcdefg";
 3 
 4         // char[] toCharArray():把字符串转换位字符数组
 5         char[] chars = str.toCharArray();
 6         System.out.println(Arrays.toString(chars));     // [a, b, c, d, e, f, g]
 7 
 8 
 9         // byte[] getBytes()：把字符串转换为字节数组
10         byte[] bytes = str.getBytes();
11         System.out.println(Arrays.toString(bytes));     //  [97, 98, 99, 100, 101, 102, 103]
12 
13         String str2 = "iT,i Love You";
14 
15         // String replace(old str,new str):把匹配的原来的字符串用新的字符串替换掉
16         String replace = str2.replace("i", "I");
17         System.out.println(replace);                    //  IT,I Love You
18 
19         //String toLowerCase():将此 String 中的所有字符都转换为小写。
20         System.out.println(str2.toLowerCase());         //  it,i love you
21 
22         //String toUpperCase():将此 String 中的所有字符都转换为大写。
23         System.out.println(str2.toUpperCase());         //   IT,I LOVE YOU
24 
25 
26     }

　　　　扩展：CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

七、截取分割字符串的方法

public String subString(int beginIndex)：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。

public String subString(int beginIndex,int endIndex)：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。（左闭右开区间）

　　

八、拆分字符串

public String split(String regex)：将此字符串按照给定的regex（规则，可以是正则表达式）拆分为字符串数组。

　　

　　注意：如果按照英文句点“.”进行切分，必须写"\."（两个反斜杠）

　　Demo：

 1 public static void main(String[] args) {
 2         String str = "aa|bb|cc|dd|ee";
 3 
 4         //String subString(int start):从start开始截取字符串到字符串结尾
 5         System.out.println(str.substring(6));        // cc|dd|ee
 6 
 7         //String subString(int start,int end):从start到end截取字符串。含start，不含end。
 8         System.out.println(str.substring(2,8));      // |bb|cc
 9 
10         //String split(string regex):按照给定的regex（规则）拆分为字符串数组。
11         String[] split = str.split("|");
12 
13         System.out.println(Arrays.toString(split));  //[a, a, |, b, b, |, c, c, |, d, d, |, e, e]
14         
15     }

九、匹配方法

boolean matches(正则表达式)：用于校验某个字符串是否符合XXX的规则

　　　Demo：

 1 public void test2(){
 2     String str = "12a345";
 3     //简单判断是否全部是数字，这个数字可以是1~n位
 4         
 5     //正则不是Java的语法，它是独立与Java的规则
 6     //在正则中是表示转义，
 7     //同时在Java中也是转义
 8     boolean flag = str.matches("\d+");
 9     System.out.println(flag);
10 }

十、替换方法

String replace(target, value)：将与target匹配的字符串使用value字符串替换。（如果没有可以匹配的字符，将原字符串返回）不支持正则表达式。

String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

String replaceFirst(String regex, String replacement)：用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

　　

十一、其他方法

public String trim()： 返回字符串的副本，忽略前导空白和尾部空白。

boolean isEmpty()：是否是空字符串

public boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始。

public boolean endsWidth(String suffix)：测试此字符串是否以指定的后缀结束。

public int campareTo()：按字典顺序比较两个字符串。

public int compareToIgnoreCase()：按字典顺序比较两个字符串,忽略大小写。

　　

　　注意：该比较基于字符串中各个字符的 Unicode 值，按字典顺序将此 String对象表示的字符序列与参数字符串所表示的字符序列进行比较。

　　如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为 0。

 1  public static void main(String[] args) {
 2         String str = "  Hello World ";
 3 
 4         //String trim():忽略字符串前导空白和尾部空白。
 5         System.out.println(str.trim());                      //  Hello World
 6 
 7         // boolean startswith测试此字符串是否以指定的前缀开始。
 8         System.out.println(str.startsWith("  He"));          // true
 9         System.out.println(str.startsWith("he"));            // false
10 
11         // boolean endswith测试此字符串是否以指定的后缀结束。
12         System.out.println(str.endsWith("ld "));             // true
13         System.out.println(str.endsWith("ll"));              // false
14 
15         //
16         String str2 = "hello java";
17         //compareTo()字典顺序比较两个字符串。
18         System.out.println(str2.compareTo(str));             // 72
19         // compartToIgnoreCase()字典顺序比较两个字符串，忽略大小写
20         System.out.println(str2.compareToIgnoreCase(str));   // 72
21     }