java如何定义一个字符栈_java基础知识详解

一、String

楼主有个习惯，经常喜欢先看后练，后面将自己不懂的东西，单独提出来进行详细研究；

String类，楼主看书的时候，只有一个模糊的概念。比如，它属于终结类，无法被继承；同时，它不属于一个基础数据类型；但是其它的，就一知半解了，故决定将其源码拿出来，仔细揣摩一下；

要了解String类，首先了解一下java的内存结构；

java的内存结构：

java的内存结构.png

Java中的内存分配：

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对数据进行了不同空间的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

具体划分为如下5个内存空间：(非常重要)

栈：存放局部变量

堆：存放所有new出来的东西

方法区：被虚拟机加载的类信息、常量、静态常量等。

本地方法栈

程序计数器(和系统相关，图片未给出)

1、程序计数器:

每个线程拥有一个PC寄存器

在线程创建时创建

指向下一条指令的地址

执行本地方法时，PC的值为undefined

2、方法区:

保存装载的类信息

类型的常量池

字段，方法信息

方法字节码

通常和永久区(Perm)关联在一起

3、堆内存:

和程序开发密切相关

应用系统对象都保存在Java堆中

所有线程共享Java堆

对分代GC来说，堆也是分代的

GC管理的主要区域

现在的GC基本都采用分代收集算法，如果是分代的，那么堆也是分代的。如果堆是分代的，那堆空间应该是下面这个样子：

4、栈内存：

线程私有，生命周期和线程相同

栈由一系列帧组成(因此Java栈也叫做帧栈)

帧保存一个方法的局部变量、操作数栈、常量池指针

每一次方法调用创建一个帧，并压栈

解释：

Java虚拟机栈描述的是Java方法执行的内存模型：每个方法被调用的时候都会创建一个栈帧，用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程就对应着一个栈帧在虚拟机中从入栈到出栈的过程。

在Java虚拟机规范中，对这个区域规定了两种异常情况：

(1)如果线程请求的栈深度太深，超出了虚拟机所允许的深度，就会出现StackOverFlowError(比如无限递归。因为每一层栈帧都占用一定空间，而 Xss 规定了栈的最大空间，超出这个值就会报错)

(2)虚拟机栈可以动态扩展，如果扩展到无法申请足够的内存空间，会出现OOM

** 常量池 **

Java中的常量池，实际上分为两种形态：静态常量池和运行时常量池。

所谓静态常量池，即*.class文件中的常量池，class文件中的常量池不仅仅包含字符串(数字)字面量，还包含类、方法的信息，占用class文件绝大部分空间。

而运行时常量池，则是jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池。

package StringBase;

public class Base {

public static void main(String[] args){

String a="abc";

String c=new String("abc");

// char[] s={'a','b','c'};

//String a=new String(s);

String b="a"+"b"+"c";

System.out.println(a==b);

System.out.println(c==b);String s1 = "Hello";

String s2 = "Hello";

String s3 = "Hel" + "lo";

String s4 = "Hel" + new String("lo");

String s5 = new String("Hello");

String s6 = s5.intern();

String s7 = "H";

String s8 = "ello";

String s9 = s7 + s8;

System.out.println(s1 == s2); // true

System.out.println(s1 == s3); // true

System.out.println(s1 == s4); // false

System.out.println(s1 == s9); // false

System.out.println(s4 == s5); // false

System.out.println(s1 == s6); // true

}

}

首先说明一点，在java 中，直接使用==操作符，比较的是两个字符串的引用地址，并不是比较内容，比较内容请用String.equals()。

s1 == s2这个非常好理解，s1、s2在赋值时，均使用的字符串字面量，说白话点，就是直接把字符串写死，在编译期间，这种字面量会直接放入class文件的常量池中，从而实现复用，载入运行时常量池后，s1、s2指向的是同一个内存地址，所以相等。

s1 == s3这个地方有个坑，s3虽然是动态拼接出来的字符串，但是所有参与拼接的部分都是已知的字面量，在编译期间，这种拼接会被优化，编译器直接帮你拼好，因此String s3 = "Hel" + "lo";在class文件中被优化成String s3 = "Hello";，所以s1 == s3成立。

s1 == s4当然不相等，s4虽然也是拼接出来的，但new String("lo")这部分不是已知字面量，是一个不可预料的部分，编译器不会优化，必须等到运行时才可以确定结果，结合字符串不变定理，鬼知道s4被分配到哪去了，所以地址肯定不同。

必须要关注编译期的行为，才能更好的理解常量池。

运行时常量池中的常量，基本来源于各个class文件中的常量池。

程序运行时，除非手动向常量池中添加常量(比如调用intern方法)，否则jvm不会自动添加常量到常量池。

以上所讲仅涉及字符串常量池，实际上还有整型常量池、浮点型常量池等等，但都大同小异，只不过数值类型的常量池不可以手动添加常量，程序启动时常量池中的常量就已经确定了，比如整型常量池中的常量范围：-128~127，只有这个范围的数字可以用到常量池。

* The {@code String} class represents character strings. All

* string literals in Java programs, such as {@code "abc"}, are

* implemented as instances of this class.

String 字符串，其中所有的字符均为String类；

package StringBase;

public class Base {

public static void main(String[] args){

String a="ABC";

System.out.println(a);

System.out.println("A"instanceof String);

String b=new String("ABC");

String c="ABC";

System.out.println(a==b);

System.out.println( b==c);

System.out.println(a==c);

}

}

// output

ABC

true

false

false

true

/**

* Strings are constant; their values cannot be changed after they

* are created. String buffers support mutable strings.

* Because String objects are immutable they can be shared.

*/

public final class String

implements java.io.Serializable, Comparable, CharSequence {

private final byte[] value;

private final byte coder;

private int hash; // Default to 0

....

private static final ObjectStreamField[] serialPersistentFields =

new ObjectStreamField[0];

....

从定义来看:

1、String为final 类型，故String 无法被继承，成员变量和成员方法均为 final 类型，

2、String 类继承三个接口：java.io.Serializable, Comparable, CharSequence

3、String 字符串是常量，其值在实例创建后就不能被修改，但字符串缓冲区支持可变的字符串，因为缓冲区里面的不可变字符串对象们可以被共享.

4、 CharSequence接口有length()，charAt(int index),subSequence(int start,int end)方法。

public static void main(String[] args) {

/**

* 情景一：字符串池

* JAVA虚拟机(JVM)中存在着一个字符串池，其中保存着很多String对象;

* 并且可以被共享使用，因此它提高了效率。

* 由于String类是final的，它的值一经创建就不可改变。

* 字符串池由String类维护，我们可以调用intern()方法来访问字符串池。

*/

String s1 = "abc";

//↑ 在字符串池创建了一个对象

String s2 = "abc";

//↑ 字符串pool已经存在对象“abc”(共享),所以创建0个对象，累计创建一个对象

System.out.println("s1 == s2 : "+(s1==s2));

//↑ true 指向同一个对象，

System.out.println("s1.equals(s2) : " + (s1.equals(s2)));

//↑ true 值相等

//↑------------------------------------------------------over

/**

* 情景二：关于new String("")

*

*/

String s3 = new String("abc");

//↑ 创建了两个对象，一个存放在字符串池中，一个存在与堆区中；

//↑ 还有一个对象引用s3存放在栈中

String s4 = new String("abc");

//↑ 字符串池中已经存在“abc”对象，所以只在堆中创建了一个对象

System.out.println("s3 == s4 : "+(s3==s4));

//↑false s3和s4栈区的地址不同，指向堆区的不同地址；

System.out.println("s3.equals(s4) : "+(s3.equals(s4)));

//↑true s3和s4的值相同

System.out.println("s1 == s3 : "+(s1==s3));

//↑false 存放的地区多不同，一个栈区，一个堆区

System.out.println("s1.equals(s3) : "+(s1.equals(s3)));

//↑true 值相同

//↑------------------------------------------------------over

/**

* 情景三：

* 由于常量的值在编译的时候就被确定(优化)了。

* 在这里，"ab"和"cd"都是常量，因此变量str3的值在编译时就可以确定。

* 这行代码编译后的效果等同于： String str3 = "abcd";

*/

String str1 = "ab" + "cd"; //1个对象

String str11 = "abcd";

System.out.println("str1 = str11 : "+ (str1 == str11));

//↑------------------------------------------------------over

/**

* 情景四：

* 局部变量str2,str3存储的是存储两个拘留字符串对象(intern字符串对象)的地址。

*

* 第三行代码原理(str2+str3)：

* 运行期JVM首先会在堆中创建一个StringBuilder类，

* 同时用str2指向的拘留字符串对象完成初始化，

* 然后调用append方法完成对str3所指向的拘留字符串的合并，

* 接着调用StringBuilder的toString()方法在堆中创建一个String对象，

* 最后将刚生成的String对象的堆地址存放在局部变量str3中。

*

* 而str5存储的是字符串池中"abcd"所对应的拘留字符串对象的地址。

* str4与str5地址当然不一样了。

*

* 内存中实际上有五个字符串对象：

* 三个拘留字符串对象、一个String对象和一个StringBuilder对象。

*/

String str2 = "ab"; //1个对象

String str3 = "cd"; //1个对象

String str4 = str2+str3;

String str5 = "abcd";

System.out.println("str4 = str5 : " + (str4==str5)); // false

//↑------------------------------------------------------over

/**

* 情景五：

* JAVA编译器对string + 基本类型/常量 是当成常量表达式直接求值来优化的。

* 运行期的两个string相加，会产生新的对象的，存储在堆(heap)中

*/

String str6 = "b";

String str7 = "a" + str6;

String str67 = "ab";

System.out.println("str7 = str67 : "+ (str7 == str67));

//↑str6为变量，在运行期才会被解析。

final String str8 = "b";

String str9 = "a" + str8;

String str89 = "ab";

System.out.println("str9 = str89 : "+ (str9 == str89));

//↑str8为常量变量，编译期会被优化

//↑------------------------------------------------------over

}

/** The value is used for character storage. */

private final byte value[];

/** Cache the hash code for the string */

private int hash; // Default to 0

/** use serialVersionUID from JDK 1.0.2 for interoperability */

private static final long serialVersionUID = -6849794470754667710L;

String类中包含一个不可变的 byte 数组用来存放字符串，一个int型的变量hash用来存放缓存字符串的哈希值，默认为0。

1、所有String实例，初始化后，其值是不可变的，变得只能说引用的对象或者说是指针的指向；

2、String 为提供set类方法，故一旦初始化其值无法改变；

String的构造方法

空的构造方法

public String() {

this.value = "".value;

this.coder = "".coder;

}

public static void main(String[] args){

String a=new String();

a="1234";

}

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

将String 对象复制给String

public String(String original) {

this.value = original.value;

this.coder = original.coder;

this.hash = original.hash;

}

public String(char value[]) {

this(value, 0, value.length, null);

}

public static void main(String[] args){

String a="123";

String b=new String("123");

char[] c={'1','2','3'};

String d=new String(c);

}