String对象与内存控制

1.编译期和运行期的区别

 

/**
 * 编译时，和运行时的不同
 * 直接量是在编译就分配内存，而引用变量和方法调用创建的运行时才分配内存
 * @author Administrator
 *
 */
public class StringJoinTest {
	public static void main(String[] args) {
		String str1 = "hello的长度为：5";
		String str2 = "hello的长度为：" + "hello".length();
		int len = 5;
		String str3 = "hello的长度为：" + len;
		
		System.out.println("str1 == str2 : " + (str1 == str2));
		System.out.println("str1 == str3 : " + (str1 == str3));
		System.out.println("str3 == str3 : " + (str3 == str2));
	}
}

 输出结果：str1 == str2 : false
                  str1 == str3 : false
                  str3 == str3 : false

 

解释：== 判断的是对象在内存中位置是否相同，而equals判断的是存储内容是否相同。

2.String和StringBuilder的区别

    1）String代码

 

public class ImmutableString {
	public static void main(String[] args) {
		String str = "hello";
		System.out.println(System.identityHashCode(str));
		str = str + "java";
		System.out.println(System.identityHashCode(str));
		str = str + ", 111";
		System.out.println(System.identityHashCode(str));
	}
}

    结果：18306082
               9740137
               23965177
   解释：结果可看出str引用变量指向的内存是不同的，所以说String是不可变类，当使用String来拼接字符串时会造成内存溢出等问题。

    2）StringBuilder

 

 

public class MutableString {
	public static void main(String[] args) {
		StringBuilder str = new StringBuilder("hello ");
		System.out.println(str + " : " + System.identityHashCode(str));
		str.append("java ");
		System.out.println(str + " : " + System.identityHashCode(str));
		str.append(",111");
		System.out.println(str + " : " + System.identityHashCode(str));
	}
}	
	

    结果：hello  : 18306082
              hello java  : 18306082
              hello java ,111 : 18306082

    解释：StringBuilder操作字符串时引用变量指向的内存是相同的。此外StringBuilder是非线程安全的，而StringBuffer是线程安全的，所以StringBuilder的效率会比StringBuffer的高

 

2.new对象是我们经常使用的，可能我们很少在乎new出来的对象在内存中的占用问题，因为java给我们一个美丽的谎言--------内存自 动回收。但作为一名真正的开发者，我们应该尽量使开发出来的程序更高效，可以更充分利用有限的内存，更快地释放那些无用java对象所占用的内存，避免 java程序的内存泄漏。  

   1）强引用

        这是java程序中最常见的引用方式，程序创建一个对象，并把对象赋给一个引用变量，这个引用就是强引用。

public class StatusTranfer {
	public static void test(){
		String a = new String("java");
		a = new String("java2");
	}
	
	public static void main(String[] args) {
		test();
	}
}

   2)软引用

   

import java.lang.ref.SoftReference;

/**
 * 软引用：当系统内存足够时，它不会被系统回收，当系统内存不足时，会被系统回收
 * @author Administrator
 *
 */
public class SoftReferrenceTest {
	public static void main(String[] args) {
		//实例软引用
		SoftReference<Person>[] people = new SoftReference[100];
		for(int i 	= 0; i < people.length; i++){
			//通过软引用实例初始化对象
			people[i] = new SoftReference<Person>(new Person("名字" + i, i));
		}
		
		System.out.println(people[2].get());
		System.out.println(people[4].get());
		System.gc();
		System.runFinalization();
		
		System.out.println(people[2].get());
		System.out.println(people[4].get());
	}
}

class Person{
	String name;
	int age;
	public Person(String name, int age){
		this.name = name;
		this.age = age;
	}
	
	public String toString(){
		return "person[name=" + name + ", age=" + age + "]";
	}
}

    3）弱引用

import java.lang.ref.WeakReference;

/**
 * 弱引用：当系统回收时，被回收
 * @author Administrator
 *
 */
public class WeakReferrenceTest {
	public static void main(String[] args) {
		WeakReference<Person1>[] people = new WeakReference[100];
		for(int i 	= 0; i < people.length; i++){
			people[i] = new WeakReference<Person1>(new Person1("名字" + i, i));
		}
		
		System.out.println(people[2].get());
		System.out.println(people[4].get());
		System.gc();
		System.runFinalization();
		
		System.out.println(people[2].get());
		System.out.println(people[4].get());
	}
}

class Person1{
	String name;
	int age;
	public Person1(String name, int age){
		this.name = name;
		this.age = age;
	}
	
	public String toString(){
		return "person[name=" + name + ", age=" + age + "]";
	}
}