Java String类

String类

String 类代表字符串。Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现。

字符串是常量;它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的,所以可以共享。例如:

String str = "abc";

等效于:

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

常用方法

1. 获取

length():

获取字符串长度。

public int length()

用法:

public class Str {
    public static void main(String[] args) {
        String a1 = "123456";
        // 6
        System.out.println(a1.length());
    }
}

charAt():

返回指定索引处的 char 值。索引范围为从 0length() - 1。序列的第一个 char 值位于索引 0 处,第二个位于索引 1 处,依此类推,这类似于数组索引。

public char charAt(int index)

用法:

public class Str {
    public static void main(String[] args) {
        String a1 = "123456";
        // 4
        System.out.println(a1.charAt(3));
    }
}

根据字符获取该字符在字符串中位置。

indexOf(int ch): 返回的ch在字符串指定位置开始,获取ch在字符串中出现的位置。

indexOf(int ch, int fromIndex):fromIndex指定位置开始,获取ch在字符串中出现的位置。

indexOf(String str):返回的是str在字符串中第一次出现的位置。

indexOf(String str, int fromIndex):fromIndex指定位置开始,获取str在字符串中出现的位置。

lastIndexOf(int ch):返回指定字符在此字符串中最后一次出现处的索引。

lastindexOf(int ch, int fromIndex):返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索。

lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引。

lastIndexOf(String str, int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索。

public class Str {
    public static void main(String[] args) {
        String str = "123456654321";
        // 0x33 = 3
        // str.indexOf(0x33) = 2
        System.out.println("str.indexOf(0x33) = " + str.indexOf(0x33));
        // str.indexOf(0x33,3) = 9
        System.out.println("str.indexOf(0x33,3) = " + str.indexOf(0x33, 3));
        // str.indexOf("3") = 2
        System.out.println("str.indexOf(\"3\") = " + str.indexOf("3"));
        // str.indexOf("3",3) = 9
        System.out.println("str.indexOf(\"3\",3) = " + str.indexOf("3", 3));
        // str.lastIndexOf(0x33) = 9
        System.out.println("str.lastIndexOf(0x33) = " + str.lastIndexOf(0x33));
        // str.lastIndexOf(0x33,3) = 2
        System.out.println("str.lastIndexOf(0x33,3) = " + str.lastIndexOf(0x33, 3));
        // str.lastIndexOf("3") = 9
        System.out.println("str.lastIndexOf(\"3\") = " + str.lastIndexOf("3"));
        // str.lastIndexOf("3",3) = 2
        System.out.println("str.lastIndexOf(\"3\",3) = " + str.lastIndexOf("3", 3));
    }
}

2. 判断

contains()

当且仅当此字符串包含指定的 char 值序列时,返回 true

public boolean contains(CharSequence s)

用法:

public class Str {
    public static void main(String[] args) {
        String str = "TestDemo.java";
        // str.contains("Test") = true
        System.out.println("str.contains(\"Test\") = " + str.contains("Test"));
        // str.contains("Test") = false
        System.out.println("str.contains(\"Test\") = " + str.contains("Text"));
    }
}

isEmpty()

当且仅当 length()0 时返回 true

public boolean isEmpty()

用法:

public class Str {
    public static void main(String[] args) {
        String s = new String();
        String s1 = "";
        String s2 = "TestDemo.java";
        // s.isEmpty() = true
        System.out.println("s.isEmpty() = " + s.isEmpty());
        // s1.isEmpty() = true
        System.out.println("s1.isEmpty() = " + s1.isEmpty());
        // s2.isEmpty() = false
        System.out.println("s2.isEmpty() = " + s2.isEmpty());

    }
}

startsWith()

startsWith(String prefix)

测试此字符串是否以指定的前缀开始

public boolean startsWith(String prefix)

用法:

public class Str {
    public static void main(String[] args) {
        String str = "TestDemo.java";
        // str.startsWith("Test") = true
        System.out.println("str.startsWith(\"Test\") = " + str.startsWith("Test"));
        // str.startsWith("test") = false
        System.out.println("str.startsWith(\"test\") = " + str.startsWith("test"));
        // str.startsWith("estDemo") = false
        System.out.println("str.startsWith(\"estDemo\") = " + str.startsWith("estDemo"));
    }
}
startsWith(String prefix, int toffset)

测试此字符串从指定索引开始的子字符串是否以指定前缀开始。

public boolean startsWith(String prefix, int toffset)

用法:

public class Str {
    public static void main(String[] args) {
        String str = "TestDemo.java";
        // str.startsWith("D",4) = true
        System.out.println("str.startsWith(\"D\", 4) = " + str.startsWith("D", 4));
        // str.startsWith("D",3) = false
        System.out.println("str.startsWith(\"D\",3) = " + str.startsWith("D", 3));
        // str.startsWith("o",8) = true
        System.out.println("str.startsWith(\"o\",8) = " + str.startsWith("o", 7));
    }
}

endsWith()

测试此字符串是否以指定的后缀结束。

public boolean endsWith(String suffix)

用法:

public class Str {
    public static void main(String[] args) {
        String str = "TestDemo.java";
        // str.endsWith(".java") = true
        System.out.println("str.endsWith(\".java\") = " + str.endsWith(".java"));
        // str.endsWith(".javax") = false
        System.out.println("str.endsWith(\".javax\") = " + str.endsWith(".javax"));
    }
}

equals()

将此字符串与指定的对象比较。当且仅当该参数不为 null,并且是与此对象表示相同字符序列的 String 对象时,结果才为 true

public boolean equals(Object anObject)

用法:

public class Str {
    public static void main(String[] args) {
        String str = "TestDemo.java";
        // str.equals("TestDemo.java") = true
        System.out.println("str.equals(\"TestDemo.java\") = " + str.equals("TestDemo.java"));
        // str.equals("TestDemo.java") = false
        System.out.println("str.equals(\"TestDemo.java\") = " + str.equals("testdemo.java"));
        // str.equals(new String("TestDemo.java")) = true
        System.out.println("str.equals(new String(\"TestDemo.java\")) = " + str.equals(new String("TestDemo.java")));
        // str.equals(new String("testdemo.java")) = false
        System.out.println("str.equals(new String(\"testdemo.java\")) = " + str.equals(new String("testdemo.java")));
    }
}

equalsIgnoreCase

将此 String 与另一个 String 比较,不考虑大小写。如果两个字符串的长度相同,并且其中的相应字符都相等(忽略大小写),则认为这两个字符串是相等的。

在忽略大小写的情况下,如果下列至少一项为 true,则认为 c1c2 这两个字符相同。

  • 这两个字符相同(使用 == 运算符进行比较)。
  • 对每个字符应用方法 Character.toUpperCase(char) 生成相同的结果。
  • 对每个字符应用方法 Character.toLowerCase(char) 生成相同的结果。
public boolean equalsIgnoreCase(String anotherString)

用法:

public class Str {
    public static void main(String[] args) {
        String str = "TestDemo.java";
        // str.equalsIgnoreCase("TestDemo.java") = true
        System.out.println("str.equalsIgnoreCase(\"TestDemo.java\") = " + str.equalsIgnoreCase("TestDemo.java"));
        // str.equalsIgnoreCase("testdemo.java") = true
        System.out.println("str.equalsIgnoreCase(\"testdemo.java\") = " + str.equalsIgnoreCase("testdemo.java"));
    }
}

3. 转换

将字符数组转成字符串。

构造函数:
String(char[])

通过使用平台的默认字符集解码指定的 byte 数组,构造一个新的 String。新 String 的长度是字符集的函数,因此可能不等于 byte 数组的长度。

当给定 byte 在给定字符集中无效的情况下,此构造方法的行为没有指定。如果需要对解码过程进行更多控制,则应该使用 CharsetDecoder 类。

public String(byte[] bytes)

用法:

public class Str {
    public static void main(String[] args) {
        byte[] b = new byte[]{84, 101, 115, 116, 68, 101, 109, 111, 46, 106, 97, 118, 97};
        // new String(b) = TestDemo.java
        System.out.println("new String(b) = " + new String(b));
    }
}
String(byte[] bytes,int offset,int length)

通过使用平台的默认字符集解码指定的 byte 子数组,构造一个新的 String。新 String 的长度是字符集的函数,因此可能不等于该子数组的长度。

当给定 byte 在给定字符集中无效的情况下,此构造方法的行为没有指定。如果需要对解码过程进行更多控制,则应该使用 CharsetDecoder 类。

public String(byte[] bytes,int offset,int length)

用法:

public class Str {
    public static void main(String[] args) {
        byte[] b = new byte[]{84, 101, 115, 116, 68, 101, 109, 111, 46, 106, 97, 118, 97};
        // new String(b, 4, 8) = Demo.jav
        System.out.println("new String(b, 4, 8) = " + new String(b, 4, 8));
    }
}
静态方法:
copyValueOf(char [])
copyValueOf(char[] data, int offset, int count)

返回指定数组中表示该字符序列的 String。

public static String copyValueOf(char[] data)

用法:

public class Str {
    public static void main(String[] args) {
        char[] content = {'T', 'e', 's', 't', 'D', 'e', 'm', 'o', '.', 'j', 'a', 'v', 'a'};
        // String.copyValueOf(content) = TestDemo.java
        System.out.println("String.copyValueOf(content) = " + String.copyValueOf(content));
        // String.copyValueOf(content,4,9) = Demo.java
        System.out.println("String.copyValueOf(content,4,9) = " + String.copyValueOf(content, 4, 9));
    }
}
valueOf(char[] data)

返回 char 参数的字符串表示形式。

public static String valueOf(boolean b)

用法:

public class Str {
    public static void main(String[] args) {
        char[] content = {'T', 'e', 's', 't', 'D', 'e', 'm', 'o', '.', 'j', 'a', 'v', 'a'};
        // String.valueOf(content) = TestDemo.java
        System.out.println("String.valueOf(content) = " + String.valueOf(content));
    }
}
将字符串转成字符数组。
String(byte [])

通过使用平台的默认字符集解码指定的 byte 数组,构造一个新的 String

public String(byte[] bytes)
String(byte [], offset,count)

通过使用平台的默认字符集解码指定的 byte 子数组,构造一个新的 String

public String(byte[] bytes, int offset, int length)

用法:

public class Str {
    public static void main(String[] args) {
        byte[] b = new byte[]{84, 101, 115, 116, 68, 101, 109, 111, 46, 106, 97, 118, 97};
        // new String(b) = TestDemo.java
        System.out.println("new String(b) = " + new String(b));
        // new String(b,4,9) = Demo.java
        System.out.println("new String(b,4,9) = " + new String(b, 4, 9));
    }
}
将字符串转成字节数组。
getBytes()

使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。

public byte[] getBytes()

用法:

public class Str {
    public static void main(String[] args) {
        byte[] b = "Hello World.java".getBytes();
        for (byte b1 : b) {
            System.out.println("b1 = " + b1);
        }
    }
}

结果:

b1 = 72
b1 = 101
b1 = 108
b1 = 108
b1 = 111
b1 = 32
b1 = 87
b1 = 111
b1 = 114
b1 = 108
b1 = 100
b1 = 46
b1 = 106
b1 = 97
b1 = 118
b1 = 97
将基本数据类型转成字符串。
valueOf(int)

返回 int 参数的字符串表示形式。

public static String valueOf(int i)

用法:

public class Str {
    public static void main(String[] args) {
        // String.valueOf(100) = 100
        System.out.println("String.valueOf(100) = " + String.valueOf(100));
    }
}
valueOf(double)

返回 double 参数的字符串表示形式。

public static String valueOf(double d)

用法:

public class Str {
    public static void main(String[] args) {
        // String.valueOf(11.11) = 11.11
        System.out.println("String.valueOf(11.11) = " + String.valueOf(11.11));
    }
}
valueOf(boolean)

返回 boolean 参数的字符串表示形式。

public static String valueOf(boolean b)

用法:

public class Str {
    public static void main(String[] args) {
        // String.valueOf(true) = true
        System.out.println("String.valueOf(true) = " + String.valueOf(true));
    }
}

4. 替换

replace()

返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

public String replace(char oldChar, char newChar)

用法:

public class Str {
    public static void main(String[] args) {
        // "Hello Worid.java".replace('i','l') = Hello World.java
        System.out.println("\"Hello Worid.java\".replace('i','l') = " + "Hello Worid.java".replace('i', 'l'));
    }
}

replaceAll()

public String replaceAll(String regex, String replacement)

使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

public class Str {
    public static void main(String[] args) {
        // hello world 123 hello world 123 hello world
        System.out.println("hello worid 123 hello worid 123 hello worid".replaceAll("i", "l"));
    }
}

5. 切割

split()

根据给定正则表达式的匹配拆分此字符串。

public String[] split(String regex)
public String[] split(String regex, int limit)

用法:

public class Str {
    public static void main(String[] args) {
        for (String h : "Hello World".split(" ")) {
            System.out.println("h = " + h);
        }

        for (String s : "Hello World Java".split(" ", 3)) {
            System.out.println("s = " + s);
        }
    }
}

结果:

h = Hello
h = World
s = Hello
s = World
s = Java

6. 子串,获取字符串一部分。

substring(int beginIndex)

返回一个新的字符串,它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始,直到此字符串末尾。

public String substring(int beginIndex) 

substring(int beginIndex, int endIndex)

返回一个新字符串,它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始,直到索引 endIndex - 1 处的字符。

public String substring(int beginIndex, int endIndex)

用法:

public class Str {
    public static void main(String[] args) {
        // "Hello World".substring(4) = o World
        System.out.println("\"Hello World\".substring(4) = " + "Hello World".substring(4));
        // "Hello World Java".substring(6, 11) = World
        System.out.println("\"Hello World Java\".substring(6, 11) = " + "Hello World Java".substring(6, 11));
    }
}

7. 转换,去除空格,比较。

将字符串转成大写或则小写。

toUpperCase():转小写

使用默认语言环境的规则将此 String 中的所有字符都转换为大写。此方法等效于 toUpperCase(Locale.getDefault())

public String toUpperCase()

用法:

public class Str {
    public static void main(String[] args) {
        // "Hello Java".toLowerCase() = hello java
        System.out.println("\"Hello Java\".toLowerCase() = " + "Hello Java".toLowerCase());
    }
}
toLowerCase():转大写

使用默认语言环境的规则将此 String 中的所有字符都转换为小写。这等效于调用 toLowerCase(Locale.getDefault())

public String toLowerCase()

用法:

public class Str {
    public static void main(String[] args) {
        // "Hello Java".toUpperCase() = HELLO JAVA
        System.out.println("\"Hello Java\".toUpperCase() = " + "Hello Java".toUpperCase());
    }
}

将字符串两端的多个空格去除。

trim()

返回字符串的副本,忽略前导空白和尾部空白。

public String trim()

用法:

public class Str {
    public static void main(String[] args) {
        String str = "             TestDemo.java                ";
        //str =              TestDemo.java                ;
        System.out.println("str = " + str);
        // str.trim() =  [TestDemo.java]
        System.out.println("str.trim() =  [" + str.trim() + "]");
    }
}

对两个字符串进行自然顺序的比较。

compareTo()

按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。

public int compareTo(String anotherString)

用法:

public class Str {
    public static void main(String[] args) {
        // "Hello Java".contains(" ") = true
        System.out.println("\"Hello Java\".contains(\" \") = " + "Hello Java".contains(" "));
        // "Hello Java".contains("o J") = true
        System.out.println("\"Hello Java\".contains(\"o J\") = " + "Hello Java".contains("o J"));
        // "Hello Java".contains("h") = false
        System.out.println("\"Hello Java\".contains(\"h\") = " + "Hello Java".contains("h"));
    }
}

练习

  • 创建一个自己的trim()

  • public class Str {
      public static void main(String[] args) {
          System.out.println(MyTrim("             TestDemo.java                "));
      }
    
      public static String MyTrim(String str) {
          // 初始化start和end变量
          int start = 0, end = str.length() - 1;
          // 判断start是否被end大于或等于并且根据start查找str的start索引是否为空格。
          // 如果为空格就start++,如果不是就再次循环。
          while (start <= end && str.charAt(start) == ' ') {
              start++;
          }
          // 判断start是否被end大于或等于并且根据end查找str的end索引是否为空格。
          // 如果为空格就start++,如果不是就再次循环。
          while (start <= end && str.charAt(end) == ' ') {
              end--;
          }
          // 根据while循环得到start和end数据来str截取并返回。
          return str.substring(start, end + 1);
      }
    }
    
  • 字符串反转

  • public class Str {
      public static void main(String[] args) {
          System.out.println("reveresString(\"Hello World\", 0, 5) = " + reveresString("Hello World", 0, 5));
      }
    
      public static String reveresString(String s, int start, int end) {
          char[] chs = s.toCharArray();
          reveres(chs, start, end);
          return new String(chs);
      }
    
      private static void reveres(char[] chs, int x, int y) {
          for (int start = x, end = y - 1; start < end; start++, end--) {
              swap(chs, start, end);
          }
      }
    
      // 调换数据顺序
      private static void swap(char[] chs, int start, int end) {
          char temp = chs[start];
          chs[start] = chs[end];
          chs[end] = temp;
      }
    }
    
  • 子串在整串中出现的次数。

  • /**
    * 获取一个字符串在另一个字符串出现的次数。
    * 思路:
    * 1. 定义个计数器。
    * 2. 获取kk第一次出现的位置。
    * 3. 从第一次出现的位置后剩下的字符串中继续获取kk出现的位置,每次获取一次就计数一次。
    * 4. 当获取不到时,计数完成。
    */
    public class Str {
      // 方法一
      public static int getSubCount(String str, String key) {
          int count = 0;
          int index = 0;
    
          while ((index = str.indexOf(key)) != -1) {
              str = str.substring(index + key.length());
              count++;
          }
          return count;
      }
    
      // 方法二
      public static int getSubCount_2(String str, String key) {
          int count = 0;
          int index = 0;
          while ((index = str.indexOf(key, index)) != -1) {
              index = index + key.length();
              count++;
          }
          return count;
      }
    
      public static void main(String[] args) {
          System.out.println(getSubCount("sdfhsakhfsksfasjfklhjkhk", "kh")); 
          System.out.println(getSubCount_2("sdfhsakhfsksfasjfklhjkhk", "kh"));
      }
    
    }
    
  • 两个字符串的最大相同子串。

  • /**
    * 获取两个字符串中最大相同子串。
    * 第一个动作:就短的那个字符串长度一次递减的子串打印。
    * “abcwethlloyuidef”
    * “cvhellobnm”
    * 思路:
    * 1.将短的那个子串按照长度递减的方式获取到。
    * 2.就每个取到的子串去长串中判断是否包含,如果包含,已经找到!
    */
    public class Str {
    
      public static String getMaxSubString(String s1, String s2) {
          String max = "", min = "";
    
          max = (s1.length() > s2.length()) ? s1 : s2;
          min = (max.equals(s1)) ? s2 : s1;
    
          for (int i = 0; i < min.length(); i++) {
              for (int j = 0, z = min.length() - i; z != min.length() + 1; j++, z++) {
                  String temp = min.substring(j, z);
                  if (max.contains(temp)) {
                      return temp;
                  }
              }
          }
          return "";
      }
    
      public static void main(String[] args) {
          String s1 = "abcwethlloyuidef";
          String s2 = "cvhellobnm";
          System.out.println(getMaxSubString(s1, s2));
      }
    
    }