【JAVA】java数据存储-基础类型，对象和字符串

总所周知，java是一种面向对象的程序设计语言。在java里，一切都被视为对象，因此可以采用单一固定的语法。尽管一切都看作对象，但是操纵的标识符实际上是对象的一个“引用”，这个引用指向数据实际存放的地址。

而我们的数据被存储到什么地方呢？特别是内存是怎么分配的呢？我们有个不同的地方可以存储数据（以下内容摘自《java编程思想》：

1. 寄存器。这里是最快的存储区，因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量是极其有限的，所以寄存器需要根据需求进行分配。我们不能直接控制，也不能在程序中感受到寄存器的任何存在迹象。

2. 堆栈。位于通用RAM（随机访问存储器）中，但通过堆栈指针可以从处理器那里直接获得支持。堆栈指针若乡下移动，则分配新的内存，若向上移动则释放哪些内存。这是一种快速有效的分配存储方法，仅次于寄存器。创建程序时，java系统必须知道在堆栈内所有项的确切的生命周期，以便上下移动堆栈指针。这一约束限制了程序的灵活性，所以虽然某些java数据存储于堆栈中，特别是对象引用，但是java对象并不存储其中。

3. 堆。一种通用的内存池（也位于RAM区），用于存放所有的java对象。堆不同于堆栈的好处是，编译器不需要知道存储的数据在堆里存活多长时间。因此，在堆里分配存储会有很大的灵活性。当需要一个对象时，只需用new写一行简单的代码。当执行这行代码时，会自动在堆里进行存储分配。当然为这种灵活性必须付出相应代价：用堆进行存储分配和清理可能会比用堆栈进行存储分配需要更多的时间。

4. 常量存储。常量值通常直接存放在程序代码内部，这样做是安全的，因为它们永远不会被改变。有时，在嵌入式系统中，常量本身会和其他部分分隔开，所以这种情况下，可以选择将其存放在ROM（只读存储器)中。

5. 非RAM存储器。如果数据完全存活于程序之外，那么它可以不受程序的任何控制，在程序没有运行时也可以存在。其中两个基本的例子是流对象和持久化对象。在流对象中，对象转化成字节流，通常被发送给另外一台机器。在“持久化对象”中，对象呗存放于磁盘上，因此即使程序终止，它们仍然可以保持自己的状态。这种存储方式的技巧在于：把对象转化成可以存放的在其他媒介上的事务，在需要时，可恢复成常规的、基于RAM的对象。java提供了对轻量级持久化的支持。

了解了数据存放的地方，我们来看看各个类型的数据都存放在哪里：

1. 基本类型。

java的基本类型有boolean, char, byte,short,int,long,float,double,void。

一般情况下，我们从上面的描述里已经可以了解到，对于java的对象来说，我们在堆栈中存放的实际上是对象的引用，而对象本体（也就是值）是被存放在堆里的，我们通过new()，在堆里存储一个对象，然后把这个对象的引用放到堆栈中。

但是对于基本类型来说，他们是需要特殊对待的，因为他们是在是太小了，太简单，这样的变量存在堆里，往往不是特别有效。因此对于这些类型来说，java采取和C与C++相同的方法，也就是不用new来创建变量，而是创建一个并非是引用的“自动”变量。这个变量直接存储“值”，并放置在堆栈中，而不是堆中，这样会更加高效。

但是这种情况仅当数值型是在128以下的时候，因为128以上的数据就会被存放到堆中。

如下示例：

		Integer num1 = 127;
		Integer num2 = 127;
		Integer num3 = 128;
		Integer num4 = 128;

		System.out.println(num1 == num2);
		System.out.println(num3 == num4);
		

返回值为：

true

false

因为128以下的数的值会直接存放在堆栈里，这样我们对比堆栈里存放的值的时候，自然是相等的。

到了128，8位二进制无法保存，那么这个值会被存放到堆中。堆中数据会对应不同的地址，在堆栈中存放的引用不同，自然也就不相等。

2. 对象。

我们从在上面已经说过了，对象在通过new 创建的时候，是在堆中创建了一个对象，并把这个对象的应用存放在堆栈中，我们使用的标识符实际上是堆栈中的这个引用，也就是，当我们用一个对象a给另一个对象赋值b的时候，是将保存在堆栈中的引用赋值给了对象b，当我们操作对象b的值的时候，实际上是在操作这个引用对应的堆中存储的值。因为a和b的堆栈中保存的实际上是一个引用，所以a和b的值都发生了变化，如下：

public class StringTest {
	
	public class Person {
		private String name;
		public Person(String name) {
			this.name = name;
		}
		
		public String getName() {
			return name;
		}

		
		public void setName(String name) {
			this.name = name;
		}
	}

	public static void main(String[] args) {
		Person a = new StringTest().new Person("a");
		Person b = a;
//		b = new StringTest().new Person("b");
		b.setName("b");
		System.out.println("a name is "+a.getName());
		System.out.println("b name is "+b.getName());
		

	}

}

这块代码的结果是：

a name is b

b name is b

a对象和b对象中name的值同时发生了变化，因为a和b虽在堆栈中是两个不同的变量，但是他们存储的引用是指向同一个堆数据的。

但是如果是这样对b做操作，结果就完全不同了：

public class StringTest {
	
	public class Person {
		private String name;
		public Person(String name) {
			this.name = name;
		}
		
		public String getName() {
			return name;
		}

		
		public void setName(String name) {
			this.name = name;
		}
	}

	public static void main(String[] args) {
		Person a = new StringTest().new Person("a");
		Person b = a;
		b = new StringTest().new Person("b");
//		b.setName("b");
		System.out.println("a name is "+a.getName());
		System.out.println("b name is "+b.getName());
		

	}

}

使用new来对b赋值，就等于是在堆中新开了一块存储空间来存放这个新的对象，并把这个新对象的引用赋值给b在堆栈中的记录，但是a还是用的之前的对象的引用，此时b和a指向的不是同一个对象了，所以结果自然是：

a name is a

b name is b

b是b，a是a。

 

3. String 型。

我单独把String型拿出来说，是因为我认为String型是一个特别的类型，它既不像基本类型那样直接把值存在堆栈里，又不像对象那样可以对堆中的值进行修改。

我们要明确一点，对String的操作永远都是生成一个新的String，而不是对它进行修改。

而对String赋值其实有两种方法，一种是直接等于赋值一个值，另一种是new一个String对象，两种方式是不同的。

按我的理解，第一种直接赋值一个值这个是先会查找堆中是否存放了相同的值，如果有，则把对应的引用赋值给这个String在堆栈中的对象，如果没有则新开辟一个空间存放该值，并把引用传递给变量。也就是如果连续赋值两个变量，那么他们的引用实际上是同一个。同样的String 对象赋值成同一个感觉是java对String 的特殊处理，上面提到的Integer就没有这种功能。

第二种，就是不会排查堆中是否有相同的值，直接开辟一个新空间存放对应的值。也就是连续new两次相同的字符串，实际上他们的引用并不是同一个。

证实代码如下：

package com.example.demo;

public class StringTest {
	
	public class Person {
		private String name;
		public Person(String name) {
			this.name = name;
		}
		
		public String getName() {
			return name;
		}

		
		public void setName(String name) {
			this.name = name;
		}
	}

	public static void main(String[] args) {
		
		String str1 = "123";
		String str2 = "123";
		String str3 = new String("123");
		String str4 = new String("123");
		System.out.println(str1 == str2);
		System.out.println(str2 == str3);
		System.out.println(str3 == str4);
		
//		

	}

}

返回值是：

true

false

false

理由就如同上面解释的那样。

而因为String型是只能生成新的String型，而不能被修改的，所以我们每次对String进行修改，就是更换String标识符对应的引用。

所以我们对String型进行传递的时候从概念上看是引用传递，但是实际效果更接近值传递，因为对新的String进行操作的时候，老的String并不会受到影响。如下：

	public static void main(String[] args) {

		String str1 = new String("123");
		String str2 = str1;
		System.out.println(str1 == str2);
		str2 = str2+"hello";
		System.out.println(str1 == str2);

		System.out.println(str1);
		System.out.println(str2);
	}

返回值为：

true

false

123

123hello

str2对应的应用在修改字符串后发生了变化，虽然String互相赋值确实赋值的是引用，但是相当于是值传递了。