String会出现在哪些地方

  • 方法内的局部string
  • 类内的字段String
  • static string
  • 容器中存储的string
  • String数组
    那么String的位置会影响其存储方式吗?
    显然是不会的,类永远只会储存在堆上。
    但是实际上类的字段并不是一直在堆上的。

String的构造方法

以下来自String类 源码,一些无关紧要的实现被我省略了:

 private final char value[];
    private int hash; // Default to 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;//底层char[]指向了同一位置!
        this.hash = original.hash;
    }
    public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);//底层char[]指向不同位置!下面的截取也是如此
    }
    public String(char value[], int offset, int count) { ... }

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

    public String(byte ascii[], int hibyte, int offset, int count) {...}

    public String(byte ascii[], int hibyte) {...}

我们可以发现String的构造器并不关注是否将char[]指向同一位置,之所以有一些没有指向同一位置完全是为了保证char[]是immutable的。
这并不能说明调用构造器构造的String的内存位置有什么特别之处。

String另一种构造方式--为包装类型提供的专有构造方式

运行如下代码:

class StringPointerTest{
    String g="gh",h="gh";
}
public class StringTest {
    public static void main(String[] args) {
        String a="abc";
        String b="abc";
        System.out.println(a==b);//true使用简写的构造能够复用创建的string类
        String c=new String("abc");
        System.out.println(a==c);//false是用构造器则不能
        String d=new String("def");
        String e="def";
        System.out.println(d==e);//false即使先构造器再使用简化构造也不行。
        StringPointerTest spt=new StringPointerTest();
        System.out.println(spt.g==spt.h); //true与String的属于方法局部变量还是类字段也无关
    }
}
class IntegerPointTest1{
    Integer a=1;

}
class IntegerPointTest2{
    Integer b=1;
}
public class IntegerTest {
    public static void main(String[] args) {
       System.out.println(new IntegerPointTest1().a==new IntegerPointTest2().b);//true!
    }
}

原理

需要存储的代码元素有:

  • Class类文件
  • 方法,类的所以实例应该共用一段方法
  • static字段
  • 字符串常量
  • 值常量
  • 类实例
  • 各种引用
  • 基本变量
    他们各自有各自的存储位置,方法内的引用存在方法栈,类内的引用存在堆,类存储在堆上,方法中的局部基本变量存于栈但是类字段的基本变量存在堆上(方法区内)。
    值得一提的是方法区(又叫静态区),其存储值常量、字符串常量、方法、静态字段、.class文件,等只用一个备份的数据。
    栈和方法区都有共享数据的功能。
    因此使用简化方法构造String类的时候,在方法内和类内会将字符串存于栈/方法区,这无关紧要,重要的是,
    使用这种构造方法,如果没有所构造的字符串常量存在于内存中,那么会在栈/方法区中存上一份,然后再堆中新建一个String类,把String类的char[]引用指向在栈/方法区中的字符串常量;
    如果所构造的字符串常量已经存在于内存中,那么则会检索关联与之对应的堆中String实例,并直接使用这个String类实例。
    只有使用简化方法构造才能被栈/方法区记录下来,如果使用new则不行,这也是为什么上例即使先new,再使用简化构造相同字符串也不会引用相同。
    因为new出来的String实例的字符串常量存储在堆上,和栈/方法区无关。

拓展到所有包装类型---可以吗?

完全不可以。
他们都没有像String那样实现缓存。
但是实现了类似的缓存,它们的自动包装机制也提供缓存功能,
但是是基于valueof方法的,该方法会对一定范围内进行缓存。
而且实现方式非常暴力,是在对应类里存一个静态的类数组,并静态初始化全部填充。

可以缓存的范围:
byte Byte -128–127
short Short -128–127
int Integer -128—127
long Long -128—127
char Character 0–127
boolean Boolean TURE,FALSE
String
不缓存的:
float Float
double Double

可见不是所有的自动包装机制都实现了全缓存。

Logo

权威|前沿|技术|干货|国内首个API全生命周期开发者社区

更多推荐