String

• 字符串是常量，创建后不可更改（改变变量值时，要重新开辟，不能直接修改）

• 字符串字面值存储在字符串池中，实现共享

• String s = "hello";产生一个对象，字符串池中存储

• String s = new String("hello");产生两个对象，堆、池各存储一个(实际，堆指向池)

• 底层是字符数组实现

  private final char value[];
  

字符串常用方法

• public int length():返回字符串长度

  public int length() {
          return value.length;
      }
  

• public char charAt(int index) :根据下标获取字符

  public char charAt(int index) {
          if ((index < 0) || (index >= value.length)) {
              throw new StringIndexOutOfBoundsException(index);
          }
          return value[index];
      }
  

• public boolean contains(CharSequence s): 判断当前字符串中是否包含s

   public boolean contains(CharSequence s) {
          return indexOf(s.toString()) > -1;
      }
  

• public char[] toCharArray():将字符串转换成数组

  public char[] toCharArray() {
          // Cannot use Arrays.copyOf because of class initialization order issues
          char result[] = new char[value.length];
          System.arraycopy(value, 0, result, 0, value.length);
          return result;
      }
  

• public int indexOf(String str) ：查找首次出现的下标，不存在则返回-1

• public int indexOf(int ch):查找字符 ，同上

  final char[] value = this.value;
              for (int i = fromIndex; i < max; i++) {
                  if (value[i] == ch) {
                      return i;
                  }
              }
              return -1;
  

• public int lastIndexOf(String str):查找最后一次出现的下标索引

• public String trim():去掉字符串前后的空格

  public String trim() {
          int len = value.length;
          int st = 0;
          char[] val = value;    /* avoid getfield opcode */
  
          while ((st < len) && (val[st] <= ‘ ‘)) {
              st++;
          }
          while ((st < len) && (val[len - 1] <= ‘ ‘)) {
              len--;
          }
          return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
      }
  

• public String toUpperCase():将小写转换成大写

• public String toLowerCase();将大写转换成小写

  以上的两个方法都有对应的静态方法

• public boolean endWith(String str):是否以str结尾

• public boolean startWith(String str):是否以str开头

• public string replace(char oldChar, char newChar):旧的被替换成新的

• public String[] split(String str):根据str做拆分

  public String[] split(String regex, int limit) {
          /* fastpath if the regex is a
           (1)one-char String and this character is not one of the
              RegEx‘s meta characters ".$|()[{^?*+\\", or
           (2)two-char String and the first char is the backslash and
              the second is not the ascii digit or ascii letter.
           */
          char ch = 0;
          if (((regex.value.length == 1 &&
               ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
               (regex.length() == 2 &&
                regex.charAt(0) == ‘\\‘ &&
                (((ch = regex.charAt(1))-‘0‘)|(‘9‘-ch)) < 0 &&
                ((ch-‘a‘)|(‘z‘-ch)) < 0 &&
                ((ch-‘A‘)|(‘Z‘-ch)) < 0)) &&
              (ch < Character.MIN_HIGH_SURROGATE ||
               ch > Character.MAX_LOW_SURROGATE))
          {
              int off = 0;
              int next = 0;
              boolean limited = limit > 0;
              ArrayList<String> list = new ArrayList<>();
              while ((next = indexOf(ch, off)) != -1) {
                  if (!limited || list.size() < limit - 1) {
                      list.add(substring(off, next));
                      off = next + 1;
                  } else {    // last one
                      //assert (list.size() == limit - 1);
                      list.add(substring(off, value.length));
                      off = value.length;
                      break;
                  }
              }
              // If no match was found, return this
              if (off == 0)
                  return new String[]{this};
  
              // Add remaining segment
              if (!limited || list.size() < limit)
                  list.add(substring(off, value.length));
  
              // Construct result
              int resultSize = list.size();
              if (limit == 0) {
                  while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
                      resultSize--;
                  }
              }
              String[] result = new String[resultSize];
              return list.subList(0, resultSize).toArray(result);
          }
          return Pattern.compile(regex).split(this, limit);
      }
  

• equals

   public boolean equals(Object anObject) {
          if (this == anObject) {
              return true;
          }
          if (anObject instanceof String) {
              String anotherString = (String)anObject;
              int n = value.length;
              if (n == anotherString.value.length) {
                  char v1[] = value;
                  char v2[] = anotherString.value;
                  int i = 0;
                  while (n-- != 0) {
                      if (v1[i] != v2[i])
                          return false;
                      i++;
                  }
                  return true;
              }
          }
          return false;
      }
  
  

• 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 v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

String

原文：https://www.cnblogs.com/zxy-GO/p/13939756.html