简介
String类是代表字符串。所有Java程序中的字符串文字，例如“abc”,都是String类的实例
Strings是不变的，创建后值就不能改变。String buffer 提供了可更改的方法。因为String对象是不变的，所以可以共享。例如：
Strng str = “abc”;
等同于
char data[] = {‘a’,’b’,’c’};
String str = new String(char);
Java为字符串连接运算符（+）和其他对象转换为字符串提供特殊支持。通过StringBuilder(或StrngBuffer)类的append方法实现字符串的连接。通过toString方法实现字符串转换，由Object定义，由Java中的所有类继承。
除了特别声明，否则传递null参数到此类的构造函数或方法将导致抛出NullPointerException异常
重载“+”
重载“+”，在这里重载指的是当对特定类使用时操作符被赋予了额外的意义。（对String使用的“+”和“+=”是Java中唯一重载过的操作符，Java不允许程序员重载其他的操作符）“+”在此允许程序员连接String，见下例：
//: strings/Concatenation.java
public class Concatenation{
public static void main(String[] args){
String mango = “mango”;
String s = “abc”+mango+”def”+47;
System.out.println(s);
}
} /* Output:
abcmangodef47
*///:~
可以这样设想String “abc”使用方法append()创建一个包含“abc”的新的String对象，这个String对象和mango的内容相连。然后新的String对象在创建另外一个String在和“def”相连，之后再按照这样进行下去。
常用方法
构造方法：
- public String()
初始化新创建的String对象，使其表示一个空的字符序列
注意：使用这个构造器（空构造器）没有意义因为Strings是不能更改的 - public String(String original)
亦即新建的string是参数string的复制 - public String(StringBuffer buffer)
分配一个新的字符串，其中包含当前包含在字符串缓冲区（string buffer）参数(argument)中的字符序列
注意： - public String(StringBuilder builder)
分配一个新的字符串，其中包含当前包含在字符串构建器（string builder）参数(argument)中的字符序列
注意：string builder的内容是复制过来的，之后对string builder的改动不会影响到新建的string
主要方法 附带源码：
1.
public int length() {
return value.length;
}
返回字符串的长度
2.
public boolean isEmpty() {
return value.length == 0;
}
只有length为0时才返回true，否则返回false
3.
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
返回指定索引(index)的字符值(character value)。索引从0到length-1。
4.
public boolean equals(Object anObject){
if (this == anObject) { //如果this等于anObject返回true
return true;
}
if (anObject instanceof String) { //如果anObject是String
String anotherString = (String)anObject; //将anObject强转为一个String实例
int n = value.length; //获取value的长度
if (n == anotherString.value.length){//如果n等于anotherString.value.length
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) { //n递减，为0时停止
if (v1[i] != v2[i]) //string的值一一比较，只要不相等就返回false
return false;
i++;
}
return true;
}
}
return false; //除了上述两种情况外，其他一律返回false
}
比较字符串和指定对象。有且只有当参数不是null且表示相同字符序列的字符串对象时才返回true
注意只有参数是String的情况下才是去比较内容，如果不是String类型，则是使用==，即比较的引用。如果想要参数为非String类型时也比较内容，则需要重写equals方法
5.
public boolean equalsIgnoreCase(String anotherString) {
return (this == anotherString) ? true
: (anotherString != null)
&& (anotherString.value.length == value.length)
&& regionMatches(true, 0, anotherString, 0, value.length);
}
比较字符串，忽略大小写
6.
public int compareTo(String anotherString){
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2); //lim是两个长度中的最小长度
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) { //一旦有字符不同，则返回c1和c2的Unicode的差值
return c1 - c2;
}
k++;
}
return len1 - len2;
}
按字典顺序比较字符串，比较是基于字符串中每个字符的Unicode。
字符串相同时返回0，小于返回负数，大于返回正数
7.
public int compareToIgnoreCase(String str) {
return CASE_INSENSITIVE_ORDER.compare(this, str);
}
compare（）忽略大小写
8.
public boolean startsWith(String prefix, int toffset) {
char ta[] = value;
int to = toffset;
char pa[] = prefix.value;
int po = 0;
int pc = prefix.value.length;
// Note: toffset might be near -1>>>1.
if ((toffset < 0) || (toffset > value.length - pc)) {
return false;
}
while (--pc >= 0) {
if (ta[to++] != pa[po++]) {
return false;
}
}
return true;
}
参数toffset: 从哪个开始
测试字符串是否以某种特定的前缀开头，返回boolean
public boolean startsWith(String prefix) {
return startsWith(prefix, 0);
}
public boolean endsWith(String suffix) {
return startsWith(suffix, value.length - suffix.value.length);
}
测试字符串是否以某种特定的后缀结尾，返回boolean
10.
public int indexOf(int ch, int fromIndex) {
final int max = value.length;
if (fromIndex < 0) {
fromIndex = 0;
} else if (fromIndex >= max) {
// Note: fromIndex might be near -1>>>1.
return -1;
}
if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
// handle most cases here (ch is a BMP code point or a
// negative value (invalid code point))
final char[] value = this.value;
for (int i = fromIndex; i < max; i++) {
if (value[i] == ch) {
return i;
}
}
return -1;
} else {
return indexOfSupplementary(ch, fromIndex);
}
}
参数：
ch: 一个字符（编码点Unicode code point）
fromIndex: 开始搜索的索引值
返回某个特定字符第一次出现时的索引值，充指定的地方开始搜索，如果不存在该字符，则返回-1
public int indexOf(int ch) {
return indexOf(ch, 0); fromIndex为0的情况
}
public int lastIndexOf(int ch, int fromIndex) {
if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
// handle most cases here (ch is a BMP code point or a
// negative value (invalid code point))
final char[] value = this.value;
int i = Math.min(fromIndex, value.length - 1);
for (; i >= 0; i--) { //从后往前找
if (value[i] == ch) {
return i;
}
}
return -1;
} else {
return lastIndexOfSupplementary(ch, fromIndex);
}
}
返回某个特定字符最后一次出现时的索引值，充指定的地方开始搜索，如果不存在该字符，则返回-1（最后一次就是从后往前找出现的第一次）
public int lastIndexOf(int ch) {
return lastIndexOf(ch, value.length - 1); fromIndex为字符串最后一个索引值的情况
}
- public int indexOf(String str, int fromIndex)
public int lastIndexOf(String str)
public int lastIndexOf(String str, int fromIndex)
public String substring(int beginIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
int subLen = value.length - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}
返回字符串的子字符串，只有开始的索引值，子字符串是新建的String
14.
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
public String replace(char oldChar, char newChar) {
if (oldChar != newChar) {
int len = value.length;
int i = -1;
char[] val = value; /* avoid getfield opcode */
while (++i < len) {
if (val[i] == oldChar) {
break;
}
} //旧字符第一次出现时的索引值 i
if (i < len) { 如果i<len
char buf[] = new char[len];
for (int j = 0; j < i; j++) {
buf[j] = val[j]; //将旧字符出现前的其他字符给到buf[]中
}
while (i < len) {
char c = val[i];
buf[i] = (c == oldChar) ? newChar : c; //在旧字符出现后的字符串中，如果有字符是旧字符则替换成新字符
i++;
}
return new String(buf, true); //返回一个创建好的新字符串，内容是buf
}
}
return this;
}
用新字符替换旧字符
16. public String[] split(String regex, int limit)
根据表达式将字符串切分为一个数组
limit 控制这一模式应用的次数，因而影响了结果数组的长度，如果limit=n，n大于0，则切分将应用n-1次，数组的长度不会大于n，数组的最后一个值将包含所有没有被切分的部分。如果n小于0，那么切分将进行任意次，数组的长度也是随机的。如果n等于0，切分将进行任意次，数组的长度也是随机的，但是剩下的空字符串将被舍弃
以字符串"boo:and:foo"为例
Regex Limit Result
: 2 { “boo”, “and:foo” }
: 5 { “boo”, “and”, “foo” }
: -2 { “boo”, “and”, “foo” }
o 5 { “b”, “”, “:and:f”, “”, “” }
o -2 { “b”, “”, “:and:f”, “”, “” }
o 0 { “b”, “”, “:and:f” }
*public String[] split(String regex) limit为0的情况
-
public static String join(CharSequence delimiter, CharSequence… elements)
用分隔符连接字符元素组成字符串
例如：
String message = String.join("-", “Java”, “is”, “cool”);
// message returned is: “Java-is-cool” -
public String toLowerCase() 变小写
public String toUpperCase() 变大写
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;
}
去掉字符串前后的空格“ ”， 注意前后可能不只一个空格
20.
public String toString() {
return this;
}
返回字符串形式
21.
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;
}
转变成字符数组
22. public byte[] getBytes()
返回obj的值用String表现
472
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
