📌  相关文章
📜  Java中的字符串类String 1

📅  最后修改于: 2020-03-25 01:20:12             🧑  作者: Mango

字符串是字符序列。在Java中，String对象是不可变的，这意味着一个常量，并且一旦创建就不能更改。
创建一个字符串
有两种在Java中创建字符串的方法：

  • 字符串字面量  
    String s = “芒果文档";

     

  • 使用new关键字 
    String s = new String (“芒果文档");

    构造器

    1. String(byte [] byte_arr): 通过解码字节byte数组构造一个新的String 。它使用平台的默认字符集进行解码。
      例：  
      byte[] b_arr = {71, 101, 101, 107, 115};
String s_byte =new String(b_arr); //芒果

       

    2. String(byte [] byte_arr，Charset char_set): 通过解码字节数组构造一个新的String 。它使用char_set进行解码。
      例： 
      byte[] b_arr = {71, 101, 101, 107, 115};
Charset cs = Charset.defaultCharset();
String s_byte_char = new String(b_arr, cs); //芒果
    3. String(byte [] byte_arr，String char_set_name) : 通过解码字节数组构造一个新的String 。它使用char_set_name进行解码。
      它看起来与上面的构造相似，并且出现在相似的函数之前，但是它使用String(包含char_set_name)作为参数，而上面的构造函数使用CharSet。
      例： 
      byte[] b_arr = {71, 101, 101, 107, 115};
String s = new String(b_arr, "US-ASCII"); //芒果
    4. String(byte [] byte_arr，int start_index，int length): 根据start_index(起始位置)和length(起始位置的字符数)从bytes数组构造一个新字符串。例： 
      byte[] b_arr = {71, 101, 101, 107, 115};
String s = new String(b_arr, 1, 3); // eek
    5. 串(字节[] byte_arr，INT START_INDEX，INT长度，字符集char_set) -构造一个新的串从字节数组取决于START_INDEX(起始位置)和长度(从起始位置的字符数) .Uses char_set用于解码。
      例： 
      byte[] b_arr = {71, 101, 101, 107, 115};
Charset cs = Charset.defaultCharset();
String s = new String(b_arr, 1, 3, cs); // eek
    6. 串(字节[] byte_arr，INT START_INDEX，INT长度，串char_set_name) -构造一个新的串从字节数组取决于START_INDEX(起始位置)和长度(从起始位置的字符数) .Uses char_set_name用于解码。
      例： 
      byte[] b_arr = {71, 101, 101, 107, 115};
String s = new String(b_arr, 1, 4, "US-ASCII"); // eeks
    7. String(char [] char_arr) –从给定的Character数组分配一个新的String
      示例： 
      char char_arr[] = {'G', 'e', 'e', 'k', 's'};
String s = new String(char_arr); //芒果
    8. String(char [] char_array，int start_index，int count) –从给定的字符数组中分配一个String，但从start_index中选择count个字符。例： 
      char char_arr[] = {'G', 'e', 'e', 'k', 's'};
String s = new String(char_arr , 1, 3); //eek
    9. String(int [] uni_code_points，int偏移量，int计数) : 从uni_code_array分配一个字符串，但从start_index中选择计数字符。例： 
      int[] uni_code = {71, 101, 101, 107, 115};
String s = new String(uni_code, 1, 3); //eek
    10. String(StringBuffer s_buffer): 从s_buffer中的字符串分配一个新字符串。
      示例： 
      StringBuffer s_buffer = new StringBuffer("芒果");
String s = new String(s_buffer); //芒果
    11. String(StringBuilder s_builder): 从s_builder中的字符串分配一个新字符串。
      示例： 
      StringBuilder s_builder = new StringBuilder("芒果");
String s = new String(s_builder); //芒果

字符串方法

  1. int length()： 返回字符串中的字符数。 
    "芒果文档".length();  // 返回4
  2. Char charAt(int i)： 返回第i个索引处的字符。 
    "芒果文档".charAt(3); // 返回  ‘档’
  3. String substring(int i)： 将第i个索引字符的子字符串返回到结尾。 
    "芒果文档".substring(3); // 返回 “档"
  4. substring串(int i，int j)： 将子字符串从i返回到j-1索引。 
    "芒果文档".substring(2, 4); // 返回 “文档"
  5. String concat(String str)：将指定的字符串连接到该字符串的末尾。 
     String s1 = "芒果";
 String s2 = "文档";
 String output = s1.concat(s2); // 返回 “芒果文档"
  6. int indexOf(String s)： 返回指定字符串首次出现在字符串内的索引。 
     String s = "Learn Share Learn";
 int output = s.indexOf(“Share"); // 返回 6
  7. int indexOf(String s，int i)： 从指定的索引开始，返回指定字符串首次出现的字符串内的索引。 
     String s = "Learn Share Learn";
 int output = s.indexOf("ea",3);// 返回 13
  8. Int lastIndexOf(String s)： 返回指定字符串最后一次出现的字符串内的索引。 
     String s = "Learn Share Learn";
 int output = s.lastIndexOf("a"); // 返回 14
  9. boolean equals(Object otherObj)： 将此字符串与指定对象进行比较。 
     Boolean out = “芒果".equals(“芒果"); // 返回 true
 Boolean out = “芒果".equals(“文档"); // returns false
  10. boolean equalsIgnoreCase(String anotherString)： 将字符串与另一个字符串进行比较，而忽略大小写考虑。 
     Boolean out= “芒果".equalsIgnoreCase(“芒果"); // returns true
 Boolean out = “a".equalsIgnoreCase(“A"); // returns true
  11.  int compareTo(String anotherString)：按字典顺序比较两个字符串。 
     int out = s1.compareTo(s2);  // 比较s2和s2
 This returns difference s1-s2. If :
 out < 0  // s1先于s2
 out = 0  // s1 = s2.
 out > 0   // s1后于s2.
  12. int compareToIgnoreCase(String anotherString)：按字典顺序比较两个字符串，忽略大小写考虑。 
     int out = s1.compareToIgnoreCase(s2);
// 比较s2和s2
 This returns difference s1-s2. If :
 out < 0  // s1先于s2
 out = 0   // s1 = s2.
 out > 0   // s1后于s2.

    注意：在这种情况下，它将不考虑字母的大小写(它将忽略大写还是小写)。

  13. String toLowerCase()： 将String中的所有字符转换为小写。 
    String word1 = “HeLLo";
String word3 = word1.toLowerCase(); // 返回 “hello"
  14. String toUpperCase()： 将String中的所有字符转换为大写。 
    String word1 = “HeLLo";
String word2 = word1.toUpperCase(); // 返回 “HELLO"
  15. String trim()： 通过删除两端的空格来返回String的副本。它不会影响中间的空格。 
    String word1 = “ Learn Share Learn “;
String word2 = word1.trim(); // 返回 “Learn Share Learn"
  16. replace(oldChar，newChar) ： 通过更换所有出现返回新的字符串 oldChar用 newChar。 
    String s1 = “芒果文档“;
String s2 = “芒果文档".replace(‘果’ ,’芒’); // 返回 “芒芒文档"

     

用来说明所有字符串方法的程序：

import java.io.*;
import java.util.*;
class Test
{
    public static void main (String[] args)
    {
        String s= "GeeksforGeeks";
        // or String s= new String ("GeeksforGeeks");
  
        // Returns the number of characters in the String.
        System.out.println("String length = " + s.length());
  
        // Returns the character at ith index.
        System.out.println("Character at 3rd position = "
                           + s.charAt(3));
  
        // Return the substring from the ith  index character
        // to end of string
        System.out.println("Substring " + s.substring(3));
  
        // Returns the substring from i to j-1 index.
        System.out.println("Substring  = " + s.substring(2,5));
  
        // Concatenates string2 to the end of string1.
        String s1 = "Geeks";
        String s2 = "forGeeks";
        System.out.println("Concatenated string  = " +
                            s1.concat(s2));
  
        // Returns the index within the string
        // of the first occurrence of the specified string.
        String s4 = "Learn Share Learn";
        System.out.println("Index of Share " + 
                           s4.indexOf("Share"));
  
        // Returns the index within the string of the
        // first occurrence of the specified string,
        // starting at the specified index.
        System.out.println("Index of a  = " + 
                           s4.indexOf('a',3));
  
        // Checking equality of Strings
        Boolean out = "Geeks".equals("geeks");
        System.out.println("Checking Equality  " + out);
        out = "Geeks".equals("Geeks");
        System.out.println("Checking Equality  " + out);
  
        out = "Geeks".equalsIgnoreCase("gEeks ");
        System.out.println("Checking Equality " + out);
  
        int out1 = s1.compareTo(s2);
        System.out.println("If s1 = s2 " + out);
  
        // Converting cases
        String word1 = "GeeKyMe";
        System.out.println("Changing to lower Case " +
                            word1.toLowerCase());
  
        // Converting cases
        String word2 = "GeekyME";
        System.out.println("Changing to UPPER Case " + 
                            word1.toUpperCase());
  
        // Trimming the word
        String word4 = " Learn Share Learn ";
        System.out.println("Trim the word " + word4.trim());
  
        // Replacing characters
        String str1 = "feeksforfeeks";
        System.out.println("Original String " + str1);
        String str2 = "feeksforfeeks".replace('f' ,'g') ;
        System.out.println("Replaced f with g -> " + str2);
    } 
}

输出：

String length = 13
Character at 3rd position = k
Substring ksforGeeks
Substring = eks
Concatenated string = GeeksforGeeks
Index of Share 6
Index of a = 8
Checking Equality false
Checking Equality true
Checking Equality false
If s1 = s2 false
Changing to lower Case geekyme
Changing to UPPER Case GEEKYME
Trim the word Learn Share Learn
Original String feeksforfeeks
Replaced f with g -> geeksgorgeeks