String常量池问题 [问题点数:50分]

Bbs1
本版专家分:0
结帖率 0%
Bbs1
本版专家分:0
String常量池问题的几个例子
String<em>常量池</em><em>问题</em>的几个例子 示例1: Java代码   String s0="kvill";   String s1="kvill";   String s2="kv" + "ill";   System.out.println( s0==s1 );   System.out.println( s0==s2 );   结果为:   true   true 分析:首先,我
String 对象内存分配(常量池和堆的分配)
     在一次面试中,面试官问了一个关于字符串对象创建<em>问题</em>,<em>问题</em>内容如下: 场景一: String s1 = &quot;123&quot; + &quot;456&quot;; 场景二: String s1 = &quot;123&quot;; String s2 = s1 + &quot;456&quot;;   在这两个场景下,分别会创建多少个字符串对象?当时其实并没太了解在 JVM 中,字符串对象的内存分配具体策略,只了解在 JVM 中有一个<em>常量池</em>,<em>常量池</em>...
Java常量池的面试题 Integer Cache
一道很让人头疼的Java面试题。好像也不太像面向应届生的题目,不过里边一些了解一下还是不错的。 今天My partner问我一个让他头疼的Java question,求输出结果: /**  *   * @author DreamSea 2011-11-19  */ public class IntegerTest {     public static void m
Java基础之jdk1.8 JVM内存模型简述,含String常量池简单分析
最近有个机会整理JAVA基础相关知识,整理到JVM内存模型这部分的时候,画了两张图,记载在此,供感兴趣的新手参考。
String之常量池小结
String之<em>常量池</em>小结
JVM常量池与String类深入理解
深入理解java String与JVM<em>常量池</em> 创建一个String有二种形式 String a = "abc"; String b = new String("abc");
java-String常量池的知识点你知道多少?-结合jdk版本变更
String <em>常量池</em>知识点 总结 三大<em>问题</em>总结: 1.String<em>常量池</em>位置在哪? 2.String<em>常量池</em>里存的是对象还是引用? 3.String类中的==比较以及intern()方法原理?   回:1.String<em>常量池</em>位置在哪? 在jdk6版本,String<em>常量池</em>是在方法区中的运行时<em>常量池</em>。   三种情况: java7之前,方法区位于永久代(PermGen),永久代和堆相互...
String放入运行时常量池的时机与String.intern方法解惑
运行时<em>常量池</em>概述 Java运行时<em>常量池</em>中主要存放两大类常量:字面量和符号引用。字面量比较接近于Java语言层面的常量概念,如文本字符串、声明为final的常量值等。 而符号引用则属于编译原理方面的概念,包括了下面三类常量: - 类和接口的全限定名(包名+类名) - 字段的名称和描述符 - 方法的名称和描述符 运行时<em>常量池</em>位置 运行时<em>常量池</em>在JDK1.6及之前版本的JVM中
java中String之常量池与对象
最近一直在研究源码,今天把String类给看完了,基本上是把源码看了一遍(JDK1.8),所获得的收获还是可以的,但是看了归看了,俗话说的好好记性不如烂笔头,今天就写一写自己的心得体会。首先在String类型在开发项目中用的是比较多的,大多数的都是在比较是否相等判断之类的,在String中重写了equals方法,先是比较地址,然后比较是否是是同一类型的对象,如果是则比较length,如果lengt...
String.intern()方法与常量池存入时的疑惑!
环境jdk:1.8今天再看极客学院关于《JVM自动内存管理:内存区域基础概念》 有这么一块没有看懂:public class RuntimeConstantPoolChange { public static void main(String[] args) { // 第一段代码 String str1 = new StringBuilder("极客").ap
Java进阶——Java中的字符串常量池
字符串<em>常量池</em> JVM为了减少字符串对象的重复创建,其内部维护了一个特殊的内存,这段内存被成为字符串<em>常量池</em>(方法区中)。实际上还有整型<em>常量池</em>、浮点型<em>常量池</em>等等。字符串<em>常量池</em>存放的是对象的引用,而不是对象。Java中字符串对象创建有两种形式:字面量形式和创建对象形式。 1、字面量形式 字面量的体现形式String str = &amp;amp;amp;amp;amp;quot;Hello&amp;amp;amp;amp;amp;quot;,简单理解为去字符串<em>常量池</em>中拿对象 当代码中出现字面量...
Java常量池详解--比较蛋疼的面试题(一)
实例一 public class test { public static void main(String[] args) { objPoolTest(); } public static void objPoolTest() { int i = 40; int i0 = 40;
java 堆栈常量池,String创建图解(内存分配,区)
       说到java中堆、栈和<em>常量池</em>,首先还是看看他们各自存放的数据类型吧!  堆:存放所有new出来的对象;栈:存放基本类型的变量数据和对象的应用,对象(new出来的对象)本身并不存在栈中,而是存放在堆中或者<em>常量池</em>中(字符串常量对象存放在<em>常量池</em>中);<em>常量池</em>:存放基本类型常量和字符串常量。 对于栈和<em>常量池</em>中的对象可以共享,对于堆中的对象不可以共享。栈中的数据大小和生命周期是可...
Java中的String、StringPool(字符串常量池)
字符串<em>常量池</em>与简单语法String s = "hahahah"; String s2 = "hahahah"; 1->在字符串<em>常量池</em>中查看是否存在内容与"hahahah"相同的字符串对象; 2->若没有,则新创建一个包含该内容的字符串对象,并让引用变量指向该对象。例如,创建字符串s的时候,字符串<em>常量池</em>中没有,则创建一个新对象,并让s指向该对象; 3->若已存在包含该内容的字符串对象,则让字符串引用
java字符串常量池——字符串==比较的一个误区
起因 再一次js的json对象的比较中,发现相同内容的json对象使用==比较并不相等。 例如: var obj = {}; var obj2 = {}; console.log(obj == obj2); // 结果为false json在js中代表一个对象==比较的是对象栈中存放引用堆的地址。上面的obj和obj2创建的是两个对象地址肯定不同结果为false。 但最令我不...
Java字符串常量池
开篇同学们面试的时候总会被问到字符串<em>常量池</em>的<em>问题</em>吧?如果你是死记硬背的答案,那么我想看了我这篇文章,你应该以后能胸有成竹了跟着Alan,走起!1. 享元模式其实<em>常量池</em>这个<em>问题</em>涉及到一个设计模式,叫“享元模式”,顾名思义 - - - &gt; 共享元素模式也就是说:一个系统中如果有多处用到了相同的一个元素,那么我们应该只存储一份此元素,而让所有地方都引用这一个元素Java中String部分就是根据享元模式设
字符串常量池、运行时常量池
众所周知,在JVM中栈存放对象的引用和基本类型,堆存放具体的对象和每个对象包含一个与之对应的class信息,方法区存储了每个类的信息(包括类的名称、方法信息、字段信息)、静态变量、常量以及编译器编译后的代码等。关于String<em>常量池</em>、<em>常量池</em>等又让人头大。String str = &quot;abc&quot;; 如此生成的字符串存放在<em>常量池</em>中String str = new String(&quot;abc&quot;); 如此生成的字...
string字符串常量池在内存中的位置
这里只是举个简单的例子说明字符串<em>常量池</em>在内存中的位置。     闲言少叙,直接上代码。   Java代码   "font-size: large;">import java.util.ArrayList;    public class Test {        public static void main(String[] args) {          Strin
java String类有关静态变量,常量池,引用对象的问题
java-String类的各种小研究今天看到一个面试题,这让我对String类和jvm运行数据有新的了解,题目如下:static String str0="0123456789"; static String str1="0123456789"; String str2=str1.sub<em>string</em>(5); String str3=new String(str2); String str4=new
Java的string常量池及不可变性
1、String<em>常量池</em>     当使用new String(“hello”)时,JVM会先使用<em>常量池</em>来管理“hello”直接量,再调用String类的构造器来创建一个新的String对象,新创建的对象被保存在堆内存中。即new String(“hello”)一共产生了两个字符串对象。 【<em>常量池</em>constant pool】管理在编译时被确定并保存在已编译的.class文件中的一些数据,包括关于类
java 为什么需要常量池
转载自  java 为什么需要<em>常量池</em>java中讲的<em>常量池</em>,通常指的是运行时<em>常量池</em>,它是方法区的一部分,一个jvm实例只有一个运行<em>常量池</em>,各线程间共享该运行<em>常量池</em>。java内存模型中将内存分为堆和栈,其中堆为线程间共享的内存数据区域,栈为线程间私有的内存区域。堆又包括方法区以及非方法区部分,栈包括本地方法栈、虚拟机栈等,如下图所示:为什么需要<em>常量池</em>jvm 在栈帧(frame) 中进行操作数和方法的动...
JVM-String常量池与运行时常量池
Start with JVM 先分析一波<em>常量池</em>-Constant Pool
Java堆、栈和常量池以及相关String的讲解
一:在JAVA中,有六个不同的地方可以存储数据:   1. 寄存器(register)。 这是最快的存储区,因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量极其有限,所以寄存器由编译器根据需求进行分配。你不能直接控制,也不能在程序中感觉到寄存器存在的任何迹象。     ------最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制. 2. 堆栈(sta
JDK1.8版本java字符串常量池里存的是String对象还是引用?
先下结论:对象!众所周知,JDK1.8版本中,String<em>常量池</em>已经从方法区中的运行时<em>常量池</em>分离到堆中了,那么在堆中的String<em>常量池</em>里存的是String对象还是引用呢?我在网上查了一晚上,各有各的说法,最后索性直接查看API(果然API才是最强大的!!!),废话少说,直接上图:翻译一下,String类的intern()方法:一个初始为空的字符串池,它由类String独自维护。当调用 inter...
字符串常量池、class常量池和运行时常量池
  原文链接:http://tangxman.github.io/2015/07/27/the-difference-of-java-<em>string</em>-pool/                         在java的内存分配中,经常听到很多关于<em>常量池</em>的描述,我开始看的时候也是看的很模糊,网上五花八门的说法简直太多了,最后查阅各种资料,终于算是差不多理清了,很多网上说法都有<em>问题</em>,笔者尝试着...
String类和常量池
String类和<em>常量池</em> 1、 String对象的两种创建方式: String str1 = &quot;abcd&quot;; String str2 = new String(&quot;abcd&quot;); System.out.println(str1==str2);//false 这两种不同的创建方法是有差别的,第一种方式是在<em>常量池</em>中拿对象,第二种方式是直接在堆内存空间创建一个新的对象。 记住:只要使用new方...
java String常量池与字符串拼接性能优化
----String<em>常量池</em>---- 1.<em>常量池</em>中的对象从哪里来的?String s1="hanhan"; String s2="hanhan"; System.out.println(s1==s2);//true当我们创建String对象采用字面量形式时,JVM首先会对这个字面量进行检查,如果<em>常量池</em>中存放有该字面量,则直接使用,否则创建新的对象并将其引用放入<em>常量池</em>中。String s1="han"
一个关于字符串常量池问题
看一个例子 public class Test4 { public static void main(String[] args) { String s1 = "b"; String s2 = "a"; String s3 = s1 + "d"; String s4 = "e" + "f"; String s5 = s1 + s2; } } <em>问题</em>是,现在字符串<em>常量池</em>
java常量池概念,String,Integer等包装类对常量池的应用
在class文件中,“<em>常量池</em>”是最复杂也最值得关注的内容。   Java是一种动态连接的语言,<em>常量池</em>的作用非常重要,<em>常量池</em>中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如:   类和接口的全限定名;   字段的名称和描述符;   方法和名称和描述符。   在C语言中,如果
结合源码和常量池详解Java中的String
本篇对String结合源码和<em>常量池</em>进行总结String是java中一个常用的引用类型。先看String源码:所以String底层是由char[]数组存储数据的。那么String的最大长度应该是多少呢?由于String底层是char[]数组,所以其允许的长度是固定的, 由于char[]数组的元素是由下标来定位的,而下标的类型为int,所以char最多只能表示2^31 - 1(2G-1),也就是说st...
java_关于字符串类型及常量池
StringBuilder:可变字符串类型 *(字符串:底层是字符数组,及其对数组的操作) 特点: (1)由final修饰 (2)没有重写equals方法 (3)此类型提供的大多数方法都带有返回值 构造器 StringBuilder()构造了一个空的字符串生成器,初始容量为16个字符。 *StringBuilder(String str...
常量池之字符串常量池String.intern()
运行时<em>常量池</em>是方法区(PermGen)的一部分。需要提前了解: 1. JVM内存模型。 2. JAVA对象在JVM中内存分配<em>常量池</em>的好处<em>常量池</em>是为了避免频繁的创建和销毁对象而影响系统性能,其实现了对象的共享。 - Java的自动装箱中其实就使用到了运行时<em>常量池</em>。详见:Java 自动装箱与拆箱的实现原理 - 还有字符串<em>常量池</em>。字符串进入到<em>常量池</em>的两种方法:1. new String()的实例
1.String对象和常量池 2.基本数据类型和封装类(128以下等不做缓存)
/** * 字符串判断 * 1.== 和!=的使用对象是同一个对象的比较 * 2.当不确定字符串是否是<em>常量池</em>的对象的时候,使用equals()比较 * 3.正常情况下都是<em>常量池</em>的字符串!!! */ public void setStr() { //String a = new String("");//那个叫兽会这样做?
字符串常量池(String Constant Pool)深入解析
字符串<em>常量池</em>(String Constant Pool) 1:概述 字符串的分配和其他对象分配一样,是需要消耗高昂的时间和空间的,JVM为了提高性能和减少内存的开销,在实例化字符串的时候进行了一些优化: 使用字符串<em>常量池</em>:每当我们创建字符串<em>常量池</em>时,JVM会首先检查字符串<em>常量池</em>,如果该字符串已经存在<em>常量池</em>中,那么久直接返回<em>常量池</em>中的实例引用,如果字符串不存在<em>常量池</em>中,就会实例化该
java中关于栈、堆、常量池介绍和关于String类的理解
栈、 <em>常量池</em>、 堆各自存放什么样的数据类型? 栈:存放基本类型的变量数据和对象的引用。像int a = 1;  String str = "hello" ; String str1 = new String("OK") ;  栈中存放的是 a, 1, str, str1。 <em>常量池</em>:存放基本类型常量和字符串常量。 堆:存放所有new出来的对象。 对于栈和<em>常量池</em>中的对象可以共享,对于堆中的对象
字符串常量池及byte数据常量池
Byte型数据缓冲池Demo1public class BufferPoolDemo { public static void main(String[] args) { Integer i1=127; Integer i2=127; System.out.println(i1==i2); System.out.println(
JAVA中关于String类型的创建和字符串常量池问题
在 JAVA 语言中有8中基本类型和一种比较特殊的类型String。这些类型为了使他们在运行过程中速度更快,更节省内存,都提供了一种<em>常量池</em>的概念。<em>常量池</em>就类似一个JAVA系统级别提供的缓存。       8种基本类型的<em>常量池</em>都是系统协调的,String类型的<em>常量池</em>比较特殊。它的主要使用方法有两种: 1)直接使用双引号声明出来的String对象会直接存储在<em>常量池</em>中。
java 字符串常量池
试题一、String s = new String("abc")创建了几个对象? String s = new String("abc")实际上是"abc"本身就是字符串池中的一个对象,在运行 new String()时,把字符串池的字符串"abc"复制到堆中,并把这个对象的应用交给s,所以创建了两个String对象,一个在字符串池中,一个在堆中。(注:我们假设的是字符串池中默认是没有abc字符
StringBuffer何时初始化到常量池
首先,在源代码中用双引号引起来的会自动进入<em>常量池</em>中(其实字符串对象是在堆中,然后<em>常量池</em>里有个引用指向它,但是和直接说在<em>常量池</em>中似乎没多大影响,下面也就这么说了) String s1 = new StringBuffer("he").append("llo").toString(); System.out.println(s1==s1.intern());//结果是true 这
String intern方法及常量池理解
 几张图轻松理解String.intern()标签: 编译器 虚拟机 intern <em>常量池</em> 字符串2017年04月12日 20:35:496817人阅读 评论(13) 收藏 举报 分类:-------【Java基础】(5) 版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/soonfly/article/details/70147205在翻《深入理解...
方法区和常量池
最近一直被方法区里面存着什么东西困扰着?        1.方法区里存class文件信息和class文件<em>常量池</em>是个什么关系。         2.class文件<em>常量池</em>和运行时<em>常量池</em>是什么关系。                  方法区存着类的信息,常量和静态变量,即类被编译后的数据。这个说法其实是没<em>问题</em>的,只是太笼统了。更加详细一点的说法是方法区里存放着类的版本,字段,方法,接口和<em>常量池</em>。
JAVA 常量池与String
提到<em>常量池</em>,一般是指运行时<em>常量池</em>,是方法区的一部分。方法区就是通常说的永久代。那么<em>常量池</em>中会存储那些数据呢?   ①编译期生成的各种字面量和符号引用   ②也有可能将运行期间的常量放入<em>常量池</em> 先看第一种:编译期生成的各种字面量和符号引用,这部分数据经过编译后存在.class文件的‘<em>常量池</em>’中,注意这个所谓的‘<em>常量池</em>’是‘静态<em>常量池</em>’,静态<em>常量池</em>的数据会在类加载后放入运行时<em>常量池</em>。举个
String类创建对象问题
关于String类中<em>常量池</em>、字符串池的理解
JVM之常量池导致的内存溢出异常问题
1.代码运行的时候<em>常量池</em>是方法区的一部分,使用<em>string</em>.itern()是一个Native方法,如果字符串<em>常量池</em>中已经一个等于此String对象的字符串,则返回池中这个字符串的<em>string</em>对象,否则将<em>string</em>对象包含的字符串添加到<em>常量池</em>中,并且由此返回此<em>string</em>对象的引用。  ...
Java之String常量池的理解
1. <em>常量池</em>概念1.1 <em>常量池</em>在java用于保存在编译期已确定的,已编译的class文件中的一份数据。它包括了关于类,方法,接口等中的常量,也包括字符串常量,如String s = “java”这种申明方式;当然也可扩充,执行器产生的常量也会放入<em>常量池</em>,故认为<em>常量池</em>是JVM的一块特殊的内存空间 百度百科2. String类和<em>常量池</em>2.1 String的”==” 和 “equals()” ==
《多线程编程》学习之六:String的常量池特性,锁对象的改变,volatile关键字
1、String的<em>常量池</em>特性         在JVM中具有<em>常量池</em>缓存功能,如String s1 = "abc"; String s2 = "abd";   这里s1与s2代表同一个String对象。当我们在同步代码块synchronized(<em>string</em>){ }使用String作为锁对象时,可能会出现<em>问题</em>。看下面例子: 例一: 测试结果:           
JAVA String类与常量池,堆之间的错综复杂...
由JVM内存管理可知,在方法区中有一块独立的区域,被称之为运行时<em>常量池</em>,在虚拟机启动时,JVM会自动创建,有9种类型的<em>常量池</em>,8大基本类型与String类型。    <em>常量池</em>是存放数据字面量的,比如“abc”,1,5.0,'c',true等等(注:String类的具体值,都是存在<em>常量池</em>中,堆中存的是<em>常量池</em>中的引用;8大基本类型的包装类中,除了Float,Double类意外,都有实现<em>常量池</em>,但是,数
1.运行时常量池导致内存溢出异常的实现
其中intern()是本地native方法的一种; 具体的验证过程见下图: 一直到后期去不断的去增加intern() 直到将方法区溢出: 通过VM对程序进行监控 如下所示: 显示如下: 此时进行内存溢出的时PerGem space的这种情况: 详细验证代码如下: import java.util.ArrayList; import java.util.Lis...
Java中的常量池(字符串常量池、class常量池和运行时常量池)
简介: 这几天在看Java虚拟机方面的知识时,看到了有几种不同<em>常量池</em>的说法,然后我就去CSDN、博客园等上找资料,里面说的内容真是百花齐放,各自争艳,因此,我好好整理了一下,将我自认为对的理解写下来与大家共同探讨: 在Java的内存分配中,总共3种<em>常量池</em>:1.字符串<em>常量池</em>(String Constant Pool):1.1:字符串<em>常量池</em>在Java内存区域的哪个位置? 在JDK6.0及之前版本,字符串
java中的String详解—-new对象和常量池的概念
原帖:[url]http://www.haohaoblog.com/?p=961[/url] :idea: 自己添加整理备用 :lol: [code=&quot;java&quot;]public class StringTest { public static void main(String[] args) { String a = new String(); St...
java中的字符串到底是在方法区的常量池里还是new出来的对象里
String实质是字符数组,两个特点:1、该类不可被继承;2、不可变性(immutable)例如 String s1 = new String(&quot;myString&quot;);和 String s1 = &quot;myString&quot;; 第一种方式通过关键字new定义过程:在程序编译期,编译程序先去字符串<em>常量池</em>检查,是否存在“myString”,如果不存在,则在<em>常量池</em>中开辟一个内存空间存放“myString”;如果...
常量池 运行时常量池 String intern方法想到的(一)
最近在看《深入理解java虚拟机》,看到了<em>常量池</em>(Constant Pool Table)和运行时<em>常量池</em>(Runtime Constant Pool)这两个概念,对这两个概念不是很理解。又看到了String类的intern方法,intern方法也没用过。于是,查了查,记录如下。 以后遇到了<em>问题</em>之后,写blog时,先下<em>问题</em>的结论。结论<em>常量池</em>这个概念是针对java class文件而言的。当java代码
JDK1.8关于运行时常量池, 字符串常量池的要点
网上关于jdk 1.8的各种实验,  结论鱼龙混杂 , 很多都相矛盾,网上有的实验也被后人测试出了不同的结果 很多都分辨不了真假, 这里记录一下网络上正确的结论, 欢迎指正! 首先自行区分运行时<em>常量池</em>与Class文件<em>常量池</em>(静态<em>常量池</em>)的概念, JVM内存模型 ,方法区与永久代的区别, 有些在我的其他博客有介绍,  连接在文尾    在JDK1.7之前运行时<em>常量池</em>逻辑包含字符串<em>常量池</em>存放在...
基于JDK1.8 分析运行时常量池、字符串常量池、各种常量池
  Java中的<em>常量池</em>分为三种类型: 类文件中<em>常量池</em>(The Constant Pool) 运行时<em>常量池</em>(The Run-Time Constant Pool) String<em>常量池</em>   类文件中<em>常量池</em> ---- 存在于Class文件中 所处区域:堆 诞生时间:编译时 内容概要:符号引用和字面量 class<em>常量池</em>是在编译的时候每个class都有的,在编译阶段,存放的是常量的符号引用...
字符串常量池深入解析
字符串<em>常量池</em> 字符串<em>常量池</em> 概述 一、Java中两种创建字符串对象的方式的分析。 二、Intern的实现原理(JDK1.8) 三、JDK1.7的Intern的执行 四:几种特殊的情况的代码 参考的部分文章 概述   在分析字符串<em>常量池</em>之前,先来分析一下java的内存区域,然后再各种的情况分析一下各种情况下的情况; 在《深入理解java虚拟机》这本书上是这样写的:对于H...
String类型的值能够被反射改变和常量池的理解
介绍文章写得有点杂,有对<em>常量池</em>的理解和字符串的值通过反射修改!!开始讲解先准备一个基础类:public class A { public final String tempString="wide world"; public String getTempString() { return tempString; } }public class TestA {
Java运行时常量池与final修饰符的关系
概述Java运行时<em>常量池</em>是JVM运行时内存模型的重要部分.我对<em>常量池</em>的理解大都来自于周志明大大的《深入理解Java虚拟机》, 书中对<em>常量池</em>有较多的描述与解释, 在内存管理, 类文件结构等部分章节中都有说明. 正如我之前的博文–JVM内存管理对<em>常量池</em>描述的一样,<em>常量池</em>会存储字面量和符号引用,但我有个疑问: <em>常量池</em>与final修饰符的关系是怎么样的?Codepublic class Test{
Java内存模型分析(堆、栈和常量池以及相关String的详细讲解)
在JAVA中,有六个不同的地方可以存储数据: 寄存器(register)。 这是最快的存储区,因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量极其有限,所以寄存器由编译器根据需求进行分配。你不能直接控制,也不能在程序中感觉到寄存器存在的任何迹象。 ——最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制. 堆栈(stack)。位于通用RAM中,但通过它的“堆栈指
字符串常量池和堆中的非常量池(堆)创建字符串(new 和非new穿件 == 和equal比较)
简单分析:String str1= &quot;hello&quot;, String str2=&quot;he&quot;+&quot;llo&quot;;之所以str1==str2返回true是因为两者都是在字符串<em>常量池</em>中(由于初始化就会在此区域分布内存)而<em>常量池</em>中的有个与栈区类似的特性,就是当str2指向的常量在常量区已存在时,他不会创建新的内存空间来存此常量,而是指向已有常量的内存(应该是以此节约空间),此时str1与str2这两个引用变量的值都...
java中的String类常量池 (你都懂了吗?)
从一个博客上看到的6个题,先看看吧,如果都会了,这部分的知识就掌握的不错啦!输出结果在代码注释后面: test1:package StringTest;public class test1 {         public static void main(String[] args){             String a = "a1";              String b
方法区与常量池
一.相关概念 1. 什么是常量 用final修饰的成员变量表示常量,值一旦给定就无法改变! final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。 Class文件中的<em>常量池</em> 在Class文件结构中,最头的4个字节用于存储魔数Magic Number,用于确定一个文件是否能被JVM接受,再接着4个字节用于存储版本号,前2个字节存储次版本号,后2个存储主版本号,...
Java内存分配详解(堆内存、栈内存、常量池)
Java程序是运行在JVM(Java虚拟机)上的,因此Java的内存分配是在JVM中进行的,JVM是内存分配的基础和前提。Java程序的运行会涉及以下的内存区域: 1. 寄存器:JVM内部虚拟寄存器,存取速度非常快,程序不可控制。 2. 栈:存放基本类型的数据和对象的引用,但对象本身不存放在栈中,而是存放在堆中。 3. 堆:存放new出来的对象,注意创建出来的对象只包含各自的成员变量,不包括成
java jdk1.7常量池移到哪去了?
今天模拟了一下<em>常量池</em>的oom,突然发现设置的参数-XX:PermSize=10M -XX:MaxPermSize=10M不管用了,同时发现内存一直在上升,当上升到一个极值就会趋于平稳,然后再过一段时间会报: Exception in thread “main” java.lang.OutOfMemoryError: GC overhead limit exceeded 这个异常是当GC的时间超过
常量在什么时候被放入常量池
先来了解一下<em>常量池</em>,<em>常量池</em>分为方法区中的运行时<em>常量池</em>和class文件中的<em>常量池</em>,class文件中的<em>常量池</em>在编译时确定,其中包括符号引用和字面量(文本字符串,被声明为final的变量的值),运行时,JVM从中读取数据到方法区的运行时<em>常量池</em>,运行时<em>常量池</em>可以在运行时添加常量,常量可以在运行时或编译时被放入<em>常量池</em>,编译期放入到类文件的<em>常量池</em>中,运行时放入到方法区的运行时<em>常量池</em>中,JDK1.7后运行时常量
检测一个字符串是否在jvm的常量池
检测一个字符串是否在jvm的<em>常量池</em>中 : public static boolean inPool(String s) {       String s2 = s.intern();       if (s2 == s)           return true;       return false;   }
Java 中关于常量池与缓存类的一点理解
先来看这么一段代码 String str1 = "123"; String str2 = "123"; System.out.println(str1 == str2); String str3 = new String("123"); System.out.println(str1 == str3); str3 = str3.in
验证运行时常量池在JDK1.7被移到Java堆中
JDK1.6代码运行及其结果 /** * VM options:-Xms10M -Xmx20M -XX:PermSize=10M -XX:MaxPermSize=10M -XX:-UseGCOverheadLimit */ public class StringIntern { public static void main(String[] args) { Li...
Java字节码结构剖析一:常量池
这篇博客开始,我打算手把手的带大家去解读一下JVM平台下的字节码文件(熟悉而又陌生的感觉)。众所周知,Class文件包含了我们定义的类或接口的信息。然后字节码又会被JVM加载到内存中,供JVM使用。那么,类信息到了字节码文件里,它们如何表示的,以及在字节码里是怎么分布的呢?带着这些<em>问题</em>,让我们去深入了解字节码文件吧。
Constant Pool常量池的概念
Constant Pool<em>常量池</em>的概念 Constant Pool<em>常量池</em>的概念: 在讲到String的一些特殊情况时,总会提到String Pool或者Constant Pool,但是我想很多人都不太 明白Constant Pool到底是个怎么样的东西,运行的时候存储在哪里,所以在这里先说一下Constant Pool的内容. String Pool是对应于在Constant Pool中存
字符串过长处理
//设置宽度为200px,当字符串长度过大时,自动变成省略号,追加悬停显示完整信息 var transStr = ‘
String常量池和synchronized关键字
在java中String是一个比较特殊的类,String有一个自己的<em>常量池</em>,存放了初始化的字符串,这一个特性经常能导致一些坑,下面简单的介绍一点。   一,用常量赋值的字符串 String a=”abc”; 当执行这条语句时,先在<em>常量池</em>中查找是否有”abc”对象,如果有则创建对象a并指向这个对象,如果没有则先在<em>常量池</em>中创建”abc”对象,然后创建对象a并指向这个对象。 最终a是指向常...
字符串常量池、堆、栈
String a="a"+"b"+"c" 创建了几个对象这个<em>问题</em>涉及到了字符串<em>常量池</em>和字符串拼接String a="a"+"b"+"c"通过编译器优化后,得到的效果是String a="abc"Java中字符串对象创建有两种形式,一种为字面量形式,如String str = "droid";另一种就是使用new这种标准的构造对象的方法,如String str = new String("droid
字符串创建的方式,双引号在常量池创建,用new普通对象的创建方式。
/** * 字符串创建的方式,双引号在<em>常量池</em>创建,用new普通对象的创建方式。 * @author jiaxutianhuo * */ public class String01 { public static void main(String[] args) { // TODO Auto-generated method stub //创建对象,是在堆内存中创建对象 //
关于常量池,字符串常量池的整理
由于之前研究了一下JVM的内存划分,对里面方法区的<em>常量池</em>一知半解,于是想要探究一下 全局字符串池(<em>string</em> pool也有叫做<em>string</em> literal pool) 全局字符串池里的内容是在类加载完成,经过验证,准备阶段之后在堆中生成字符串对象实例,然后将该字符串对象实例的引用值存到<em>string</em> pool中(记住:<em>string</em> pool中存的是引用值而不是具体的实例对象,具体的实例对象是在...
Java的String类为什么是不可变的以及字符串常量池
JAVA中的String是一个不可变(immutable)类,即创建一个String对象后,是不能直接改变字符串中的某个字符的。 我们打开JDK中String类的源代码来看一下: /** The value is used for character storage. */ private final char value[];其中用于存储String值的仍然是一个char型数
java中-128~127数字常量池
java中的自动装箱和自动拆箱是jdk1.5中出现的,可以在程序编译期自动将基本数据类型转换为包装类型。 有如下代码: public class Test{ public static void main(String... args){ Integer i1 = 128; Integer i2 = 128; /* ...
java基础常见问题解析(四)堆、常量池、方法区栈与队列
堆、<em>常量池</em>、方法区栈与队列 在Java 中,下面关于String 类和StringBuffer 类的描述正确的是哪一个 a. StringBuffer 类的对象调用toString()方法将转化为String 类型 b. 两个类都有append()方法 c. 可以直接将字符串”test” 赋值给声明的String 类和StringBuffer 类的变量 d. 两个类的实例的值都能够改变...
Java中的栈,堆,方法区和常量池
1.寄存器:最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制. 2. 栈:存放基本类型的变量数据和对象的引用,但对象本身不存放在栈中,而是存放在堆(new 出来的对象)或者<em>常量池</em>中(对象可能在<em>常量池</em>里)(字符串常量对象存放在<em>常量池</em>中。)      栈中的数据可以共享:  int a = 3;   int b = 3;   编译器先处理int a = 3;首先它会在栈中创
java中常量池的概念及存在的区域
--------java中<em>常量池</em>的概念 在class文件中,“<em>常量池</em>”是最复杂也最值得关注的内容。   Java是一种动态连接的语言,<em>常量池</em>的作用非常重要,<em>常量池</em>中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如:   类和接口的全限定名;   字段的名称和描述符;   方
Java字符串常量池相关问题
首先,我们来熟悉字符串<em>常量池</em>:字符串在java程序中被大量使用,为了避免每次都创建相同的字符串对象及内存分配,JVM内部对字符串对象的创建做了一定的优化,有一块专门的区域用来存储字符串常量,该区域就是字符串<em>常量池</em>。字符串<em>常量池</em>涉及到一个设计模式,叫享元模式,所谓享元模式是说:一个系统中如果有多处用到了相同的一个元素,那么我们应该只存储一份此元素,而让所有地方都引用这一个元素。
8种基本类型的包装类和常量池简单介绍
/** * 8种基本类型的包装类和对象池 * 包装类:java提供的为原始数据类型的封装类,如:int(基本数据类型),Integer封装类。 * 对象池:为了一定程度上减少频繁创建对象,将一些对象保存到一个"容器"中。 * * Byte,Short,Integer,Long,Character。这5种整型的包装类的对象池范围在-128~127之间,也就是说, * 超出这
运行时数据区域——运行时常量池(Runtime Constant Pool)。
博文中的内容来源《深入理解Java虚拟机_JVM高级特性与最佳实践》这一本书,感激不尽。
java string 常量池问题
字符串相加,只要有变量参与的,那么就不会使用<em>常量池</em>里的字符串引用。如果是String s3 = &quot;ab&quot;;String s5 = &quot;a&quot; + &quot;b&quot;;这种在相加过程中没有变量参与的字符串参加,会使用<em>常量池</em>。所以,s3 == s5的值是true。反正别的不多说,具体看程序,看了下面的,那一切都懂了(基于jdk1.8)                String s1 = &quot;a&quot;; String s...
java: 封装缓存池(int与Integer)、常量池(拘留池)、static变量 static代码块 static方法、 final变量、final 方法、final类 整理
java 内存模型: JVM主要管理两种类型内存:堆和非堆,堆内存(Heap Memory)是在 Java 虚拟机启动时创建, 非堆内存(Non-heap Memory)是在 JVM堆之外的内存  堆:对象的具体(属性 方法);  非堆区: 栈:方法执行时 在此操作,局部变量,堆中对象的地址; 静态数据区: static修饰的数据区(假设 技术不能假设!!):如果经stat
synchronized 数据类型String常量池特性
package extthread; import service.Service; public class ThreadA extends Thread { private Service service; public ThreadA(Service service) { super(); this.service = service; } @Override publi...
java内存中的堆栈、堆、静态区、常量池
转自:http://www.cnblogs.com/protected/p/6419217.html程序运行时,有六个地方都可以保存数据:  1、 寄存器:这是最快的保存区域,因为它位于和其他所有保存方式不同的地方:处理器内部。然而,寄存器的数量十分有限,所以寄存器是根据需要由编译器分配。我们对此没有直接的控制权,也不可能在自己的程序里找到寄存器存在的任何踪迹。  2、 堆栈:存放基本类型的数据和...
关于字符串在常量池中中的存储问题
关于字符串在<em>常量池</em>中中的存储<em>问题</em> package com.xwl; /** * 关于<em>常量池</em>的<em>问题</em> * @author Administrator * 字符串<em>常量池</em> */ public class AboutInterview { public static void main(String[] args) { String s1 = &quot;hello&quot;; ...
Java中内存问题总结一(栈、堆、常量池及String类在内存中的实现)
原文地址 在JAVA中,有六个不同的地方可以存储数据: 1. 寄存器(register)。 这是最快的存储区,因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量极其有限,所以寄存器由编译器根据需求进行分配。你不能直接控制,也不能在程序中感觉到寄存器存在的任何迹象。 ------最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制. 2. 堆栈
jvm-方法区(常量池
<em>常量池</em>主要涉及到<em>常量池</em>里的内容和<em>常量池</em>解析这两块。 在方法区中,每个类型都对应一个<em>常量池</em>,<em>常量池</em>中存储了如:文字字符串,final变量值,类名,方法名等常量。jvm把<em>常量池</em>组织为入口列表的形式,可通过索引来访问<em>常量池</em>中的各个入口,每个<em>常量池</em>入口的第一个字节都是个标志,用这个标志来表示该入口中存储的常量类型,如:CONSTANT_Long表示里面存储的是Long类型的字面值,CONSTANT_Cl
理解归纳方法区和常量池
前言    方法区用于存储已经被虚拟机加载的类信息(class文件是存入方法区的),常量,静态变量。    我对方法区的理解其实是个逻辑区,其是在哪里不重要,在堆内外都没关系,对于HotSpot来说,方法区JDK1.7是在永久代,而1.8在元空间(与堆不相连的本地内存)。    而<em>常量池</em>是方法区的一部分(说的不是很准备)1. <em>常量池</em>:<em>常量池</em>,分为class<em>常量池</em>和运行时<em>常量池</em>,运行时的<em>常量池</em>是属于...
java-jvm-常量池
Java中的<em>常量池</em>,实际上分为两种形态:静态<em>常量池</em>和运行时<em>常量池</em>。      所谓静态<em>常量池</em>,即*.class文件中的<em>常量池</em>,class文件中的<em>常量池</em>不仅仅包含字符串(数字)字面量,还包含类、方法的信息,占用class文件绝大部分空间。      而运行时<em>常量池</em>,则是jvm虚拟机在完成类装载操作后,将class文件中的<em>常量池</em>载入到内存中,并保存在方法区中,我们常说的<em>常量池</em>,就是指方法区
String类的内存解析——字符串常量池
package pers.songhongkang.chapter4.day09; //String类的内存解析,存在<em>常量池</em>中 public class TestString { public static void main(String[] args) { String str1="AA"; String str2="AA"; String str3=new String("AA
常量池 运行时常量池 String intern方法想到的(四)之深入理解intern
上篇博文由<em>常量池</em> 运行时<em>常量池</em> String intern方法想到的(三),写到了String的内存模型,这篇博文讨论下String#intern方法的实现。 这篇博文主要参考自:深入解析String#intern。只是用来学习,无意侵犯版权。声明本文的讨论如在不特殊说明的前提下,使用的是JDK1.6,在特殊场合会说明使用的是JDK1.6还是JDK1.8。 JDK1.6java version
关于String常量池与堆的分析总结
一、 起源和区别 首先上图: 出现以上两种方式的原因是: 字符串创建实例过程中,JVM为了减少内存开销进行的一种优化概念。 第一种方式创建实例时,JVM会首先检查字符串<em>常量池</em>中是否含有该实例。如果字符串已经存在池中,就返回池中的实例引用。如果字符串不在池中,就会实例化一个字符串并放到池中。(8种基本数据类型均有<em>常量池</em>机制)。 第二种方式是运行期创建,而不去考虑是否已经存在<em>常量池</em>中。 二、&amp;quot;=...
Java提高篇之常量池
一.相关概念1. 什么是常量用final修饰的成员变量表示常量,值一旦给定就无法改变!final修饰的变量有三种:静态变量、实例变量和局部变量,分别表示三种类型的常量。2. Class文件中的<em>常量池</em>在Class文件结构中,最头的4个字节用于存储魔数Magic Number,用于确定一个文件是否能被JVM接受,再接着4个字节用于存储版本号,前2个字节存储次版本号,后2个存储主版本号,再接着是用于存放常
string 的栈 堆、常量池的区别 特列
1.<em>string</em>的特点:只要改变<em>string</em>的值就要重新在堆里面new指向栈的新的地址,2.找对象值的步骤:现在<em>常量池</em>中找--找不到就去堆里newString a="hello"; String b="h"+"ello";但是上面的输出结果是相等的
java的变量和常量以及常量池
首先变量名和常量名都是用户自行定义的标志符,遵循先定义后使用的原则,常量和变量的区别是常量之后会不会改变 变量 占据着内存的某一存储区域,该区域有自己的名称和数据类型,该区域的数据可以在同一类型范围内不断的变化,那么为什么定义变量,可以用来存放同一类型的变量可以重复使用,每一个变量都有他自己的作用范围,定义开始到定义它的代码块结束,同一代码块范围内不允许有多个相同名字的局部
java中的字符串常量池,栈和堆的概念
<em>问题</em>:String str = new String(“abc”),“abc”在内存中是怎么分配的?    答案是:堆,字符串常量区。 题目考查的为Java中的字符串<em>常量池</em>和JVM运行时数据区的相关概念。 &quot;abc&quot;为字面量对象,其存储在堆内存中。而字符串<em>常量池</em>则存储的是字符串对象的一个引用。   Java中的字符串<em>常量池</em> Java中字符串对象创建有两种形式,一种为字面量形式,如Stri...
文章热词 字节数组转string问题 双目视觉问题 特征点问题 相机标定问题 最优化问题
相关热词 c++问题 bootstrap 问题 c++a+b问题 合唱队形问题c# 区块链问题 学习python时遇到的问题
我们是很有底线的