1、String类
String类 不可被继承，是不可改变的，被final修饰。一旦创建了String对象，那它的值就无法改变了。
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
private final char value[]; //该值用于字符存储
private int hash; //缓存字符串的哈希码。默认是0
private static final long serialVersionUID = -6849794470754667710L;
private static final ObjectStreamField[] serialPersistentFields =
new ObjectStreamField[0];
//构造器
public String() {
this.value = "".value;
}
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}
}
可以看出String类的定义基本符合不可变类的特点，只有"hash"存在疑问。
/**
* Returns a hash code for this string. The hash code for a
* {@code String} object is computed as
* <blockquote><pre>
* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
* </pre></blockquote>
* using {@code int} arithmetic, where {@code s[i]} is the
* <i>i</i>th character of the string, {@code n} is the length of
* the string, and {@code ^} indicates exponentiation.
* (The hash value of the empty string is zero.)
*
* @return a hash code value for this object.
*/
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
hash变量用于缓存字符串的哈希吗。而hashCode()方法用于得到字符串对象的哈希吗。由上面的源码可以看出，hash虽然不是final,但是它是通过计算final属性value得来的，并且能保证每次调用它的值都是一致的。所以String是不可变的。
2、Sting类内存是怎么存储的
先上一段代码
package JavaBase;
public class StringTest {
public static void main(String[] args) {
String str = "Hello,World!";
String str2 = "Hello,World!";
String str3 = new String("Hello,World!");
String str4 = new String("Hello,World!");
System.out.println(str == str2); //true
System.out.println(str.equals(str2)); //true
System.out.println(str == str3); //false
System.out.println(str.equals(str3)); //true
System.out.println(str4 == str3); //false
System.out.println(str4.equals(str3)); //true
}
}
内存过程大致如下
1）运行先编译，然后当前类StringTest .class文件加载进入内存的方法区
2）main方法压入栈内存
3）常量池创建一个"Hello,World!“对象，产生一个内存地址。
4）然后吧"Hello,World!“内存地址复制给main方法成员变量str1,这个时候str1根据内存地址，指向了常量池的"Hello,World!”。
5）运行到String str2 = “Hello,World!”;，由于常量池存在"Hello,World!”，所以不会在创建，直接把"Hello,World!"内存地址赋值给了str2。
6）接下来new会在堆内存区域创建"Hello,World!“对象，把内存地址复制给str3,指向堆的"Hello,World!”。
7）再次new的时候，也会再次创建一个"Hello,World!“对象，把内存地址复制给str4,指向堆的"Hello,World!”。
8）此时堆中存在两个对象。分别有着自己的内存地址，自己的内存区域。
java中的equals比较对象的值，==比较对象的内存地址（可参考链接)。 输出显而易见。
假如 String str4 = “Hello,” + “World!”;内存分配，与str1比较的结果又是怎样的呢？
字符串是一个特殊的包装类，其引用是存放在栈里的，而对象内容必须根据创建方式不同定（常量池和堆），有的是编译期就已经创建好，存在字符串常量池中，而有的是运行时候才被创建，使用new关键字，存放在堆中。
可参考： java+内存分配及变量存储位置的区别
java内存分配和String类型的深度解析
可是有一个疑惑
public class StringTest {
public static void main(String[] args) {
String str = "Hello,World!";
String s1 = "Hello,";
String s2 = "World!";
String s = "Hello," + "World!";
String str2 = s1 + s2;
System.out.println(str2 == str);
System.out.println(s == str);
System.out.println(str2 == s);
System.out.println(s1 == "Hello,");
}
}
运行结果：
false
true
false
true
关于 s 与 str2 内存分配的情况又是怎样的呢？
3、字符串判断是否是回文串？
public static boolean isPalindrome(String str) {
if(str == null) {
return false;
}
StringBuilder strBuilder = new StringBuilder(str);
strBuilder.reverse();
return strBuilder.toString().equals(str);
}
public static boolean _isPalindrome(String str) {
if(str == null) {
return false;
}
int length = str.length();
for (int i = 0; i < length/2; i++) {
if(str.charAt(i) != str.charAt(length - i - 1)) {
return false;
}
}
return true;
}
4、如何比较两个字符串？
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;
}
public boolean equalsIgnoreCase(String anotherString) {
return (this == anotherString) ? true
: (anotherString != null)
&& (anotherString.value.length == value.length)
&& regionMatches(true, 0, anotherString, 0, value.length);
}
public boolean regionMatches(boolean ignoreCase, int toffset,
String other, int ooffset, int len) {
char ta[] = value;
int to = toffset;
char pa[] = other.value;
int po = ooffset;
// Note: toffset, ooffset, or len might be near -1>>>1.
if ((ooffset < 0) || (toffset < 0)
|| (toffset > (long)value.length - len)
|| (ooffset > (long)other.value.length - len)) {
return false;
}
while (len-- > 0) {
char c1 = ta[to++];
char c2 = pa[po++];
if (c1 == c2) {
continue;
}
if (ignoreCase) {
// If characters don't match but case may be ignored,
// try converting both characters to uppercase.
// If the results match, then the comparison scan should
// continue.
char u1 = Character.toUpperCase(c1);
char u2 = Character.toUpperCase(c2);
if (u1 == u2) {
continue;
}
// Unfortunately, conversion to uppercase does not work properly
// for the Georgian alphabet, which has strange rules about case
// conversion. So we need to make one last check before
// exiting.
if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
continue;
}
}
return false;
}
return true;
}
-
compareTo(String anotherString)
与传入的anotherString字符串进行比较，如果小于传入的字符串返回负数，如果大于则返回正数。当两个字符串值相等时，返回0.此时eqauls方法会返回true。 -
equalsIgnoreCase(String str)
该方法与compareTo方法类似，区别只是内部利用了Character.toUpperCase等方法进行了大小写转换后进行比较。
5、将String转为char，将char转为String?
- 将String转为char：
使用String.charAt(int index)（返回值为char）可以得到String中某一指定位置的char。
使用String.toCharArray()（返回值为char[]）可以包含整个String的char数组。 - char转为String
String s = String.valueOf(‘c’)；最高效
String s = String.valueOf(new Char[]{‘c’});将一个char数组转为String
String s = Character.toString(‘c’)
String s = new Character(‘c’).toString();
String s = “” + ‘c’; 这个方法很简单，但是效率最低。Java中String Object的值实际上是不可变的，是一个final变量，所以每次对String做出任何改变，都是初始化了一个全新的String Object并将原来的变量指向了这个新的String。而java对使用+运算符处理String相加进行了方法重载。字符串直接相加连接实际上调用了 new StringBuilder().append("").append(‘c’).toString();
6、浅谈一下String, StringBuffer，StringBuilder的区别
String 是不可变类，每当我们对String进行操作的时候，总会是会创建新的字符串。操作String很消耗资源，所以Java提供了两个工具类来操作String，StringBuffer，StringBuilder。
StringBuffer 是线程安全的，而StringBuilder是线程不安全的。
- StringBuffer
public final class StringBuffer extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{
public synchronized StringBuffer append(StringBuffer sb) {
toStringCache = null;
super.append(sb);
return this;
}
@Override
public synchronized int lastIndexOf(String str, int fromIndex) {
return super.lastIndexOf(str, fromIndex);
}
@Override
public synchronized String toString() {
if (toStringCache == null) {
toStringCache = Arrays.copyOfRange(value, 0, count);
}
return new String(toStringCache, true);
}
由源码可以看出，一些操作字符串的接口都被synchronize修饰，所以效率比较低，线程安全。
- StringBuilder：
public final class StringBuilder
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{
@Override
public StringBuilder append(Object obj) {
return append(String.valueOf(obj));
}
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
@Override
public String toString() {
// Create a copy, don't share the array
return new String(value, 0, count);
}
可见StringBuilder是线程不安全的，效率相对于StringBuffer也比较高。
7、String的intern()方法
返回：
字符串对象的规范化表示形式；
一个字符串，内容与此字符串相同，但它保证来自字符串池中。
public static void main(String[] args) {
String str = "Hello,World!";
String s1 = "Hello,";
String s2 = "World!";
String str2 = s1 + s2;
String str3 = new String("Hello,World!");
System.out.println(str2.intern());
System.out.println(str3.intern());
System.out.println(str2.intern() == str);
System.out.println(str2 == str);
System.out.println(str3.intern() == str);
System.out.println(str3 == str);
}
运行结果：
Hello,World!
Hello,World!
true
false
true
false
尽管在输出中调用intern()并没有什么效果，但是实际上后台这个方法会做一系列的动作和操作。在调用这个方法时，会先检查字符池（常量池）中是否有这个字符串，如果有则返回这个字符串的引用，否则就将这个字符串添加到字符串池中，然后返回这个字符串的引用。
它遵循对于任何两个字符串str1和str2，当且仅当str1.equals(str2)为true时，str1.intern() == str2.intern()才为true。所有字面值字符串和字符串赋值常量表达式都是内部的。
8、String是线程安全的吗？
String是不可变类，一旦创建了String类，我们就无法改变它的值，因此，它是线程安全的，可在多线程的环境下使用。
9、String的HashCode()计算方式
String重写了父类Object的hashCode()方法。Object的该方法被native修饰（ public native int hashCode()），被native的方法一般属于原生函数，是用c/c++实现的，然后生成一个dll文件供java调用。
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}