• java中字符串处理、串联和转换的几个常用方法，以及如果需要自己编程实现的具体实施步骤。

    What?

    如何分类?

    如何使用？

    //String 类提供处理 Unicode 代码点（即字符）(TT观点：指的莫非就是对象的意思。)和 Unicode 代码单元（即 char 值）的方法。（TT观点:看来处理这两种Unicode代码点和代码单元是不一样的，分开掌握。）

    1、toString()

     object类的toString方法。
    1     toString
 2 
 3 public String toString()
 4 
 5          返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
 6  
 7          Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于： 
 8 
 9          getClass().getName() + '@' + Integer.toHexString(hashCode())
10  
11          返回：
12                  该对象的字符串表示形式。

     Character类中的toString方法如下，

    1 toString
2        public String toString()
3        返回表示此 Character 值的 String 对象。
4        结果是一个长度为 1 的字符串，其唯一组件是此 Character 对象表示的基本 char 值。 
5 
6       覆盖：
7          类 Object 中的 toString
8       返回：
9               此对象的字符串表示形式。

    Character类中的另外一个toString方法。

    1 toString
2 public static String toString(char c)
             返回一个表示指定 char 值的 String 对象。结果是长度为 1 的字符串，仅由指定的 char 组成。 
3 
4 参数：
5      c - 要转换的 char 值 
6 返回：
7      指定 char 值的字符串表示形式
8 从以下版本开始： 
9 1.4

    String类中的toString()

     1 toString
 2    public String toString()
 3             返回此对象本身（它已经是一个字符串！）。 
 4 
 5         指定者：
 6                 接口 CharSequence 中的 toString
 7         覆盖：
 8                  类 Object 中的 toString
 9         返回：
10                  字符串本身。

    2、subString()

    子字符串。

    String类的方法。

     1 substring
 2 public String substring(int beginIndex)
 3              返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。
 4               示例： 
 5 
 6                                  "unhappy".substring(2) returns "happy"
 7                                  "Harbison".substring(3) returns "bison"
 8                                  "emptiness".substring(9) returns "" (an empty string)
 9  
10   参数：
11 beginIndex - 起始索引（包括）。 
12    返回：
13 指定的子字符串。 
14    抛出： 
15 IndexOutOfBoundsException - 如果 beginIndex 为负或大于此 String 对象的长度。
     1 substring
 2 public String substring(int beginIndex,
 3                         int endIndex)返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。 
 4 示例： 
 5 
 6  "hamburger".substring(4, 8) returns "urge"
 7  "smiles".substring(1, 5) returns "mile"
 8  
 9 参数：
10 beginIndex - 起始索引（包括）。
11 endIndex - 结束索引（不包括）。 
12 返回：
13 指定的子字符串。 
14 抛出： 
15 IndexOutOfBoundsException - 如果 beginIndex 为负，或 endIndex 大于此 String 对象的长度，或 beginIndex 大于 endIndex。

    2、（2）split（）方法。

     1 split
 2 public String[] split(String regex,
 3                       int limit)根据匹配给定的正则表达式来拆分此字符串。 
 4 此方法返回的数组包含此字符串的子字符串，每个子字符串都由另一个匹配给定表达式的子字符串终止，或者由此字符串末尾终止。数组中的子字符串按它们在此字符串中出现的顺序排列。如果表达式不匹配输入的任何部分，那么所得数组只具有一个元素，即此字符串。 
 5 
 6 limit 参数控制模式应用的次数，因此影响所得数组的长度。如果该限制 n 大于 0，则模式将被最多应用 n - 1 次，数组的长度将不会大于 n，而且数组的最后一项将包含所有超出最后匹配的定界符的输入。如果 n 为非正，那么模式将被应用尽可能多的次数，而且数组可以是任何长度。如果 n 为 0，那么模式将被应用尽可能多的次数，数组可以是任何长度，并且结尾空字符串将被丢弃。 
 7 
 8 例如，字符串 "boo:and:foo" 使用这些参数可生成以下结果： 
 9 
10 Regex Limit 结果 
11 : 2 { "boo", "and:foo" } 
12 : 5 { "boo", "and", "foo" } 
13 : -2 { "boo", "and", "foo" } 
14 o 5 { "b", "", ":and:f", "", "" } 
15 o -2 { "b", "", ":and:f", "", "" } 
16 o 0 { "b", "", ":and:f" } 
17 
18 调用此方法的 str.split(regex, n) 形式与以下表达式产生的结果完全相同： 
19 
20 Pattern.compile(regex).split(str, n) 
21 
22 参数：
23 regex - 定界正则表达式
24 limit - 结果阈值，如上所述 
25 返回：
26 字符串数组，它是根据给定正则表达式的匹配拆分此字符串确定的 
27 抛出： 
28 PatternSyntaxException - 如果正则表达式的语法无效
29 从以下版本开始： 
30 1.4 
31 另请参见：
32 Pattern
     1 split
 2 public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。 
 3 该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此，所得数组中不包括结尾空字符串。 
 4 
 5 例如，字符串 "boo:and:foo" 使用这些表达式可生成以下结果： 
 6 
 7 Regex 结果 
 8 : { "boo", "and", "foo" } 
 9 o { "b", "", ":and:f" } 
10 
11 
12 参数：
13 regex - 定界正则表达式 
14 返回：
15 字符串数组，它是根据给定正则表达式的匹配拆分此字符串确定的 
16 抛出： 
17 PatternSyntaxException - 如果正则表达式的语法无效
18 从以下版本开始： 
19 1.4 
20 另请参见：

    2、（3）toLowerCase()

    toLowerCase

    public String toLowerCase(Locale locale)
    使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。大小写映射关系基于 Character 类指定的 Unicode 标准版。由于大小写映射关系并不总是 1:1 的字符映射关系，因此所得 String 的长度可能不同于原 String。

    下表中给出了几个小写映射关系的示例：

    语言环境的代码大写字母小写字母描述
    tr (Turkish) u0130 u0069 大写字母 I，上面有点 -> 小写字母 i
    tr (Turkish) u0049 u0131 大写字母 I -> 小写字母 i，无点
    (all) French Fries french fries 将字符串中的所有字符都小写
    (all) capiotacapchi capthetacapupsil capsigma iotachi thetaupsilon sigma 将字符串中的所有字符都小写
    参数：
    locale - 使用此语言环境的大小写转换规则
    返回：
    要转换为小写的 String。
    从以下版本开始：
    1.1
    另请参见：
    toLowerCase(), toUpperCase(), toUpperCase(Locale)

    toUpperCase

    public String toUpperCase(Locale locale)
    使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。大小写映射关系基于 Character 类指定的 Unicode 标准版。由于大小写映射关系并不总是 1:1 的字符映射关系，因此所得 String 的长度可能不同于原 String。

    下表中给出了几个与语言环境有关和 1:M 大小写映射关系的一些示例。

    语言环境的代码小写大写描述
    tr (Turkish) u0069 u0130 小写字母 i -> 大写字母 I，上面有点
    tr (Turkish) u0131 u0049 小写字母 i，无点 -> 大写字母 I
    (all) u00df u0053 u0053 小写字母 sharp s -> 两个字母：SS
    (all) Fahrvergnügen FAHRVERGNÜN  
    参数：
    locale - 使用此语言环境的大小写转换规则
    返回：
    要转换为大写的 String。
    从以下版本开始：
    1.1
    另请参见：
    toUpperCase(), toLowerCase(), toLowerCase(Locale)

    toUpperCase

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

    注： 此方法与语言环境有关，如果用于应独立于语言环境解释的字符串，则可能生成不可预料的结果。示例有编程语言标识符、协议键、HTML 标记。例如，"title".toUpperCase() 在 Turkish（土耳其语）语言环境中返回 "T?TLE"，其中“?”是 LATIN CAPITAL LETTER I WITH DOT ABOVE 字符。对于与语言环境有关的字符，要获得正确的结果，请使用 toUpperCase(Locale.ENGLISH)。

    返回：
    要转换为大写的 String。
    另请参见：
    toUpperCase(Locale)

    3、append()

      （1）append()方法如果对8Bit的byte类型变量进行操作，是从高位到低位一位一位添加的，还是相反的顺序添加的呢？

    append

    public StringBuffer append(CharSequence s)
    将指定的 CharSequence 添加到该序列。

    按顺序将 CharSequence 参数中的字符添加到该序列中，使该序列增加该参数的长度。

    该方法的结果与调用 this.append(s, 0, s.length()) 完全相同；

    该方法在 this（目标）对象上实现同步，但不在源上（s）实现同步。

    如果 s 为 null，则添加 4 个 "null" 字符。

    指定者：
    接口 Appendable 中的 append
    参数：
    s - 要添加的 CharSequence。
    返回：
    此对象的一个引用。
    从以下版本开始：
    1.5 

    4、charAt()

     1 charAt
 2 public char charAt(int index)返回指定索引处的 char 值。索引范围为从 0 到 length() - 1。序列的第一个 char 值位于索引 0 处，第二个位于索引 1 处，依此类推，这类似于数组索引。 
 3 如果索引指定的 char 值是代理项，则返回代理项值。 
 4 
 5 
 6 指定者：
 7 接口 CharSequence 中的 charAt
 8 参数：
 9 index - char 值的索引。 
10 返回：
11 此字符串指定索引处的 char 值。第一个 char 值位于索引 0 处。 
12 抛出： 
13 IndexOutOfBoundsException - 如果 index 参数为负或不小于此字符串的长度。
     1 e.g.1:
 2           //将数字放到整数数组，逆序，字符串尾部对齐。
 3         int[] arrStr1=new int[str1.length()-flagStr1];//如果是负数，则字符串的长度需要减去符号位的那一位。
 4         for(int i=0;i<arrStr1.length;i++){
 5             arrStr1[i]=str1.charAt(str1.length() - 1 - i) - '0';
 6         }
 7         int[] arrStr2=new int[str2.length()-flagStr2];//如果是负数，则字符串的长度需要减去符号位的那一位。
 8         for(int i=0;i<arrStr2.length;i++){
 9             arrStr2[i]=str1.charAt(str2.length() - 1 - i) - '0';
10         }

    5、charValue()

     这是Character类的一个方法。不仅String是类，作为主数据类型的char，有对应的类Character。它的实例对象，是基本类型char的值。

    Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。 

     1 charValue
 2 public char charValue()
 3          返回此 Character 对象的值。 
 4 
 5          返回：
 6          此对象表示的基本 char 值。
 7 
 8 英文版：
 9 char charValue()
10 Converts this value to a CharValue and returns the result as a char. The value will be narrowed or widened as necessary, and magnitude or precision information may be lost (as if the primitive had been cast to a char, in the narrowing case).
11 Returns:
12 the value, converted to char

    6、equals()比较的是什么呢？

         Ans：记得比较的是字节组合。（对了一半，但是模棱两可。）

     1 equals
 2 public boolean equals(Object obj)
 3          指示其他某个对象是否与此对象“相等”。 
 4          equals 方法在非空对象引用上实现相等关系： 
 5 
 6             （1）自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。 
 7             （2）对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true      时，x.equals(y) 才应返回 true。 
 8             （3）传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。 
 9             （4）一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。 
10 对于任何非空引用值 x，x.equals(null) 都应返回 false。 
11 
12 Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。 
13 
14 注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。 
15 
16 
17 参数：
18 obj - 要与之比较的引用对象。 
19 返回：
20 如果此对象与 obj 参数相同，则返回 true；否则返回 false。
21 另请参见：
22 hashCode(), Hashtable
     1 //String类中的equals:
 2 
 3 equals
 4 public boolean equals(Object anObject)将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。 
    (TT观点：还是下面总结的，equals()比较的是判断两个对象是否在意义上相等。即，比较两个String对象是否带有相同的字节组合。也就是两个对象，相当于两个引用，是不是指向同一个对象。TT观：看来也是看是不是具有相同的字节组合。）)
     5 
 6 覆盖：
 7 类 Object 中的 equals
 8 参数：
 9 anObject - 与此 String 进行比较的对象。 
10 返回：
11 如果给定对象表示的 String 与此 String 相等，则返回 true；否则返回 false。
12 另请参见：
13 compareTo(String), equalsIgnoreCase(String)

        equals()和“==”的区别与联系：

     “==”的两个用法：

    （1）使用==来比较两个primitive 主数据类型，

    （2）或者判断两个引用是否引用同一个对象，即是否指向同一个对象。

    （3）==只能来比较两个变量的字节组合。

    （4）使用equals()，这个方法是object类的，使用这个方法可以来判断两个对象是否在意义上相等。（像是两个String对象是否带有相同的字节组合。TT观：看来也是看是不是具有相同的字节组合。）

         e.g.1:

    1 int a=3;
2 byte b=3;
3 if(a==b){//true}

    虽然int类型和byte类型的变量空间大小是不一样的，但是，==只比较两个变量的字节组合，只要字节组合相等，就判断为真，不管int变量的长度那么长了。

    e.g.2:

     1 Foo a=new Foo();
 2 
 3 Foo b=new Foo();
 4 
 5 Foo c=a;
 6 
 7 if(a==b)   {//false}
 8 if(a==c)   {//true}
 9 if(b==c)   {//false}
10 
11 //要记得，只是在比较字节组合的模样。此规则适用与primitive主数据类型。因此==运算符对参照相同对象的引用变量会返回true值。在此情况下，我们还是无法得知字节组合的样式，但可以确定的是所参照的相同的对象。

    7、contentEquals()

    1 contentEquals
2 public boolean contentEquals(StringBuffer sb)将此字符串与指定的 StringBuffer 比较。当且仅当此 String 与指定 StringBuffer 表示相同的字符序列时，结果才为 true。 也就是说String和StringBuffer指向同一个对象喽？？是这个意思吗？
3 
4 参数：
5 sb - 要与此 String 比较的 StringBuffer。 
6 返回：
7 如果此 String 与指定 StringBuffer 表示相同的字符序列，(就是字节组合。)则返回 true；否则返回 false。
8 从以下版本开始： 
9 1.4

     8、compareTo

     1 compareTo
 2 public int compareTo(String anotherString)
       按字典顺序比较两个字符串。
       该比较基于字符串中各个字符的 Unicode 值。按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。如果这两个字符串相等，则结果为 0；compareTo 只在方法 equals(Object) 返回 true 时才返回 0。 
 3 这是字典排序的定义。如果这两个字符串不同，那么它们要么在某个索引处的字符不同（该索引对二者均为有效索引），要么长度不同，或者同时具备这两种情况。如果它们在一个或多个索引位置上的字符不同，假设 k 是这类索引的最小值；则在位置 k 上具有较小值的那个字符串（使用 < 运算符确定），其字典顺序在其他字符串之前。在这种情况下，compareTo 返回这两个字符串在位置 k 处两个char 值的差，即值： 
 4 
 5  this.charAt(k)-anotherString.charAt(k)
 6  如果没有字符不同的索引位置，则较短字符串的字典顺序在较长字符串之前。在这种情况下，compareTo 返回这两个字符串长度的差，即值： 
 7  this.length()-anotherString.length()
 8  
 9 指定者：
10 接口 Comparable<String> 中的 compareTo
11 参数：
12 anotherString - 要比较的 String。 
13 返回：
14 如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。
  • 相关阅读:
    UVALive 3645 Objective: Berlin(最大流 ：时序模型)
    【】筛选素数法
    UVaLive 7361（矩阵快速幂）
    【模板】KMP字符串匹配【KMP】
    【模板】KMP字符串匹配【KMP】
    【模板】KMP字符串匹配【KMP】
    八百标兵奔北坡【DP】
    八百标兵奔北坡【DP】
    八百标兵奔北坡【DP】
    八百标兵奔北坡【DP】
  • 原文地址：https://www.cnblogs.com/meihao1989/p/3265063.html
Copyright © 2020-2023  润新知