JavaSE-String常用方法

public int length() {
    return value.length;
}
例：
String s = "I am fxyh!";
int length = s.length();//length=10

public char charAt(int index) {
    if ((index < 0) || (index >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
    return value[index];
}
例:
String s = "I am fxyh!";
char charAt = s.charAt(5);//charAt = 'f'

public String substring(int beginIndex) {...}
public String substring(int beginIndex, int endIndex) {...}
例：
String s = "I am fxyh!";
System.out.println(s.substring(2, 8));//am fxy
System.out.println(s.substring(2));//am fxyh!

比较字符串方法

1. compareTo两个字符串之间进行比较(区分大小写)

   • 源码：解释再多，不如看下源码

     public int compareTo(String anotherString) {
       int len1 = value.length;//原字符串的长度
       int len2 = anotherString.value.length;//传入字符串的长度
       int lim = Math.min(len1, len2);//两个字符串之间最短的长度
       char v1[] = value;//元字符串的char数组
       char v2[] = anotherString.value;//传入字符串的char数组
     
       int k = 0;
       while (k < lim) {//若果两个字符串中有最小长度大于0，则进入循环
           char c1 = v1[k];
           char c2 = v2[k];
           if (c1 != c2) {//如果第几位的char不同，则返回原字符的对应位的char类型的-传入的字符串对应为的差值，
           return c1 - c2;
           }
           k++;
           //如果传入的字符串和原字符串是包含关系的时候，也是返回长度差
           //就如：String str2 = "I AM FXYH!";
           //String str4 = "I AM FXYH!AAA"; 这样是返回两个字符串的长度差
       }
       return len1 - len2;
     }
     

2. compareToIgnore，不区分大小写进行字符串比较

   • 源码：

     public int compareToIgnoreCase(String str) {
       return CASE_INSENSITIVE_ORDER.compare(this, str);
     }
     //String类的常量
     public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator();
     //内部内
     private static class CaseInsensitiveComparator implements Comparator<String>, java.io.Serializable {
       // use serialVersionUID from JDK 1.2.2 for interoperability
       private static final long serialVersionUID = 8575799808933029326L;
     
       public int compare(String s1, String s2) {
           int n1 = s1.length();
           int n2 = s2.length();
           int min = Math.min(n1, n2);
           for (int i = 0; i < min; i++) {
               char c1 = s1.charAt(i);
               char c2 = s2.charAt(i);
               if (c1 != c2) {
                   c1 = Character.toUpperCase(c1);
                   c2 = Character.toUpperCase(c2);
                   if (c1 != c2) {
                       c1 = Character.toLowerCase(c1);
                       c2 = Character.toLowerCase(c2);
                       if (c1 != c2) {
                           // No overflow because of numeric promotion
                           return c1 - c2;
                       }
                   }
               }
           }
           return n1 - n2;
       }
     
       /** Replaces the de-serialized object. */
       private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
     }
     

3. equals区分大小写进行比较

   public boolean equals(Object anObject) {...}
   

4. equalsIgnoreCase不区分大小写进行比较

   public boolean equalsIgnoreCase(String anotherString) {...}
   

String s = "I".concat("am").concat("fxyh");
效果相当于String s = "I"+"am"+"fxyh";
但是效率明显没有“+”高

单个字符查找

1. public int indexOf(int ch) {
       return indexOf(ch, 0);
   }
   public int indexOf(int ch, int fromIndex) {...}
   //查找字符串里面的数字，查到返回位置，没查到返回负数,fromIndex表示从哪个位置开始找
   

2. public int indexOf(String str) {
       return indexOf(str, 0);
   }
   public int indexOf(String str, int fromIndex) {...}
   //查找字符串里的字符串，查到返回位置，没查到也是返回负数，fromIndex表示从哪个位置开始找
   

3. lastIndexOf和indexOf类似，只是从后面往前面找。

字符串大小写转换

1. toUpperCase()//将字符串转成大写，然后返回新字符串
2. toLowerCase()//将字符串转成小写，然后返回新字符串

trim() //截去字符串两端的空格，然后返回新字符串

boolean statWith(String prefix)判断字符串是不是以prefix字符串开头

boolean endWith(String suffix)判断字符串是不是以suffix字符串结尾

String[] split(String str)//将字符串以str进行拆分，分解成String[]。