String源码剖析(3)--方法篇

版权声明:转载著名出处 https://blog.csdn.net/gcola007/article/details/89789933

本文基于JDK1.8

本篇文章主要是关于String类的内部方法的分析,目录如下:

  • 构造函数分析
  • “比较”方法
  • String对“+”的重载

构造函数分析

1.默认构造函数

public String() {
   this.value = "".value;
}

该构造方法会创建空的字符序列,注意这个构造方法的使用,因为创造不必要的字符串对象是不可变的。因此不建议采取下面的创建 String 对象:

String str = new String()
str = "sample";

这样的结果显而易见,会产生了不必要的对象。

2.使用字符串类型的对象来初始化

public String(String original){
  this.value = original.value;
  this.hash = original.hash;
}

这里将直接将源 String 中的 value 和 hash 两个属性直接赋值给目标 String。因为 String 一旦定义之后是不可以改变的,所以也就不用担心改变源 String 的值会影响到目标 String 的值。

3.使用字符数组来构造

public String(char value[]){
    ...
}
public String(char value[], int offset, int count){
    ...
}

这里值得注意的是:当我们使用字符数组创建 String 的时候,会用到Arrays.copyOf方法或Arrays.copyOfRange方法。这两个方法是将原有的字符数组中的内容逐一的复制到 String 中的字符数组中。会创建一个新的字符串对象,随后修改的字符数组不影响新创建的字符串。

4.使用字节数组来构建String

在 Java 中,String 实例中保存有一个 char[] 字符数组,char[] 字符数组是以 unicode 码来存储的,String 和 char 为内存形式。

byte 是网络传输或存储的序列化形式,所以在很多传输和存储的过程中需要将 byte[] 数组和 String 进行相互转化。所以 String 提供了一系列重载的构造方法来将一个字符数组转化成 String,提到 byte[] 和 String 之间的相互转换就不得不关注编码问题。

String(byte[] bytes,Charset charset);

该构造方法是指通过 charset 来解码指定的 byte 数组,将其解码成 unicode 的 char[] 数组,构造成新的 String。

这里的 bytes 字节流是使用 charset 进行编码的,想要将他转换成 unicode 的 char[] 数组,而又保证不出现乱码,那就要指定其解码方式

同样的,使用字节数组来构造 String 也有很多种形式,按照是否指定解码方式分的话可以分为两种:

public String(byte bytes[]){
  this(bytes, 0, bytes.length);
}
public String(byte bytes[], int offset, int length){
    checkBounds(bytes, offset, length);
    this.value = StringCoding.decode(bytes, offset, length);
}

如果我们在使用 byte[] 构造 String 的时候,使用的是下面这四种构造方法(带有 charsetName 或者 charset 参数)的一种的话,那么就会使用StringCoding.decode()方法进行解码,使用的解码的字符集就是我们指定的 charsetName 或者 charset。

String(byte bytes[]);
String(byte bytes[], int offset, int length);
String(byte bytes[], Charset charset);
String(byte bytes[], String charsetName);
String(byte bytes[], int offset, int length, Charset charset);
String(byte bytes[], int offset, int length, String charsetName);

我们在使用 byte[] 构造 String 的时候,如果没有指明解码使用的字符集的话,那么 StringCoding 的 decode 方法首先调用系统的默认编码格式,如果没有指定编码格式则默认使用 ISO-8859-1 编码格式进行编码操作。这里就不展示代码了,有兴趣的同学可以去源码中搜索关键字"ISO-8859-1"。

5.一个特殊的保护类型的构造方法

String 除了提供了很多公有的供程序员使用的构造方法以外,还提供了一个保护类型的构造方法(Java 7),我们看一下他是怎么样的:

String(char[] value,boolean share) {
    // assert share : "unshared not supported";
    this.value = value;
}

从代码中我们可以看出,该方法和 String(char[] value) 有两点区别:

  • 第一个区别:该方法多了一个参数:boolean share,其实这个参数在方法体中根本没被使用。注释说目前不支持 false,只使用 true。那可以断定,加入这个 share 的只是为了区分于 String(char[] value) 方法,不加这个参数就没办法定义这个函数,只有参数是不同才能进行重载。
  • 第二个区别:具体的方法实现不同。我们前面提到过 String(char[] value) 方法在创建 String 的时候会用到 Arrays 的 copyOf 方法将 value 中的内容逐一复制到 String 当中,而这个 String(char[] value, boolean share) 方法则是直接将 value 的引用赋值给 String 的 value。那么也就是说,这个方法构造出来的 String 和参数传过来的 char[] value 共享同一个数组。

为什么 Java 会提供这样一个方法呢?

  • 性能好:这个很简单,一个是直接给数组赋值(相当于直接将 String 的 value 的指针指向char[]数组),一个是逐一拷贝,当然是直接赋值快了。
  • 节约内存:该方法之所以设置为 protected,是因为一旦该方法设置为公有,在外面可以访问的话,如果构造方法没有对 arr 进行拷贝,那么其他人就可以在字符串外部修改该数组,由于它们引用的是同一个数组,因此对 arr 的修改就相当于修改了字符串,那就破坏了字符串的不可变性。
  • 安全的:对于调用他的方法来说,由于无论是原字符串还是新字符串,其 value 数组本身都是 String 对象的私有属性,从外部是无法访问的,因此对两个字符串来说都很安全。

6.Java7加入的新特性

在 Java 7 之前有很多 String 里面的方法都使用上面说的那种“性能好的、节约内存的、安全”的构造函数。 比如:substringreplaceconcatvalueOf等方法。

实际上它们使用的是 public String(char[], ture) 方法来实现。

但是在 Java 7 中,substring 已经不再使用这种“优秀”的方法了

为什么呢? 虽然这种方法有很多优点,但是他有一个致命的缺点,对于 sun 公司的程序员来说是一个零容忍的 bug,那就是他很有可能造成内存泄露。

看一个例子,假设一个方法从某个地方(文件、数据库或网络)取得了一个很长的字符串,然后对其进行解析并提取其中的一小段内容,这种情况经常发生在网页抓取或进行日志分析的时候。

下面是示例代码:

1String aLongString = "...averylongstring...";
2String aPart = aLongString.substring(20, 40);
3return aPart;

在这里 aLongString 只是临时的,真正有用的是 aPart,其长度只有 20 个字符,但是它的内部数组却是从 aLongString 那里共享的,因此虽然 aLongString 本身可以被回收,但它的内部数组却不能释放。这就导致了内存泄漏。如果一个程序中这种情况经常发生有可能会导致严重的后果,如内存溢出,或性能下降。

新的实现虽然损失了性能,而且浪费了一些存储空间,但却保证了字符串的内部数组可以和字符串对象一起被回收,从而防止发生内存泄漏,因此新的 substring 比原来的更健壮。

“比较”方法

boolean equals(Object anObject); // 比较对象
boolean contentEquals(StringBuffer sb);
boolean equals(Object anObject); // 比较对象
boolean contentEquals(StringBuffer sb); // 与字符串比较内容
boolean contentEquals(Char Sequencecs); // 与字符比较内容
boolean equalsIgnoreCase(String anotherString); // 忽略大小写比较字符串对象
int compareTo(String anotherString); // 比较字符串
int compareToIgnoreCase(String str); // 忽略大小写比较字符串
boolean regionMatches(int toffset,String other,
                     into offset,int len); // 局部匹配
boolean regionMatches(boolean ignoreCase,int toffset,匹配
                     String other,into offset,
                     int len); // 可忽略大小写局部

字符串有一系列方法用于比较两个字符串的关系。 前四个返回 boolean 的方法很容易理解,前三个比较就是比较 String 和要比较的目标对象的字符数组的内容,一样就返回 true, 不一样就返回false,核心代码如下:

int n = value.length; 
while (n-- ! = 0) {
  if (v1[i] != v2[i])
    return false;
    i++;
}

v1,v2分别代表 String 的字符数组和目标对象的字符数组。 第四个和前三个唯一的区别就是他会将两个字符数组的内容都使用 toUpperCase 方法转换成大写再进行比较,以此来忽略大小写进行比较。相同则返回 true,不想同则返回 false。

String对"+"的重载

我们知道,Java 是不支持重载运算符,String 的 “+” 是 java 中唯一的一个重载运算符,那么 java 使如何实现这个加号的呢?我们先看一段代码:

public static void main(String[] args) {
     String string = "hello";
     String string2 = string + "world";
}

然后我们将这段代码的实际执行情况贴出来看看:

public static void main(String args[]){
     String string = "hollo";
     String string2 = (new StringBuilder(String.valueOf(string))).append("world").toString();
}

看了反编译之后的代码我们发现,其实 String 对 “+” 的支持其实就是使用了 StringBuilder 以及他的 append、toString 两个方法。

小结

  • 一旦 String 对象在内存(堆)中被创建出来,就无法被修改。特别要注意的是,String 类的所有方法都没有改变字符串本身的值,都是返回了一个新的对象。
  • 如果你需要一个可修改的字符串,应该使用 StringBuffer 或者StringBuilder。否则会有大量时间浪费在垃圾回收上,因为每次试图修改都有新的String 对象被创建出来。
  • 如果你只需要创建一个字符串,你可以使用双引号的方式,如果你需要在堆中创建一个新的对象,你可以选择构造函数的方式。

以上分析的方法只是String中的一部分,其实这么多Api光靠记是记不住的,用到的时候再看,熟练了自然就记住了。


最近开始学习JDK源码,一些学习笔记都同步在了公众号上,想看更多更全的源码分析文章,欢迎关注我的公众号: Plus技术栈。

展开阅读全文

没有更多推荐了,返回首页