资讯专栏INFORMATION COLUMN

Java String 源码浅析

2shou / 492人阅读

摘要:如果对象长度不相等,则为假。从后往前,判断类中数组的单个字符是否相等,有不相等则为假。由此可以看出,如果对两个超长的字符串进行比较还是非常费时间的。字符串数值化比较将字符串数值化。

引言

从一段代码说起:

</>复制代码

  1. public void stringTest(){
  2. String a = "a"+"b"+1;
  3. String b = "ab1";
  4. System.out.println(a == b);
  5. }

大家猜一猜结果如何?如果你的结论是true。好吧,再来一段代码:

</>复制代码

  1. public void stringTest(){
  2. String a = new String("ab1");
  3. String b = "ab1";
  4. System.out.println(a == b);
  5. }

结果如何呢?正确答案是false

让我们看看经过编译器编译后的代码如何

</>复制代码

  1. //第一段代码
  2. public void stringTest() {
  3. String a = "ab1";
  4. String b = "ab1";
  5. System.out.println(a == b);
  6. }
  7. //第二段代码
  8. public void stringTest() {
  9. String a1 = new String("ab1");
  10. String b = "ab1";
  11. System.out.println(a1 == b);
  12. }

也就是说第一段代码经过了编译期优化,原因是编译器发现"a"+"b"+1和"ab1"的效果是一样的,都是不可变量组成。但是为什么他们的内存地址会相同呢?如果你对此还有兴趣,那就一起看看String类的一些源码吧。

一 String类

String类被final所修饰,也就是说String对象是不可变量,并发程序最喜欢不可变量了。String类实现了Serializable, Comparable, CharSequence接口。

Comparable接口有compareTo(String s)方法,CharSequence接口有length(),charAt(int index),subSequence(int start,int end)方法。

二 String属性

String类中包含一个不可变的char数组用来存放字符串,一个int型的变量hash用来存放计算后的哈希值。

</>复制代码

  1. /** The value is used for character storage. */
  2. private final char value[];
  3. /** Cache the hash code for the string */
  4. private int hash; // Default to 0
  5. /** use serialVersionUID from JDK 1.0.2 for interoperability */
  6. private static final long serialVersionUID = -6849794470754667710L;
三 String构造函数

</>复制代码

  1. //不含参数的构造函数,一般没什么用,因为value是不可变量
  2. public String() {
  3. this.value = new char[0];
  4. }
  5. //参数为String类型
  6. public String(String original) {
  7. this.value = original.value;
  8. this.hash = original.hash;
  9. }
  10. //参数为char数组,使用java.utils包中的Arrays类复制
  11. public String(char value[]) {
  12. this.value = Arrays.copyOf(value, value.length);
  13. }
  14. //从bytes数组中的offset位置开始,将长度为length的字节,以charsetName格式编码,拷贝到value
  15. public String(byte bytes[], int offset, int length, String charsetName)
  16. throws UnsupportedEncodingException {
  17. if (charsetName == null)
  18. throw new NullPointerException("charsetName");
  19. checkBounds(bytes, offset, length);
  20. this.value = StringCoding.decode(charsetName, bytes, offset, length);
  21. }
  22. //调用public String(byte bytes[], int offset, int length, String charsetName)构造函数
  23. public String(byte bytes[], String charsetName)
  24. throws UnsupportedEncodingException {
  25. this(bytes, 0, bytes.length, charsetName);
  26. }
三 String常用方法 boolean equals(Object anObject)

</>复制代码

  1. public boolean equals(Object anObject) {
  2. //如果引用的是同一个对象,返回真
  3. if (this == anObject) {
  4. return true;
  5. }
  6. //如果不是String类型的数据,返回假
  7. if (anObject instanceof String) {
  8. String anotherString = (String) anObject;
  9. int n = value.length;
  10. //如果char数组长度不相等,返回假
  11. if (n == anotherString.value.length) {
  12. char v1[] = value;
  13. char v2[] = anotherString.value;
  14. int i = 0;
  15. //从后往前单个字符判断,如果有不相等,返回假
  16. while (n-- != 0) {
  17. if (v1[i] != v2[i])
  18. return false;
  19. i++;
  20. }
  21. //每个字符都相等,返回真
  22. return true;
  23. }
  24. }
  25. return false;
  26. }

equals方法经常用得到,它用来判断两个对象从实际意义上是否相等,String对象判断流程:

</>复制代码

  1. 内存地址相同,则为真。
    如果对象类型不是String类型,则为假。否则继续判断。

如果对象长度不相等,则为假。否则继续判断。
从后往前,判断String类中char数组value的单个字符是否相等,有不相等则为假。如果一直相等直到第一个数,则返回真。

</>复制代码

  1. 由此可以看出,如果对两个超长的字符串进行比较还是非常费时间的。
int compareTo(String anotherString)

</>复制代码

  1. public int compareTo(String anotherString) {
  2. //自身对象字符串长度len1
  3. int len1 = value.length;
  4. //被比较对象字符串长度len2
  5. int len2 = anotherString.value.length;
  6. //取两个字符串长度的最小值lim
  7. int lim = Math.min(len1, len2);
  8. char v1[] = value;
  9. char v2[] = anotherString.value;
  10. int k = 0;
  11. //从value的第一个字符开始到最小长度lim处为止,如果字符不相等,返回自身(对象不相等处字符-被比较对象不相等字符)
  12. while (k < lim) {
  13. char c1 = v1[k];
  14. char c2 = v2[k];
  15. if (c1 != c2) {
  16. return c1 - c2;
  17. }
  18. k++;
  19. }
  20. //如果前面都相等,则返回(自身长度-被比较对象长度)
  21. return len1 - len2;
  22. }

这个方法写的很巧妙,先从0开始判断字符大小。如果两个对象能比较字符的地方比较完了还相等,就直接返回自身长度减被比较对象长度,如果两个字符串长度相等,则返回的是0,巧妙地判断了三种情况。

int hashCode()

</>复制代码

  1. public int hashCode() {
  2. int h = hash;
  3. //如果hash没有被计算过,并且字符串不为空,则进行hashCode计算
  4. if (h == 0 && value.length > 0) {
  5. char val[] = value;
  6. //计算过程
  7. //s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
  8. for (int i = 0; i < value.length; i++) {
  9. h = 31 * h + val[i];
  10. }
  11. //hash赋值
  12. hash = h;
  13. }
  14. return h;
  15. }

String类重写了hashCode方法,Object中的hashCode方法是一个Native调用。String类的hash采用多项式计算得来,我们完全可以通过不相同的字符串得出同样的hash,所以两个String对象的hashCode相同,并不代表两个String是一样的。

boolean startsWith(String prefix,int toffset)

</>复制代码

  1. public boolean startsWith(String prefix, int toffset) {
  2. char ta[] = value;
  3. int to = toffset;
  4. char pa[] = prefix.value;
  5. int po = 0;
  6. int pc = prefix.value.length;
  7. // Note: toffset might be near -1>>>1.
  8. //如果起始地址小于0或者(起始地址+所比较对象长度)大于自身对象长度,返回假
  9. if ((toffset < 0) || (toffset > value.length - pc)) {
  10. return false;
  11. }
  12. //从所比较对象的末尾开始比较
  13. while (--pc >= 0) {
  14. if (ta[to++] != pa[po++]) {
  15. return false;
  16. }
  17. }
  18. return true;
  19. }
  20. public boolean startsWith(String prefix) {
  21. return startsWith(prefix, 0);
  22. }
  23. public boolean endsWith(String suffix) {
  24. return startsWith(suffix, value.length - suffix.value.length);
  25. }

起始比较和末尾比较都是比较经常用得到的方法,例如在判断一个字符串是不是http协议的,或者初步判断一个文件是不是mp3文件,都可以采用这个方法进行比较。

String concat(String str)

</>复制代码

  1. public String concat(String str) {
  2. int otherLen = str.length();
  3. //如果被添加的字符串为空,返回对象本身
  4. if (otherLen == 0) {
  5. return this;
  6. }
  7. int len = value.length;
  8. char buf[] = Arrays.copyOf(value, len + otherLen);
  9. str.getChars(buf, len);
  10. return new String(buf, true);
  11. }

concat方法也是经常用的方法之一,它先判断被添加字符串是否为空来决定要不要创建新的对象。

String replace(char oldChar,char newChar)

</>复制代码

  1. public String replace(char oldChar, char newChar) {
  2. //新旧值先对比
  3. if (oldChar != newChar) {
  4. int len = value.length;
  5. int i = -1;
  6. char[] val = value; /* avoid getfield opcode */
  7. //找到旧值最开始出现的位置
  8. while (++i < len) {
  9. if (val[i] == oldChar) {
  10. break;
  11. }
  12. }
  13. //从那个位置开始,直到末尾,用新值代替出现的旧值
  14. if (i < len) {
  15. char buf[] = new char[len];
  16. for (int j = 0; j < i; j++) {
  17. buf[j] = val[j];
  18. }
  19. while (i < len) {
  20. char c = val[i];
  21. buf[i] = (c == oldChar) ? newChar : c;
  22. i++;
  23. }
  24. return new String(buf, true);
  25. }
  26. }
  27. return this;
  28. }

这个方法也有讨巧的地方,例如最开始先找出旧值出现的位置,这样节省了一部分对比的时间。replace(String oldStr,String newStr)方法通过正则表达式来判断。

String trim()

</>复制代码

  1. public String trim() {
  2. int len = value.length;
  3. int st = 0;
  4. char[] val = value; /* avoid getfield opcode */
  5. //找到字符串前段没有空格的位置
  6. while ((st < len) && (val[st] <= " ")) {
  7. st++;
  8. }
  9. //找到字符串末尾没有空格的位置
  10. while ((st < len) && (val[len - 1] <= " ")) {
  11. len--;
  12. }
  13. //如果前后都没有出现空格,返回字符串本身
  14. return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
  15. }

trim方法用起来也6的飞起

String intern()

</>复制代码

  1. public native String intern();

intern方法是Native调用,它的作用是在方法区中的常量池里通过equals方法寻找字面值的对象,如果没有找到则在常量池中开辟一片空间存放字符串并返回该对应String的引用,否则直接返回常量池中已存在String对象的引用。

将引言中第二段代码

</>复制代码

  1. //String a = new String("ab1");
  2. //改为
  3. String a = new String("ab1").intern();

则结果为为true,原因在于a所指向的地址来自于常量池,而b所指向的字符串常量默认会调用这个方法,所以a和b都指向了同一个地址空间。

int hash32()

</>复制代码

  1. private transient int hash32 = 0;
  2. int hash32() {
  3. int h = hash32;
  4. if (0 == h) {
  5. // harmless data race on hash32 here.
  6. h = sun.misc.Hashing.murmur3_32(HASHING_SEED, value, 0, value.length);
  7. // ensure result is not zero to avoid recalcing
  8. h = (0 != h) ? h : 1;
  9. hash32 = h;
  10. }
  11. return h;
  12. }

在JDK1.7中,Hash相关集合类在String类作key的情况下,不再使用hashCode方式离散数据,而是采用hash32方法。这个方法默认使用系统当前时间,String类地址,System类地址等作为因子计算得到hash种子,通过hash种子在经过hash得到32位的int型数值。

</>复制代码

  1. public int length() {
  2. return value.length;
  3. }
  4. public String toString() {
  5. return this;
  6. }
  7. public boolean isEmpty() {
  8. return value.length == 0;
  9. }
  10. public char charAt(int index) {
  11. if ((index < 0) || (index >= value.length)) {
  12. throw new StringIndexOutOfBoundsException(index);
  13. }
  14. return value[index];
  15. }

以上是一些简单的常用方法。

总结

String对象是不可变类型,返回类型为String的String方法每次返回的都是新的String对象,除了某些方法的某些特定条件返回自身。

String对象的三种比较方式:

==内存比较:直接对比两个引用所指向的内存值,精确简洁直接明了。

equals字符串值比较:比较两个引用所指对象字面值是否相等。

hashCode字符串数值化比较:将字符串数值化。两个引用的hashCode相同,不保证内存一定相同,不保证字面值一定相同。

更多文章:http://blog.gavinzh.com

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/64410.html

相关文章

  • java移位符浅析

    摘要:左移运算符首先我们将化为源码因为其是类型,所以化为二进制有位正数的补码和反码等于源码的本身。左移运算符是将操作数的二进制码整理左移指定位数,左移后右面空出的位用来补充。补充如果操作类型低于类型,比如,等,先将其转化为类型在进行移位。 java移位符初步使用与简单理解 概述 java移位符主要包括3种: 运算符 名称 >> 左移运算符 3); } } 结果如下: ...

    blankyao 评论0 收藏0
  • JAVA HashMap源码浅析

    摘要:类的属性和构造函数二的初始化构造方法这是的构造函数之一,其他构造函数都引用这个构造函数进行初始化。在构造函数中不会对数组进行初始化,只有在等操作方法内会进行判断是否要初始化或扩容。其作用是保证的效率。 引言 HashMap在键值对存储中被经常使用,那么它到底是如何实现键值存储的呢? 一 Entry Entry是Map接口中的一个内部接口,它是实现键值对存储关键。在HashMap中,有E...

    xuxueli 评论0 收藏0
  • Grays Anatomy源码浅析

    摘要:在里面,最大的改变使运行时的成为可能。缺省情况下,将会在方法中计算这些,通过在加载这两个类进入虚拟机时,使用反射来计算。通过重写方法,更正获取的方式,改成使用指定的方式进行。 Grays Anatomy源码浅析 标签(空格分隔):JAVA JVM 问题排查 在知乎上看到一个问题,被R大推荐了这个线上排查的工具,就下来用了用,感觉还不错,知道是Java写的后,就行看看源码,相关知识比较...

    verano 评论0 收藏0
  • CAS 5.2.x 单点登录 - 实现原理及源码浅析

    摘要:上一篇文章简单介绍了在本地开发环境中搭建服务端和客户端,对单点登录过程有了一个直观的认识之后,本篇将探讨单点登录的实现原理。因此引入服务端作为用户信息鉴别和传递中介,达到单点登录的效果。为该流程的实现类。表示对返回结果的处理。 上一篇文章简单介绍了 CAS 5.2.2 在本地开发环境中搭建服务端和客户端,对单点登录过程有了一个直观的认识之后,本篇将探讨 CAS 单点登录的实现原理。 一...

    elisa.yang 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<