紫薇星上的Java——JavaOO（5）

最新推荐文章于 2024-09-06 23:25:28 发布
最新推荐文章于 2024-09-06 23:25:28 发布
阅读量285 收藏
点赞数
分类专栏： 紫薇星上的Java 文章标签： Java 系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39732867/article/details/104192520
版权

第一部分我们整理了一些Java的基础知识点，详情可戳👉紫薇星上的Java——JavaOO（1）

第二部分我们整理了修饰符、运算符与逻辑控制的知识点，详情可戳👉紫薇星上的Java——JavaOO（2）

第三部分我们正式进入了JavaOO的世界，学习了类与对象，数组以及方法的使用，详情可戳👉紫薇星上的Java——JavaOO（3）

第四部分我们整理了一些实用的类与方法如 Number&Math类和Character 类，详情可戳👉紫薇星上的Java——JavaOO（4）

这部分我们将延续上一部分关于类与方法的整理，如String类、StringBuffer类等，虽然有点枯燥都是在说一些方法，但阅读后会留有一些印象总归是好的，大噶加油！

15.Java String 类

字符串广泛应用 在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

15.1 字符串

  • 创建字符串

创建字符串最简单的方式如下:

String greeting = "紫薇星";

在代码中遇到字符串常量时，这里的值是 "紫薇星"，编译器会使用该值创建一个 String 对象，和其它对象一样，可以使用关键字和构造方法来创建 String 对象，String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:

public class StringDemo{
   public static void main(String args[]){
      char[] helloArray = { 'z', 'i', 'j', 'u', 'n'};
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}

当上面的代码被编译时，它会产生下列结果：

zijun

注意:String 类是不可改变的，所以一旦创建了 String 对象，那它的值就无法改变了，如果需要对字符串做很多修改，那么应该选择使用StringBuffer类&StringBuilder类。

  • 字符串长度

用于获取有关对象的信息的方法称为访问器方法，String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数，下面的代码执行后，len 变量等于 5:

public class StringDemo {
    public static void main(String args[]) {
        String site = "zijun";
        int len = site.length();
        System.out.println( "长度 : " + len );
   }
}

当上面的代码被编译时，它会产生下列结果：

长度：5
  • 连接字符串

String 类提供了连接两个字符串的方法：

string1.concat(string2);

返回 string2 连接 string1 的新字符串,也可以对字符串常量使用 concat() 方法，如：

"我的名字是 ".concat("Zijun");

更常用的是使用'+'操作符来连接字符串，如：

"Hello," + " runoob" + "!"

下面是一个例子：

public class StringDemo {
    public static void main(String args[]) {     
        String string1 = "紫薇星地址：";     
        System.out.println("1、" + string1 + "https://blog.csdn.net/qq_39732867");  
    }
}

当上面的代码被编译时，它会产生下列结果：

1、紫薇星地址：https://blog.csdn.net/qq_39732867
  • 创建格式化字符串

我们知道输出格式化数字可以使用 printf() 和 format() 方法，String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象，String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出，如下所示：

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);

或者这样写也可以：

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

15.2 String 方法

下面是 String 类支持的方法：

序号方法描述
1char charAt(int index)     返回指定索引处的 char 值。
2int compareTo(Object O)     把这个字符串和另一个对象比较。
3int compareTo(String anotherString)     按字典顺序比较两个字符串。
4int compareToIhnoreCase(Sting str)     按字典顺序比较两个字符串，不考虑大小写。
5String concat(String str)     将指定字符串连接到此字符串的结尾。
6boolean contentEquals(StringBuffer sb)     当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
7static String copyValueOf(char[] data)     返回指定数组中表示该字符序列的 String。
8static String copyValueOf(char[] data, int offset, int count)     返回指定数组中表示该字符序列的 String。
9boolean endsWith(String suffix)     测试此字符串是否以指定的后缀结束。
10boolean equals(Object anObject)     将此字符串与指定的对象比较。
11boolean equalslgnoreCase(String anotherString)     将此 String 与另一个 String 比较，不考虑大小写。
12byte[] getBytes()     使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
13byte[] getBytes(String charsetName)   使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
14void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)     将字符从此字符串复制到目标字符数组。
15int hashCode()     返回此字符串的哈希码。
16int indexOf(int ch)返回指定字符在此字符串中第一次出现处的索引。
17int indexOf(int ch, int fromIndex)     返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
18int indexOf(String str)     返回指定子字符串在此字符串中第一次出现处的索引。
19int indexOf(String str, int fromIndex)     返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
20String intern()     返回字符串对象的规范化表示形式。
21int lastIndexOf(int ch)     返回指定字符在此字符串中最后一次出现处的索引。
22int lastIndexOf(int ch, int fromIndex)    返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
23int lastIndexOf(String str)     返回指定子字符串在此字符串中最右边出现处的索引。
24int lastIndexOf(String str, int fromIndex)  返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
25int length()     返回此字符串的长度。
26boolean matches(String regex)     告知此字符串是否匹配给定的正则表达式。
27boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)     测试两个字符串区域是否相等。
28boolean regionMatches(int toffset, Seting other, int ooffset,int len)     测试两个字符串区域是否相等。
29String replace(char oldChar, char newChar)    返回一个新字符串，通过用newChar替换此字符串中出现的所有oldChar得到的。
30String replaceAll(String regex, String replacement) 使用给定的replacement替换此字符串所有匹配给定正则表达式的子字符串。
31String replaceFirst(String regex, String replacement) 使用给定的replacement替换此字符串匹配给定正则表达式首个子字符串。
32String[] split(String regex)     根据给定正则表达式的匹配拆分此字符串。
33String[] split(String regex, int limit)     根据匹配给定的正则表达式来拆分此字符串。
34boolean startsWith(String prefix)     测试此字符串是否以指定的前缀开始。
35boolean startsWith(String prefix, int toffset)     测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36CharSequence subSequence(int beginIndex, int endIndex)     返回一个新的字符序列，它是此序列的一个子序列。
37String substring(int beginIndex)     返回一个新的字符串，它是此字符串的一个子字符串。
38String substring(int beginIndex, int endIndex)     返回一个新字符串，它是此字符串的一个子字符串。
39char[] toCharArray()     将此字符串转换为一个新的字符数组。
40String toLowerCase()     使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41String toLowerCase(Locale locale)     使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42String toString()     返回此对象本身（它已经是一个字符串！）。
43String toUpperCase()     使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44String toUpperCase(Locale locale)     使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45String trim()     返回字符串的副本，忽略前导空白和尾部空白。
46static String valueOf(primitive data type x)     返回给定data type类型x参数的字符串表示形式。

接下来我们一一来说明，下面这段会有些长，主要是对上表的内容进行进一步解释与举例，如需跳过请点击：16.Java StringBuffer 和 StringBuilder 类

  • Java charAt() 方法

charAt() 方法用于返回指定索引处的字符，索引范围为从 0 到 length() - 1。格式如下：

public char charAt(int index)

参数：index -- 字符的索引。

返回值：返回指定索引处的字符。

public class Test {
 
    public static void main(String args[]) {
        String s = "www.runoob.com";
        char result = s.charAt(8);
        System.out.println(result);
    }
}

当上面的代码被编译时，它会产生下列结果：

0
  • Java compareTo() 方法

compareTo() 方法用于两种方式的比较：字符串与对象进行比较、按字典顺序比较两个字符串。格式如下：

int compareTo(Object o)

int compareTo(String anotherString)

参数：o -- 要比较的对象、anotherString -- 要比较的字符串。

返回值：返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至比较的字符或被比较的字符有一方结束。

  1. 如果参数字符串等于此字符串，则返回值 0；
  2. 如果此字符串小于字符串参数，则返回一个小于 0 的值；
  3. 如果此字符串大于字符串参数，则返回一个大于 0 的值。
public class Test {
 
    public static void main(String args[]) {
        String str1 = "Strings";
        String str2 = "Strings";
        String str3 = "Strings123";
 
        int result = str1.compareTo( str2 );
        System.out.println(result);
      
        result = str2.compareTo( str3 );
        System.out.println(result);
     
        result = str3.compareTo( str1 );
        System.out.println(result);
    }
}

当上面的代码被编译时，它会产生下列结果：

0
-3
3
  • Java compareToIgnoreCase() 方法

compareToIgnoreCase() 方法用于按字典顺序比较两个字符串，不考虑大小写。格式如下：

int compareToIgnoreCase(String str)

参数：str -- 要比较的字符串。

返回值

  1. 如果参数字符串等于此字符串，则返回值 0；
  2. 如果此字符串小于字符串参数，则返回一个小于 0 的值；
  3. 如果此字符串大于字符串参数，则返回一个大于 0 的值。
public class Test {

    public static void main(String args[]) {
        String str1 = "STRINGS";
        String str2 = "Strings";
        String str3 = "Strings123";

        int result = str1.compareToIgnoreCase( str2 );
        System.out.println(result);
      
        result = str2.compareToIgnoreCase( str3 );
        System.out.println(result);
     
        result = str3.compareToIgnoreCase( str1 );
        System.out.println(result); 
    }
}

当上面的代码被编译时，它会产生下列结果：

0
-3
3
  • Java concat() 方法

concat() 方法用于将指定的字符串参数连接到字符串上。格式如下：

public String concat(String s)

参数：s -- 要连接的字符串。

返回值：返回连接后的新字符串。

public class Test {
    public static void main(String args[]) {
        String s = "紫薇星：";
        s = s.concat("https://blog.csdn.net/qq_39732867");
        System.out.println(s);
    }
}

当上面的代码被编译时，它会产生下列结果：

紫薇星：https://blog.csdn.net/qq_39732867
  • Java contentEquals() 方法

contentEquals() 方法用于将此字符串与指定的 StringBuffer 比较。格式如下：

public boolean contentEquals(StringBuffer sb)

参数：sb -- 要与字符串比较的 StringBuffer。

返回值：如字符串与指定 StringBuffer 表示相同的字符序列，则返回 true；否则返回 false。

public class Test {
    public static void main(String args[]) {
        String str1 = "String1";
        String str2 = "String2";
        StringBuffer str3 = new StringBuffer( "String1");

        boolean  result = str1.contentEquals( str3 );
        System.out.println(result);
          
        result = str2.contentEquals( str3 );
        System.out.println(result);
    }
}

当上面的代码被编译时，它会产生下列结果：

true
false
  • Java copyValueOf() 方法

copyValueOf() 方法有两种形式：

  1. public static String copyValueOf(char[] data): 返回指定数组中表示该字符序列的字符串。

  2. public static String copyValueOf(char[] data, int offset, int count): 返回指定数组中表示该字符序列的 字符串。

public static String copyValueOf(char[] data)

public static String copyValueOf(char[] data, int offset, int count)

参数：data -- 字符数组、offset -- 子数组的初始偏移量、count -- 子数组的长度。

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

public class Test {
    public static void main(String args[]) {
        char[] Str1 = {'h', 'e', 'l', 'l', 'o', ' ', 'z', 'i', 'j', 'u', 'n'};
        String Str2 = "";
 
        Str2 = Str2.copyValueOf( Str1 );
        System.out.println("返回结果：" + Str2);
 
        Str2 = Str2.copyValueOf( Str1, 2, 6 );
        System.out.println("返回结果：" + Str2);
    }
}

当上面的代码被编译时，它会产生下列结果：

返回结果：hello zijun
返回结果：llo zi
  • Java endsWith() 方法

endsWith() 方法用于测试字符串是否以指定的后缀结束。格式如下：

public boolean endsWith(String suffix)

参数：suffix -- 指定的后缀。

返回值：如果参数表示的字符序列是此对象表示的字符序列的后缀，则返回 true；否则返回 false。注意，如果参数是空字符串，或者等于此 String 对象（用 equals(Object) 方法确定），则结果为 true。

public class Test {
    public static void main(String args[]) {
        String Str = new String("Zijun：https://blog.csdn.net");
        boolean retVal;
 
        retVal = Str.endsWith( "https" );
        System.out.println("返回值 = " + retVal );
 
        retVal = Str.endsWith( "net" );
        System.out.println("返回值 = " + retVal );
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 = false
返回值 = true
  • Java equals() 方法

equals() 方法用于将字符串与指定的对象比较，格式如下：

public boolean equals(Object anObject)

参数：anObject -- 与字符串进行比较的对象。

返回值：如果给定对象与字符串相等，则返回 true；否则返回 false。

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("zijun");
        String Str2 = Str1;
        String Str3 = new String("zijun");
        boolean retVal;

        retVal = Str1.equals( Str2 );
        System.out.println("返回值 = " + retVal );

        retVal = Str1.equals( Str3 );
        System.out.println("返回值 = " + retVal );
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 = true
返回值 = true
  • Java equalsIgnoreCase() 方法

equalsIgnoreCase() 方法用于将字符串与指定的对象比较，不考虑大小写，格式如下：

public boolean equalsIgnoreCase(String anotherString)

参数：anObject -- 与字符串进行比较的对象。

返回值：如果给定对象与字符串相等，则返回 true；否则返回 false。

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("zijun");
        String Str2 = Str1;
        String Str3 = new String("zijun");
        String Str4 = new String("ZIJUN");
        boolean retVal;

        retVal = Str1.equals( Str2 );
        System.out.println("返回值 = " + retVal );

        retVal = Str3.equals( Str4);
        System.out.println("返回值 = " + retVal );

        retVal = Str1.equalsIgnoreCase( Str4 );
        System.out.println("返回值 = " + retVal );
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 = true
返回值 = false
返回值 = true
  • Java getBytes() 方法

getBytes() 方法有两种形式：

  1. getBytes(String charsetName): 使用指定的字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

  2. getBytes(): 使用平台的默认字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

public byte[] getBytes(String charsetName) throws UnsupportedEncodingException

public byte[] getBytes()

参数：charsetName -- 支持的字符集名称。

返回值：返回 byte 数组。

import java.io.*;
 
public class Test {
    public static void main(String args[]) {
        String Str1 = new String("zijun");
 
        try{
            byte[] Str2 = Str1.getBytes();
            System.out.println("返回值：" + Str2 );
            
            Str2 = Str1.getBytes( "UTF-8" );
            System.out.println("返回值：" + Str2 );
            
            Str2 = Str1.getBytes( "ISO-8859-1" );
            System.out.println("返回值：" + Str2 );
        } catch ( UnsupportedEncodingException e){
            System.out.println("不支持的字符集");
        }
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值：[B@506e6d5e
返回值：[B@96532d6
返回值：[B@3796751b
  • Java getChars() 方法

getChars() 方法将字符从字符串复制到目标字符数组。格式如下：

public void getChars(int srcBegin, int srcEnd, char[] dst,  int dstBegin)

参数

  1. srcBegin -- 字符串中要复制的第一个字符的索引。

  2. srcEnd -- 字符串中要复制的最后一个字符之后的索引。

  3. dst -- 目标数组。

  4. dstBegin -- 目标数组中的起始偏移量。

返回值：没有返回值，但会抛出 IndexOutOfBoundsException 异常。

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("www.csdn.com");
        char[] Str2 = new char[6];

        try {
            Str1.getChars(4, 8, Str2, 0);
            System.out.print("拷贝的字符串为：" );
            System.out.println(Str2 );
        } catch( Exception ex) {
            System.out.println("触发异常...");
        }
    }
}

当上面的代码被编译时，它会产生下列结果：

csdn
  • Java hashCode() 方法

hashCode() 方法用于返回字符串的哈希码，字符串对象的哈希码根据以下公式计算：

s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

使用 int 算法，这里 s[i] 是字符串的第 i 个字符，n 是字符串的长度，^ 表示求幂。空字符串的哈希值为 0。格式如下：

public int hashCode()

参数：无。

返回值：返回对象的哈希码值。

public class Test {
        public static void main(String args[]) {
                String Str = new String("www.csdn.com");
                System.out.println("字符串的哈希码为 :" + Str.hashCode() );
        }
}

当上面的代码被编译时，它会产生下列结果：

字符串的哈希码为 :-1667458812
  • Java indexOf() 方法

indexOf() 方法有以下四种形式：

  1. public int indexOf(int ch): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

  2. public int indexOf(int ch, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

  3. int indexOf(String str): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

  4. int indexOf(String str, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

public int indexOf(int ch )

public int indexOf(int ch, int fromIndex)

int indexOf(String str)

int indexOf(String str, int fromIndex)

参数

  1. ch -- 字符，Unicode 编码。

  2. fromIndex -- 开始搜索的索引位置，第一个字符是 0 ，第二个是 1 ，以此类推。

  3. str -- 要搜索的子字符串。

返回值：查找字符串，或字符 Unicode 编码在字符串出现的位置。

public class Main {
    public static void main(String args[]) {
        String string = "aaa456ac";  
        //查找指定字符是在字符串中的下标。在则返回所在字符串下标；不在则返回-1.  
        System.out.println(string.indexOf("b")); // indexOf(String str); 返回结果：-1，"b"不存在  
 
        // 从第四个字符位置开始往后继续查找，包含当前位置  
        System.out.println(string.indexOf("a",3));//indexOf(String str, int fromIndex); 返回结果：6  
 
        //（与之前的差别：上面的参数是 String 类型，下面的参数是 int 类型）参考数据：a-97,b-98,c-99  
 
        // 从头开始查找是否存在指定的字符  
        System.out.println(string.indexOf(99));//indexOf(int ch)；返回结果：7  
        System.out.println(string.indexOf('c'));//indexOf(int ch)；返回结果：7  
 
        //从fromIndex查找ch，这个是字符型变量，不是字符串。字符a对应的数字就是97。  
        System.out.println(string.indexOf(97,3));//indexOf(int ch, int fromIndex); 返回结果：6  
        System.out.println(string.indexOf('a',3));//indexOf(int ch, int fromIndex); 返回结果：6  
    }
}

当上面的代码被编译时，它会产生下列结果：

-1
6
7
7
6
6

指定子字符串在字符串中第一次出现处的索引，从指定的索引开始。

public class Test {
    public static void main(String args[]) {
        String Str = new String("紫薇星:https://blog.csdn.net/qq_39732867");
        String SubStr1 = new String("https");
        String SubStr2 = new String("net");
 
        System.out.print("查找字符 o 第一次出现的位置 :" );
        System.out.println(Str.indexOf( 'o' ));
        System.out.print("从第14个位置查找字符 o 第一次出现的位置 :" );
        System.out.println(Str.indexOf( 'o', 14 ));
        System.out.print("子字符串 SubStr1 第一次出现的位置:" );
        System.out.println( Str.indexOf( SubStr1 ));
        System.out.print("从第十五个位置开始搜索子字符串 SubStr1 第一次出现的位置 :" );
        System.out.println( Str.indexOf( SubStr1, 15 ));
        System.out.print("子字符串 SubStr2 第一次出现的位置 :" );
        System.out.println(Str.indexOf( SubStr2 ));
    }
}

当上面的代码被编译时，它会产生下列结果：

查找字符 o 第一次出现的位置 :14
从第14个位置查找字符 o 第一次出现的位置 :14
子字符串 SubStr1 第一次出现的位置:4
从第十五个位置开始搜索子字符串 SubStr1 第一次出现的位置 :-1
子字符串 SubStr2 第一次出现的位置 :22
  • Java intern() 方法

intern() 方法返回字符串对象的规范化表示形式，遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。

public String intern()

参数：无

返回值：一个字符串，内容与此字符串相同，但一定取自具有唯一字符串的池。

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("www.csdn.com");
        String Str2 = new String("WWW.CSDN.COM");

        System.out.print("规范表示:" );
        System.out.println(Str1.intern());

        System.out.print("规范表示:" );
        System.out.println(Str2.intern());
    }
}

当上面的代码被编译时，它会产生下列结果：

规范表示:www.csdn.com
规范表示:WWW.CSDN.COM
  • Java lastIndexOf() 方法

lastIndexOf() 方法有以下四种形式：

  1. public int lastIndexOf(int ch): 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

  2. public int lastIndexOf(int ch, int fromIndex): 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索，如果此字符串中没有这样的字符，则返回 -1。

  3. public int lastIndexOf(String str): 返回指定子字符串在此字符串中最右边出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

  4. public int lastIndexOf(String str, int fromIndex): 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索，如果此字符串中没有这样的字符，则返回 -1。

public int lastIndexOf(int ch)

public int lastIndexOf(int ch, int fromIndex)

public int lastIndexOf(String str)

public int lastIndexOf(String str, int fromIndex)

参数

  1. ch -- 字符。

  2. fromIndex -- 开始搜索的索引位置。

  3. str -- 要搜索的子字符串。

返回值：指定子字符串在字符串中第一次出现处的索引值。

public class Test {
    public static void main(String args[]) {
        String Str = new String("紫薇星:https://blog.csdn.net/qq_39732867");
        String SubStr1 = new String("https");
        String SubStr2 = new String("net");

        System.out.print("查找字符 o 最后出现的位置 :" );
        System.out.println(Str.lastIndexOf( 'o' ));
        System.out.print("从第14个位置查找字符 o 最后出现的位置 :" );
        System.out.println(Str.lastIndexOf( 'o', 14 ));
        System.out.print("子字符串 SubStr1 最后出现的位置:" );
        System.out.println( Str.lastIndexOf( SubStr1 ));
        System.out.print("从第十五个位置开始搜索子字符串 SubStr1最后出现的位置 :" );
        System.out.println( Str.lastIndexOf( SubStr1, 15 ));
        System.out.print("子字符串 SubStr2 最后出现的位置 :" );
        System.out.println(Str.lastIndexOf( SubStr2 ));
    }
}

当上面的代码被编译时，它会产生下列结果：

查找字符 o 最后出现的位置 :14
从第14个位置查找字符 o 最后出现的位置 :14
子字符串 SubStr1 最后出现的位置:4
从第十五个位置开始搜索子字符串 SubStr1最后出现的位置 :4
子字符串 SubStr2 最后出现的位置 :22
  • Java length() 方法

length() 方法用于返回字符串的长度，长度等于字符串中 16 位 Unicode 代码单元的数量。格式如下：

public int length()

参数：无

返回值：返回字符串长度。

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("www.csdn.com");
        String Str2 = new String("csdn" );

        System.out.print("字符串 Str1 长度 :");
        System.out.println(Str1.length());
        System.out.print("字符串 Str2 长度 :");
        System.out.println(Str2.length());
    }
}

当上面的代码被编译时，它会产生下列结果：

字符串 Str1 长度 :12
字符串 Str2 长度 :4
  • Java matches() 方法

matches() 方法用于检测字符串是否匹配给定的正则表达式，调用此方法的 str.matches(regex) 形式与以下表达式产生的结果完全相同：

Pattern.matches(regex, str)

语法格式如下：

public boolean matches(String regex)

参数：regex -- 匹配字符串的正则表达式。

返回值：在字符串匹配给定的正则表达式时，返回 true。

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.csdn.com");

        System.out.print("返回值 :" );
        System.out.println(Str.matches("(.*)csdn(.*)"));
        
        System.out.print("返回值 :" );
        System.out.println(Str.matches("(.*)google(.*)"));

        System.out.print("返回值 :" );
        System.out.println(Str.matches("www(.*)"));
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 :true
返回值 :false
返回值 :true
  • Java regionMatches() 方法

regionMatches() 方法用于检测两个字符串在一个区域内是否相等。语法格式如下：

public boolean regionMatches(int toffset, String other, int ooffset, int len)

public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)

参数

  1. ignoreCase -- 如果为 true，则比较字符时忽略大小写。

  2. toffset -- 此字符串中子区域的起始偏移量。

  3. other -- 字符串参数。

  4. ooffset -- 字符串参数中子区域的起始偏移量。

  5. len -- 要比较的字符数。

返回值：如果字符串的指定子区域匹配字符串参数的指定子区域，则返回 true；否则返回 false。是否完全匹配或考虑大小写取决于 ignoreCase 参数。

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("www.csdn.com");
        String Str2 = new String("csdn");
        String Str3 = new String("CSDN");

        System.out.print("返回值 :" );
        System.out.println(Str1.regionMatches(4, Str2, 0, 4));

        System.out.print("返回值 :" );
        System.out.println(Str1.regionMatches(4, Str3, 0, 4));

        System.out.print("返回值 :" );
        System.out.println(Str1.regionMatches(true, 4, Str3, 0, 4));
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 :true
返回值 :false
返回值 :true
  • Java replace() 方法

replace() 方法通过用 newChar 字符替换字符串中出现的所有 oldChar 字符，并返回替换后的新字符串。格式如下：

public String replace(char oldChar, char newChar)

参数：oldChar -- 原字符、newChar -- 新字符。

返回值：替换后生成的新字符串。

public class Test {
    public static void main(String args[]) {
        String Str = new String("hello");

        System.out.print("返回值 :" );
        System.out.println(Str.replace('o', 'T'));

        System.out.print("返回值 :" );
        System.out.println(Str.replace('l', 'D'));
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 :hellT
返回值 :heDDo
  • Java replaceAll() 方法

replaceAll() 方法使用给定的参数 replacement 替换字符串所有匹配给定的正则表达式的子字符串。格式如下：

public String replaceAll(String regex, String replacement)

参数：regex -- 匹配此字符串的正则表达式、newChar -- 用来替换每个匹配项的字符串。

返回值：成功则返回替换的字符串，失败则返回原始字符串。

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.google.com");

        System.out.print("匹配成功返回值 :" );
        System.out.println(Str.replaceAll("(.*)google(.*)", "csdn" ));
        System.out.print("匹配失败返回值 :" );
        System.out.println(Str.replaceAll("(.*)taobao(.*)", "csdn" ));
    }
}

当上面的代码被编译时，它会产生下列结果：

匹配成功返回值 :csdn
匹配失败返回值 :www.google.com
  • Java replaceFirst() 方法

replaceFirst() 方法使用给定的参数 replacement 替换字符串第一个匹配给定的正则表达式的子字符串。格式如下：

public String replaceFirst(String regex, String replacement)

参数：regex -- 匹配此字符串的正则表达式、replacement -- 用来替换第一个匹配项的字符串。

返回值：成功则返回替换的字符串，失败则返回原始字符串。

public class Test {
    public static void main(String args[]) {
        String Str = new String("hello csdn，I am from csdn。");

        System.out.print("返回值 :" );
        System.out.println(Str.replaceFirst("csdn", "google" ));
        System.out.print("返回值 :" );
        System.out.println(Str.replaceFirst("(.*)csdn(.*)", "google" ));
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 :hello google，I am from csdn。
返回值 :google
  • Java split() 方法

split() 方法根据匹配给定的正则表达式来拆分字符串。格式如下：

注意： . 、 $、 | 和 * 等转义字符，必须得加 \\ 。多个分隔符，可以用 | 作为连字符。

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

参数：regex -- 正则表达式分隔符、limit -- 分割的份数。

返回值：字符串数组。

public class Test {
    public static void main(String args[]) {
        String str = new String("Welcome-to-Csdn");
 
        System.out.println("- 分隔符返回值 :" );
        for (String retval: str.split("-")){
            System.out.println(retval);
        }
 
        System.out.println("");
        System.out.println("- 分隔符设置分割份数返回值 :" );
        for (String retval: str.split("-", 2)){
            System.out.println(retval);
        }
 
        System.out.println("");
        String str2 = new String("www.csdn.com");
        System.out.println("转义字符返回值 :" );
        for (String retval: str2.split("\\.", 3)){
            System.out.println(retval);
        }
 
        System.out.println("");
        String str3 = new String("acount=? and uu =? or n=?");
        System.out.println("多个分隔符返回值 :" );
        for (String retval: str3.split("and|or")){
            System.out.println(retval);
        }
    }
}

当上面的代码被编译时，它会产生下列结果：

- 分隔符返回值 :
Welcome
to
Csdn

- 分隔符设置分割份数返回值 :
Welcome
to-Csdn

转义字符返回值 :
www
csdn
com

多个分隔符返回值 :
acount=? 
 uu =? 
 n=?
  • Java startsWith() 方法

startsWith() 方法用于检测字符串是否以指定的前缀开始。格式如下：

public boolean startsWith(String prefix, int toffset)

public boolean startsWith(String prefix)

参数：prefix -- 前缀、toffset -- 字符串中开始查找的位置。

返回值：如果字符串以指定的前缀开始，则返回 true；否则返回 false。

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.csdn.com");
 
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("www") );
 
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("csdn") );
 
        System.out.print("返回值 :" );
        System.out.println(Str.startsWith("csdn", 4) );
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 :true
返回值 :false
返回值 :true
  • Java subSequence() 方法

subSequence() 方法返回一个新的字符序列，它是此序列的一个子序列。格式如下：

public CharSequence subSequence(int beginIndex, int endIndex)

参数：beginIndex -- 起始索引（包括）、endIndex -- 结束索引（不包括）。

返回值：返回一个新的字符序列，它是此序列的一个子序列。

public class Test {
    public static void main(String args[]) {
         String Str = new String("www.csdn.com");

         System.out.print("返回值 :" );
         System.out.println(Str.subSequence(4, 10) );
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 :csdn.c
  • Java substring() 方法

substring() 方法返回字符串的子字符串。格式如下：

public String substring(int beginIndex)

public String substring(int beginIndex, int endIndex)

参数：beginIndex -- 起始索引（包括）, 索引从 0 开始、endIndex -- 结束索引（不包括）。

返回值：子字符串。

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.csdn.com");
 
        System.out.print("返回值 :" );
        System.out.println(Str.substring(4) );
 
        System.out.print("返回值 :" );
        System.out.println(Str.substring(4, 10) );
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 :csdn.com
返回值 :csdn.c
  • Java toCharArray() 方法

toCharArray() 方法将字符串转换为字符数组，格式如下：

public char[] toCharArray()

参数：无

返回值：字符数组。

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.csdn.com");

        System.out.print("返回值 :" );
        System.out.println( Str.toCharArray() );
    }
}

当上面的代码被编译时，它会产生下列结果：

www.csdn.com
  • Java toLowerCase() 方法

toLowerCase() 方法将字符串转换为小写，格式如下：

public String toLowerCase()

public String toLowerCase(Locale locale)

参数：无

返回值：转换为小写的字符串。

public class Test {
    public static void main(String args[]) {
        String Str = new String("WWW.CSDN.COM");

        System.out.print("返回值 :" );
        System.out.println( Str.toLowerCase() );
    }
}

当上面的代码被编译时，它会产生下列结果：

www.csdn.com
  • Java toString() 方法

toString() 方法返回此对象本身（它已经是一个字符串），格式如下：

public String toString()

参数：无

返回值：字符串本身。

public class Test {
    public static void main(String args[]) {
        String Str = new String("WWW.CSDN.COM");

        System.out.print("返回值 :" );
        System.out.println( Str.toString() );
    }
}

当上面的代码被编译时，它会产生下列结果：

WWW.CSDN.COM
  • Java toUpperCase() 方法

toUpperCase() 方法将字符串小写字符转换为大写，格式如下：

public String toUpperCase()

public String toUpperCase(Locale locale)

参数：无

返回值：字符转换为大写后的字符串。

public class Test {
    public static void main(String args[]) {
        String Str = new String("www.csdn.com");

        System.out.print("返回值 :" );
        System.out.println( Str.toUpperCase() );
    }
}

当上面的代码被编译时，它会产生下列结果：

WWW.CSDN.COM
  • Java trim() 方法

trim() 方法用于删除字符串的头尾空白符，格式如下：

public String trim()

参数：无

返回值：删除头尾空白符的字符串。

public class Test {
    public static void main(String args[]) {
        String Str = new String("    www.csdn.com    ");
        System.out.print("原始值 :" );
        System.out.println( Str );

        System.out.print("删除头尾空白 :" );
        System.out.println( Str.trim() );
    }
}

当上面的代码被编译时，它会产生下列结果：

原始值 :    www.csdn.com    
删除头尾空白 :www.csdn.com
  • Java valueOf() 方法

valueOf() 方法有以下几种不同形式：

  1. valueOf(boolean b): 返回 boolean 参数的字符串表示形式。.

  2. valueOf(char c): 返回 char 参数的字符串表示形式。

  3. valueOf(char[] data): 返回 char 数组参数的字符串表示形式。

  4. valueOf(char[] data, int offset, int count): 返回 char 数组参数的特定子数组的字符串表示形式。

  5. valueOf(double d): 返回 double 参数的字符串表示形式。

  6. valueOf(float f): 返回 float 参数的字符串表示形式。

  7. valueOf(int i): 返回 int 参数的字符串表示形式。

  8. valueOf(long l): 返回 long 参数的字符串表示形式。

  9. valueOf(Object obj): 返回 Object 参数的字符串表示形式。

static String valueOf(boolean b) 

static String valueOf(char c) 

static String valueOf(char[] data) 

static String valueOf(char[] data, int offset, int count) 

static String valueOf(double d) 

static String valueOf(float f) 

static String valueOf(int i)

static String valueOf(long l)

static String valueOf(Object obj)

参数：指定类型参数。

返回值：删除头尾空白符的字符串。

public class Test {
    public static void main(String args[]) {
        double d = 1100.00;
        boolean b = true;
        long l = 1234567890;
        char[] arr = {'z', 'i', 'j', 'u', 'n'};

        System.out.println("返回值 : " + String.valueOf(d) );
        System.out.println("返回值 : " + String.valueOf(b) );
        System.out.println("返回值 : " + String.valueOf(l) );
        System.out.println("返回值 : " + String.valueOf(arr) );
    }
}

当上面的代码被编译时，它会产生下列结果：

返回值 : 1100.0
返回值 : true
返回值 : 1234567890
返回值 : zijun

16.Java StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类，和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问），由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类，然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

public class Test{
  public static void main(String args[]){
    StringBuffer sBuffer = new StringBuffer("CSDN官网：");
    sBuffer.append("www");
    sBuffer.append(".csdn");
    sBuffer.append(".com");
    System.out.println(sBuffer);  
  }
}

当上面的代码被编译时，它会产生下列结果：

CSDN官网：www.csdn.com
  • StringBuffer 方法

以下是 StringBuffer 类支持的主要方法：

序号方法描述
1public StringBuffer append(String s)     将指定的字符串追加到此字符序列。
2public StringBuffer reverse()     将此字符序列用其反转形式取代。
3public delete(int start, int end)     移除此序列的子字符串中的字符。
4public insert(int offset, int i)     将 int 参数的字符串表示形式插入此序列中。
5replace(int start, int end, String str)     使用给定 String 中的字符替换此序列的子字符串中的字符。

下面的列表里的方法和 String 类的方法类似：

序号方法描述
1int capacity()     返回当前容量。
2char charAt(int index)     返回此序列中指定索引处的 char 值。
3void ensureCapacity(int minimumCapacity)     确保容量至少等于指定的最小值。
4void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)     将字符从此序列复制到目标字符数组 dst。
5int indexOf(String str)     返回第一次出现的指定子字符串在该字符串中的索引。
6int indexOf(String str, int fromIndex)     从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7int lastIndexOf(String str)     返回最右边出现的指定子字符串在此字符串中的索引。
8int lastIndexOf(String str, int fromIndex)     返回 String 对象中子字符串最后出现的位置。
9int length()     返回长度（字符数）。
10void setCharAt(int index, char ch)     将给定索引处的字符设置为 ch。
11void setLength(int newLength)     设置字符序列的长度。
12CharSequence subSequence(int start, int end)     返回一个新的字符序列，该字符序列是此序列的子序列。
13String substring(int start)     返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
14String substring(int start, int end)     返回一个新的 String，它包含此序列当前所包含的字符子序列。
15String toString()     返回此序列中数据的字符串表示形式。

经过了这么长时间，一些实用的类与方法终于写的差的多了，下一部分将回归正题，我们将整理Java中日期与时间，I/O流，异常处理的知识点。最近疫情越来愈严重了，昨天已经实施每户人家两天之内只允许一人出门采购物资，大噶一定要注意卫生，戴好口罩，勤洗手勤消毒，我们下次见👋

紫郡
关注
专栏目录
Java代驾网站 毕业设计大纲
03-14
在Java Web开发中，这种模式通常体现在JSP、Servlet和模型组件上。MVC（Model-View-Controller）模式是实现这一架构的具体策略，模型处理数据，视图负责展示，控制器协调两者之间的交互。 二、Servlet和JSP Servlet...
JAVA小区门户网站毕业设计大纲
03-14
本项目旨在开发一款Java小区门户网站，为小区业主提供全方位的服务和信息发布平台。该平台将包括门户网站、管理后台、业主自助服务等模块。门户网站主要为业主提供小区新闻、活动、故障报修、安全提醒、物业公告等...
紫微斗数算法的实现流程
绝影-"安德斯"-的专栏
09-06 1023
我想，在当下信息技术加持下，借助大数据+人工智能，传统的紫微斗数学问，必将大放异彩，必将也成为了中国文化重要组成部分，对此我深信不疑。
紫薇星上的Java——JavaOO（1）
紫郡的博客
02-03 359
这个系列我们来整理Java中的知识点，我个人是先学习了C语言才学习Java的，所以建议大家了解一下C语言后再学习Java上手会非常快，这个系列会分为几个部分来整理，我们首先整理JavaOO（Java Object Oriented Java面向对象），同时在整理中免不了使用代码来进行举例，由于Java的代码数量较多(ˉ▽ˉ；)...所以请大家保持耐心。
紫薇星上的Java——JavaOO（7）
紫郡的博客
02-08 281
这部分我们来整理一些进阶的知识点，作为JavaOO的最后一个部分，后面的知识点将会单独的，详细的整理！
紫薇星上的Java——JavaOO（6）
紫郡的博客
02-07 264
这一部分我们将整理Java中日期与时间，I/O流，异常处理的知识点，回归正题，大噶加油！
紫薇星上的Java——JavaOO（4）
紫郡的博客
02-06 276
这一部分我们来整理一些实用的类与方法，大噶冲冲冲！
紫薇星上的Java——JavaOO（3）
紫郡的博客
02-05 266
今天我们就来正式进入JavaOO的世界，来，先给自己new个对象~
紫薇星上的Java——JavaOO（2）
紫郡的博客
02-04 194
这一部分我们来整理修饰符、运算符与逻辑控制的知识点，这些知识点都是为面向对象做好基础，大噶加油！
紫薇星上的Java——数据结构
紫郡的博客
02-09 179
又见面了大家！之前我出过C语言系列和JavaOO系列，不过JavaOO系列写到面向对象基本操作知识点后就停了，因为后面的知识点比较复杂，再这样大段大段地写不够详细，也比较不负责任，所以这些知识点以后将会慢慢以单独一篇文章的形式写出来，整理起来比较详细，查找起来也比较方便。大噶加油！！！
紫薇星上的Java——映射转换
紫郡的博客
02-11 340
在之前我们有讲过一节引用传递，当我们了解引用传递后就可以在实际开发中运用到它，那今天我们就来实践一下叭！
2020——收藏资料西安紫薇·永和坊下半年营销提案.ppt
11-17
2020——收藏资料西安紫薇·永和坊下半年营销提案.ppt
清风徐来——三款新型CPU风扇介绍.pdf
09-24
综上所述，这三款CPU风扇各有特色，泰腾紫薇星六号以其锻造技术和风警器提供了高效的散热和安全保障；大轴径低转速风扇则以优秀的噪音控制和散热性能，兼顾了性能与安静；而九州风神AE 085+在细节上做得尤为出色，...
紫薇排盘算法java对应版
06-06
而紫薇排盘算法java对应版则是一个基于java语言编写的算法实现，可以方便地在计算机上运行。 该算法实现包括了八字生克旺衰、紫薇星斗、天干地支等命理概念。通过输入出生时间，计算出对应的八字，再根据紫薇星斗图...
1基于STM32的智能气象站项目.docx
最新发布
10-30
1基于STM32的智能气象站项目
技术资料分享SH-HC-05蓝牙模块技术手册很好的技术资料.zip
10-30
技术资料分享SH-HC-05蓝牙模块技术手册很好的技术资料.zip
【路径规划】改进的人工势场算法机器人避障路径规划【含Matlab源码 1151期】.zip
10-30
【路径规划】改进的人工势场算法机器人避障路径规划【含Matlab源码 1151期】.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值