Java 常量池详解之字符串常量池实现代码

目录
  • 1.字符串常量池(String Constant Pool)
    • 1.1:字符串常量池在Java内存区域的哪个位置?
    • 1.2:字符串常量池是什么?
    • 1.3 字符串常量池生成的时机?
    • 如何将String对象放入到常量池
    • String 对象代码案例解析
    • new string(“abc”)创建了几个对象
    • 解析public native String intern() 方法
    • Integer 对象代码案例解析
    • 为啥Integer i1 =10 跟Integer.valueOf(10) 是相等的?
    • 为啥Integer i1 =128 跟Integer.valueOf(128) 是不相等的?

在Java的内存分配中,总共3种常量池:

Java 常量池详解(二)class文件常量池 和 Java 常量池详解(三)class运行时常量池

1.字符串常量池(String Constant Pool)

在JDK1.7之前运行时常量池逻辑包含字符串常量池存放在方法区, 此时hotspot虚拟机对方法区的实现为永久代
在JDK1.7 字符串常量池被从方法区拿到了堆中, 这里没有提到运行时常量池,也就是说字符串常量池被单独拿到堆,运行时常量池剩下的东西还在方法区, 也就是hotspot中的永久代
在JDK1.8 hotspot移除了永久代用元空间(Metaspace)取而代之, 这时候字符串常量池还在堆, 运行时常量池还在方法区, 只不过方法区的实现从永久代变成了元空间(Metaspace)

1.1:字符串常量池在Java内存区域的哪个位置?

  • 在JDK6.0及之前版本,字符串常量池是放在Perm Gen区(也就是方法区)中;
  • 在JDK7.0版本,字符串常量池被移到了堆中了。至于为什么移到堆内,大概是由于方法区的内存空间太小了。
  • (堆内是可以进行回收的,然后方法区也是能回收的,但是本身区域内存比较少,如果用的字符串常量太多了,也会抛java.lang.OutOfMemoryError:PermGenspace 异常)

1.2:字符串常量池是什么?

  • 在HotSpot VM里实现的string pool功能的是一个StringTable类,它是一个Hash表,默认值大小长度是1009;这个StringTable在每个HotSpot VM的实例只有一份,被所有的类共享。字符串常量由一个一个字符组成,放在了StringTable上。
  • 在JDK6.0中,StringTable的长度是固定的,长度就是1009,因此如果放入String Pool中的String非常多,就会造成hash冲突,导致链表过长,当调用String#intern()时会需要到链表上一个一个找,从而导致性能大幅度下降;
  • 在JDK7.0中,StringTable的长度可以通过参数指定:
-XX:StringTableSize=66666`

1.3 字符串常量池生成的时机?

String a = "a";

全局字符串池里的内容是在类加载完成,经过验证,准备阶段之后在堆中生成字符串对象实例,然后将该字符串对象实例的引用值存到string pool中(记住:string pool中存的是引用值而不是具体的实例对象,具体的实例对象是在堆中开辟的一块空间存放的)

如何将String对象放入到常量池

  • “abc” 双引号String 对象会自动放入常量池
  • 调用String的intern 方法也会将对象放入到常量池中

String 对象代码案例解析

public static void main(String[] args) {
    String a = "a";
    String b = "b";
    String c = "a" + "b";
    //生成两个对象 一个"ab" ,一个新的String 对象value 值是ab
    //public String(String original) {
    //   this.value = original.value;
    //   this.hash = original.hash;
    //}
    String d = new String("ab"); 

    String e = a + "b";
    String f = a + b;
    String g = "ab";

   System.out.println(e == c);
   System.out.println(c == d);
   System.out.println(f == c);
   System.out.println(g == c);

   String e1 = e.intern();
   String c2 = c.intern();
   System.out.println(e1 == c2);
   System.out.println(e1 == c);
}

//运行结果
false
false
false
true
true
true

String c =“a” + “b” 和String c = “a” + b (String b= “b”)的区别

String b = "b";
String c = "a" + "b"; 等价于 String c ="ab"
String c1 = "a" + b; 

// java 反编译的结果
 0 ldc #3 <b> //load constant  加载常量 "b"
 2 astore_1   // 存入变量1中
 3 ldc #4 <ab> //自动识别了
 5 astore_2
 6 new #7 <java/lang/StringBuilder>
 9 dup
10 invokespecial #8 <java/lang/StringBuilder.<init>>
13 ldc #2 <a>
15 invokevirtual #9 <java/lang/StringBuilder.append>
18 aload_1
19 invokevirtual #9 <java/lang/StringBuilder.append>
22 invokevirtual #10 <java/lang/StringBuilder.toString>
25 astore_3
26 return

(1) “a”+“b” 编译器自动识别了变成了 “ab” => 3 ldc #4
(2) “a” + b(变量)

  • 先new 了StringBuilder 对象,并初始化init
  • 然后bulider.append(“a”)
  • 从变量1(b)中取出值"b"
  • 然后执行了bulider.append(“b”)
  • 最后执行了builder.toString() 方法 给变量3( c1)进行赋值

new string(“abc”)创建了几个对象

答案:是两个 ,new string(xxxx)方法,xxxx传入的是String对象。说明xxxx也是String对象。

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

String 是一个final 类型对象是不会变化的,如果发生变化,说明其实是新的对象。

public final class String

解析public native String intern() 方法

如果常量池中存在当前字符串, 就会直接返回当前字符串. 如果常量池中没有此字符串, 会将此字符串放入常量池中后, 再返回

native实现代码:

\openjdk7\jdk\src\share\native\java\lang\String.c



Java_java_lang_String_intern(JNIEnv *env, jobject this)
{
    return JVM_InternString(env, this);
}

\openjdk7\hotspot\src\share\vm\prims\jvm.h

JNIEXPORT jstring JNICALL
JVM_InternString(JNIEnv *env, jstring str);

\openjdk7\hotspot\src\share\vm\prims\jvm.cpp

JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
  JVMWrapper("JVM_InternString");
  JvmtiVMObjectAllocEventCollector oam;
  if (str == NULL) return NULL;
  oop string = JNIHandles::resolve_non_null(str);
  //调用StringTable::intern 方法
  oop result = StringTable::intern(string, CHECK_NULL);
  return (jstring) JNIHandles::make_local(env, result);
JVM_END

\openjdk7\hotspot\src\share\vm\classfile\symbolTable.cpp

oop StringTable::intern(Handle string_or_null, jchar* name, int len, TRAPS) {
  //根据名字找到对应hash下标
  unsigned int hashValue = java_lang_String::hash_string(name, len);
  int index = the_table()->hash_to_index(hashValue);
  //顺着对应的链表查找对应的值
    oop string = the_table()->lookup(index, name, len, hashValue);
  // Found
  if (string != NULL) return string;
  // Otherwise, add to symbol to table
  return the_table()->basic_add(index, string_or_null, name, len,
                                hashValue, CHECK_NULL);
}

\openjdk7\hotspot\src\share\vm\classfile\symbolTable.cpp

oop StringTable::lookup(int index, jchar* name, int len, unsigned int hash) {
  for (HashtableEntry<oop>* l = bucket(index); l != NULL; l = l->next()) {
    if (l->hash() == hash) {
      if (java_lang_String::equals(l->literal(), name, len)) {
        return l->literal();
      }
    }
  }
  return NULL;
}

1.它的大体实现结构就是:JAVA 使用 jni 调用c++实现的StringTable的intern方法。

2.要注意的是,String的String Pool是一个固定大小的Hashtable,默认值大小长度是1009,如果放进String Pool的String非常多,就会造成Hash冲突严重,从而导致链表会很长,而链表长了后直接会造成的影响就是当调用String.intern时性能会大幅下降。

Interger 包装类的池化技术



public final class Integer extends Number implements Comparable<Integer> {

    @Native public static final int   MIN_VALUE = 0x80000000;

    @Native public static final int   MAX_VALUE = 0x7fffffff;

    //缓存-128到127的值在IntegerCache里面,可以进行共享
    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

    public static Integer valueOf(int i) {
        //是不是在-128到127里面,不是的话就生成新的Integer
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
}

Integer 对象代码案例解析

public void test(){
    Integer i1 = 10;
    Integer i2 = 10;
    Integer i3 = new Integer(10);//新对象
    Integer i4 = new Integer(10);//新对象
    Integer i5 = Integer.valueOf(10);//从缓存池里面获取。
    Integer i6 = Integer.valueOf(128);
    Integer i7 = 128;

    System.out.println(i1 == i2); // true
    System.out.println(i2 == i3); // false
    System.out.println(i3 == i4); // false
    System.out.println(i1 == i5); // true
    System.out.println(i6 == i7); // false
}

//运行结果:
true
false
false
true
false

为啥Integer i1 =10 跟Integer.valueOf(10) 是相等的?

因为Integer i1 = 10 底层原理是 Integer i1 = Integer.valueof(10)

  //Integer i1 =10 反编译的结果
  0 bipush 10
  2 invokestatic #14 <java/lang/Integer.valueOf> //调用了Integer.valueof方法
  5 astore_1

为啥Integer i1 =128 跟Integer.valueOf(128) 是不相等的?

因为超过-128~127 这个范围,就不在缓存池里面,不能共享都是新new 出来的

public static Integer valueOf(int i) {
        //是不是在-128到127里面,不是的话就生成新的Integer
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

问题:包装类对象池是不是 JVM 常量池的一种?

  • 包装类的对象池是池化技术的应用,并非是虚拟机层面的东西,而是 Java 在类封装里实现的,IntegerCache 是 Integer在内部维护的一个静态内部类,用于对象缓存。
  • Integer 对象池在底层实际上就是一个变量名为 cache 的数组,里面包含了 -128 ~ 127 的 Integer 对象实例。使用对象池的方法就是通过 Integer.valueOf() 返回 cache 中的对象,像 Integer i = 10这种自动装箱实际上也是调用 Integer.valueOf() 完成的
  • 这和常量池中字面量的保存有很大区别,Integer 不需要显示地出现在代码中才添加到池中,初始化时它已经包含了所有需要缓存的对象

到此这篇关于Java 常量池详解之字符串常量池的文章就介绍到这了,更多相关java字符串常量池内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • JAVA中的字符串常量池使用操作代码

    目录 前言 理解字符串常量池 字符串拼接方式 妙用String.intern() 方法 字符串常量池有多大? 字符串常量池的优缺点 字符串池的优点 字符串池的缺点 总结 前言 研究表明,Java堆中对象占据最大比重的就是字符串对象,所以弄清楚字符串知识很重要,本文主要重点聊聊字符串常量池.Java中的字符串常量池是Java堆中的一块特殊存储区域,用于存储字符串.它的实现是为了提高字符串操作的性能并节省内存.它也被称为String Intern Pool或String Constant Pool.

  • Java字符串split方法的坑及解决

    目录 Java字符串split方法的坑 Java字符串split方法的探究 总结 Java字符串split方法的坑 先来看几行简单的Java代码,如下: System.out.println("1,2".split(",").length); System.out.println("1,2,".split(",").length); System.out.println("".split(",&q

  • Java计算字符串公式的方式解读

    目录 如何计算字符串公式 解决方案一 解决方案二 总结 如何计算字符串公式 解决方案一 使用 commons-jexl3 jar 包 可以使用 commons-jexl3 jar包,此 jar 包提供了一些方法用于计算字符串中的公式. maven 依赖如下: <dependency>     <groupId>org.apache.commons</groupId>     <artifactId>commons-jexl3</artifactId&g

  • java正则匹配读取txt文件提取特定开头和结尾的字符串

    目录 前言 一.使用FileInputStream处理 二.使用正则开始匹配 1.匹配规则书写 2.pattern 代码案例 总结 前言 前天刚入职的算法同事,过来问我怎么提取txt文件中的数据,我一看这还不简单,结果…搞了好久. 正则不用真的会忘记,写篇博客增加一下记忆吧. 需求:提取txt文件中,有特定开头(双引号) ,特定结尾(双引号) 的中间的数据,打印出来 一.使用FileInputStream处理 FileInputStream:是java中的字节输入流,就是通过字节的形式进行读取

  • Java 常量池详解之字符串常量池实现代码

    目录 1.字符串常量池(String Constant Pool) 1.1:字符串常量池在Java内存区域的哪个位置? 1.2:字符串常量池是什么? 1.3 字符串常量池生成的时机? 如何将String对象放入到常量池 String 对象代码案例解析 new string(“abc”)创建了几个对象 解析public native String intern() 方法 Integer 对象代码案例解析 为啥Integer i1 =10 跟Integer.valueOf(10) 是相等的? 为啥I

  • Tomcat 7-dbcp配置数据库连接池详解

    Tomcat 7-dbcp配置数据库连接池详解 原理 关于连接池,大家都晓得用来限定对数据库的连接.基本的原理是预先在缓冲池中放入一定的空闲连接,当程序需要和数据库来交互时,不是直接新建数据库连接而是在连接池中直接取,使用完成后再放回到连接池中.为什么要这样牺牲一个缓冲来存放这些原本就会使用的连接呢?在上面讲了一个好处就是可以限定连接数,这样不会造成N多的数据库连接最后宕机:额外有了这样一个连接池,也可以来监听这些连接和便于管理. 配置 1.拷贝相关的jar 要知道连接池不是用来直接操作数据库的

  • Java常量池详解

    目录 (1)class常量池 (2)运行时常量池 (3)基本类型包装类常量池 (4)字符串常量池 总结 java中有几种不同的常量池,以下的内容是对java中几种常量池的介绍,其中最常见的就是字符串常量池. (1)class常量池 在Java中,Java类被编译后就会形成一份class文件:class文件中除了包含类的版本.字段.方法.接口等描述信息外,还有一项信息就是常量池,用于存放编译器生成的各种字面量和符号引用,每个class文件都有一个class常量池. 其中字面量包括:1.文本字符串

  • Java String类的理解及字符串常量池介绍

    目录 一. String类简介 1. 介绍 2. 字符串构造 二. 字符串常量池(StringTable) 1. 思考? 2. 介绍和分析 3. intern方法 三. 面试题:String类中两种对象实例化的区别 四. 字符串的不可变性 一. String类简介 1. 介绍 字符串广泛应用 在 Java 编程中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串. Java的String类在lang包里,java.lang.String是java字符串类,包含

  • PHP中类型转换 ,常量,系统常量,魔术常量的详解

    PHP中类型转换 ,常量,系统常量,魔术常量的详解 1.自动类型转换; 在运算和判断时,会进行自动类型转换; 1)其他类型转为bool,判断时转换; 1)整型转布尔型:0转false,非0转为true: 2) 空字符串和'0'("0")转为false,其他转为true; 3) 空数组转为false, 非空数组则转为true; 4) null转为false 5) 资源打开不成功为false 是0或空,打开不成功的转为'false','0'; 2)其他类型转为字符串(字符串拼接); nul

  • Java 数据库连接池详解及简单实例

    Java 数据库连接池详解 数据库连接池的原理是: 连接池基本的思想是在系统初始化的时候,将数据库连接作为对象存储在内存中,当用户需要访问数据库时,并非建立一个新的连接,而是从连接池中取出一个已建立的空闲连接对象.使用完毕后,用户也并非将连接关闭,而是将连接放回连接池中,以供下一个请求访问使用.而连接的建立.断开都由连接池自身来管理.同时,还可以通过设置连接池的参数来控制连接池中的初始连接数.连接的上下限数以及每个连接的最大使用次数.最大空闲时间等等.也可以通过其自身的管理机制来监视数据库连接的

  • java线程池详解及代码介绍

    目录 一.线程池简介 二.四种常见的线程池详解 三.缓冲队列BlockingQueue和自定义线程池ThreadPoolExecutor 总结 一.线程池简介 线程池的概念 线程池就是首先创建一些线程,它们的集合称为线程池,使用线程池可以很好的提高性能,线程池在系统启动时既创建大量空闲的线程,程序将一个任务传给线程池.线程池就会启动一条线程来执行这个任务,执行结束后,该线程并不会死亡,而是再次返回线程池中成为空闲状态,等待执行下一个任务. 线程池的工作机制 在线程池的编程模式下,任务是提交给整个

  • 详解python字符串驻留技术

    前言 每种编程语言为了表现出色,并且实现卓越的性能,都需要有大量编译器级与解释器级的优化. 由于字符串是任何编程语言中不可或缺的一个部分,因此,如果有快速操作字符串的能力,就可以迅速地提高整体的性能. 在本文中,我们将深入研究 Python 的内部实现,并了解 Python 如何使用一种名为字符串驻留(String Interning)的技术,实现解释器的高性能.本文的目的不仅在于介绍 Python 的内部知识,而且还旨在使读者能够轻松地浏览 Python 的源代码:因此,本文中将有很多出自CP

  • Java中finalize()详解及用法

     Java中finalize()详解 在程序设计中,我们有时可能希望某些数据是不能够改变的,这个时候final就有用武之地了.final是Java的关键字,它所表示的是"这部分是无法修改的".不想被改变的原因有两个:效率.设计.使用到final的有三种情况:数据.方法.类.        一. final数据 有时候数据的恒定不变是很有用的,它能够减轻系统运行时的负担.对于这些恒定不变的数据我可以叫做"常量"."常量"主要应用与以下两个地方: 1

  • java @interface 注解详解及实例

    java @interface 注解详解及实例 1 简介 在Java中,定义注解其实和定义接口差多不,只需要在interface前添加一个@符号就可以,即 @interface Zhujie{ },这就表明我们定义了一个名为 @Zhujie 的注解.注解中的每一个方法定义了这个注解类型的一个元素,特别注意:注解中方法的声明中一定不能包含参数,也不能抛出异 常:方法的返回值被限制为简单类型.String.Class.emnus.注释,和这些类型的数组,但方法可以有一个缺省值. 注解相当于一种标记,

随机推荐