java String 类的常用方法

àì夳堔傛蜴生んèń 2021-10-14 03:28 334阅读 0赞

### java String 类的常用方法 ###

*  String 类的常用方法
 *   *  boolean equals(Object anObject)
     *  equalsIgnoreCase()
     *  int indexOf(String str, int fromIndex)
     *  int lastIndexOf(int ch)
     *  valueOf()
     *  char charAt(int index)
     *  String concat(String str)
     *  isEmpty()
     *  contains()
     *  boolean startsWith(String prefix, \[int toffset\])
     *  boolean endsWith(String suffix)
     *  byte\[\] getBytes()
     *  void getChars(int srcBegin, int srcEnd, char\[\] dst, int dstBegin)
     *  char\[\] toCharArray()
     *  int length()
     *  String replace(char oldChar, char newChar)
     *  String replaceAll(String regex, String replacement)
     *  String replaceFirst(String regex, String replacement)
     *  String\[\] split(String regex)
     *  String substring(int beginIndex, \[int endIndex\])
     *  toLowerCase()
     *  toUpperCase()
     *  trim()
     *  format()
     *  join()
     *  int compareTo(Object o) or int compareTo(String anotherString)

# String 类的常用方法 #

## boolean equals(Object anObject) ##

// equals 字符串是否相同
    		System.out.println("123".equals("123"));//true

## equalsIgnoreCase() ##

// equalsIgnoreCase 忽略大小写后字符串是否相同
    		System.out.println("abc".equalsIgnoreCase("ABC"));//true

## int indexOf(String str, int fromIndex) ##

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

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

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

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

**参数**  
ch – 字符，Unicode 编码。

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

str – 要搜索的子字符串。

// indexOf 目标字符或字符串在源字符串中位置下标
    		System.out.println("0123".indexOf("2"));//2

## int lastIndexOf(int ch) ##

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

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

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

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

**参数**  
ch – 字符。

fromIndex – 开始搜索的索引位置。

str – 要搜索的子字符串。

// lastIndexOf 目标字符或字符串在源字符串中最后一次出现的位置下标
    		System.out.println("0123012".lastIndexOf("0"));//4

## valueOf() ##

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

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

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

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

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

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

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

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

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)

// valueOf 其他类型转字符串
    		System.out.println(String.valueOf(123));//123

## char charAt(int index) ##

返回指定索引处的 char 值。

// charAt 获取指定下标位置的字符
    		System.out.println("0123".charAt(0));//0

## String concat(String str) ##

// concat 追加字符串到当前字符串
    		System.out.println("123".concat("45"));//12345

## isEmpty() ##

// isEmpty 字符串长度是否为0
    		System.out.println("".isEmpty());//true

## contains() ##

// contains 是否包含目标字符串
    		System.out.println("abc".contains("b"));//true

## boolean startsWith(String prefix, \[int toffset\]) ##

prefix – 前缀。

toffset – 字符串中开始查找的位置。

// startsWith 是否以目标字符串开头
    		System.out.println("abcd".startsWith("a"));//true

## boolean endsWith(String suffix) ##

// endsWith 是否以目标字符串结束
    		System.out.println("abcd".endsWith("a"));//false

## byte\[\] getBytes() ##

// getBytes 获取字符串的字节数组
    		byte[] bt = "12345".getBytes();//{1,2,3,4,5}
    		System.out.println(bt.length);//5

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

srcBegin – 字符串中要复制的第一个字符的索引。

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

dst – 目标数组。

dstBegin – 目标数组中的起始偏移量。

// getChars 获取字符串的指定长度字符数组
    		String Str1 = new String("0123456789");
    		char[] Str2 = new char[6];//{0,0,0,0,0,0}
    
    		try { 
    			Str1.getChars(4, 10, Str2, 0);//{4,5,6,7,8,9}
    			System.out.println("字符串"+Str2 );
    		} catch( Exception ex) { 
    			System.out.println("触发异常...");
    		}

## char\[\] toCharArray() ##

// toCharArray 获取字符串的字符数组
    		char[] str3 = "12345".toCharArray();//{1,2,3,4,5}
    		System.out.println(str3.length);//5

## int length() ##

// length 字符串字符数
    		System.out.println("1234".length());//4

## String replace(char oldChar, char newChar) ##

// replace 字符串替换
    		System.out.println("1234-5678-90".replace("-","+"));//1234+5678+90

## String replaceAll(String regex, String replacement) ##

// replaceAll 带正则字符串替换
    		System.out.println("1234-5678-90".replaceAll("-","+"));//1234+5678+90

## String replaceFirst(String regex, String replacement) ##

// replaceFirst 替换第一个出现的目标字符串
    		System.out.println("1234-5678-90".replaceFirst("-","+"));//1234+5678-90

## String\[\] split(String regex) ##

// split 以某正则表达式分割字符串
    		String str = "1,2,3,4,5";
    		String[] s = str.split(",");//{"1","2","3","4","5"}
    		System.out.println(s.length);//5

## String substring(int beginIndex, \[int endIndex\]) ##

beginIndex – 起始索引（包括）, 索引从 0 开始。

endIndex – 结束索引（不包括）。

// substring 截取字符串
    		System.out.println("012345".substring(1,3));//12

## toLowerCase() ##

// toLowerCase 字符串转小写
    		System.out.println("ABCde".toLowerCase());//abcde

## toUpperCase() ##

// toUpperCase 字符串转大写
    		System.out.println("abCde".toUpperCase());//ABCDE

## trim() ##

// trim 去字符串首尾空格
    		System.out.println(" abc de ".trim());//abc de

## format() ##

str=String.format("Hi,%s", "王力");
    		System.out.println(str);
    // Hi,王力
    		str=String.format("Hi,%s:%s.%s", "王南","王力","王张");
    		System.out.println(str);
    // Hi,王南:王力.王张
    		System.out.printf("字母a的大写是：%c %n", 'A');
    // 字母a的大写是：A
    		System.out.printf("3>7的结果是：%b %n", 3>7);
    // 3>7的结果是：false
    		System.out.printf("100的一半是：%d %n", 100/2);
    // 100的一半是：50
    		System.out.printf("100的16进制数是：%x %n", 100);
    // 100的16进制数是：64
    		System.out.printf("100的8进制数是：%o %n", 100);
    // 100的8进制数是：144
    		System.out.printf("50元的书打8.5折扣是：%f 元%n", 50*0.85);
    // 50元的书打8.5折扣是：42.500000 元
    		System.out.printf("上面价格的16进制数是：%a %n", 50*0.85);
    // 上面价格的16进制数是：0x1.54p5
    		System.out.printf("上面价格的指数表示：%e %n", 50*0.85);
    // 上面价格的指数表示：4.250000e+01
    		System.out.printf("上面价格的指数和浮点数结果的长度较短的是：%g %n", 50*0.85);
    // 上面价格的指数和浮点数结果的长度较短的是：42.5000
    		System.out.printf("上面的折扣是%d%% %n", 85);
    // 上面的折扣是85%
    		System.out.printf("字母A的散列码是：%h %n", 'A');
    // 字母A的散列码是：41

## join() ##

// join 以某字符串，连接某字符串数组
    		List names=new ArrayList<String>();
    		names.add("1");
    		names.add("2");
    		names.add("3");
    		System.out.println(String.join("-", names));//1-2-3
    		String[] arrStr=new String[]{ "a","b","c"};
    		System.out.println(String.join("-", arrStr));//a-b-c

## int compareTo(Object o) or int compareTo(String anotherString) ##

o – 要比较的对象。

anotherString – 要比较的字符串。

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

如果参数字符串等于此字符串，则返回值 0；  
如果此字符串小于字符串参数，则返回一个小于 0 的值；  
如果此字符串大于字符串参数，则返回一个大于 0 的值。

String str1 = "Strings";
            String str2 = "Strings";
            String str3 = "Strings123";
     
            int result = str1.compareTo( str2 );
            System.out.println(result);//0
          
            result = str2.compareTo( str3 );
            System.out.println(result);//-3
         
            result = str3.compareTo( str1 );
            System.out.println(result);//3