1）String.intern()，存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个 方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用， 如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用
- 由于 Java 6 中使用固定的内存大小（PermGen）因此不要使用 String.intern() 方法
- Java7 和 8 在堆内存中实现字符串池。这以为这字符串池的内存限制等于应用程序的内存限制。
- 在 Java 7 和 8 中使用 -XX:StringTableSize 来设置字符串池 Map 的大小。它是固定的，因为它使用 HashMap 实现。近似于你应用单独的字符串个数（你希望保留的）并且设置池的大小为最接近的质数并乘以 2 （减少碰撞的可能性）。它是的 String.intern 可以使用相同（固定）的时间并且在每次插入时消耗更小的内存(同样的任务，使用java WeakHashMap将消耗4-5倍的内存)。
- 在 Java 6 和 7（Java7u40以前） 中 -XX:StringTableSize 参数的值是 1009。Java7u40 以后这个值调整为 60013 （Java 8 中使用相同的值）
- 如果你不确定字符串池的用量，参考：-XX:+PrintStringTableStatistics JVM 参数，当你的应用挂掉时它告诉你字符串池的使用量信息。
2）public String subString（int beginIndex, int endIndex)当字符串很大时会发生内存泄漏，因为该方法返回的是new String（offset + beginIndex, endIndex - beginIndex, value），是一种以空间换时间的策略，浪费了内存空间，却提高了字符串的生成速度。
3）在性能敏感的系统中，StringTokenizer("abc;sdfdd;dfdfddffdsss",";")方法比str.split(";")方法更快，还可以用subString方法空间换时间会更快。
还有chatAt()方法比StartWith（String str）方法更快。
4）Java编译时，就会对字符串处理进行一定的优化，因此String不一定就比StringBuffer慢。
不考虑同步的情况下，StringBuilder比StringBuffer要快。容量参数，如StringBuffer sb = new StringBuffer(10000);效果会比较好，因为容量扩容时，需要进行数组复制。
5）遍历列表，经测试，对于ArrayList和LinkedList（LinkedList没有for循环操作），时间：foreach操作 > 迭代器 > for循环
6）native方法通常比一般的方法快，因为它直接调用操作系统本地链接库的API。
7）默认情况下，HashMap初始大小为16，负载因子为0.75。并且是无序的。
LinkedHashMap基于hash的快速元素插入，同时维护着元素插入集合时的先后顺序。遍历集合时，总是按照先进先出的顺序排序。
基于红黑树的实现，有着高效的基于元素key的排序算法。
8）优化集合访问代码：1.分离循环中被重复调用的代码2.省略相同的操作3.减少方法调用
9）程序中需要通过索引下表对List进行随机访问，尽量不哟个LinkedList，而ArrayList和Vector都是不错的选择，因为其实现了RandomAccess接口
10）慎用异常，尤其是在循环中用异常
11）复制数组中，尽量使用System.arraycopy(array, 0, arraydst, 0, size);比自己使用循环进行复制要快一个数量级。因为System.arraycopy(...)方法使用的是native函数，调用操作系统的API，所有快。
12）FileReader 和 FileWrite 的性能要优于直接使用FileInputStream和FileOutputStream。读取文件时，适当的使用缓存，可以提高系统的文件读写性能。
13）Object.clone()方法可以绕过对象构造函数，快速复制一个对象实例。由于不需要调用对象构造函数，因此，clone（）方法不会受到构造函数性能的影响，能够快速生成一个实例。但是默认情况下，clone（）方法生成的实例只是原对象的浅拷贝。若需要深拷贝，则需要实现Cloneable接口的JavaBean，重新实现clone（）方法。
14）若没有必要进行重载的必要时，将其声明为static，可以加速方法的调用。静态方法要明显快于实例方法。
15）某些情况下可以用数组形式来替换switch
16）一维数组代替二维数组
17）提取公共表达式
18）展开循环，即在循环中，可以多次多次的循环工作，减少循环的次数
19）布尔运算代替位运算；
字符串池是使用一个拥有固定容量的 HashMap 每个元素包含具有相同 hash 值的字符串列表。默认的池大小是 1009 (出现在上面提及的 bug 报告的源码中，在 Java7u40 中增加了)。你必须设置一个更大的 -XX:StringTalbeSize 值(相比较默认的 1009 ),如果你希望更多的使用 String.intern() -- 否则这个方法将很快递减到 0 （池大小）。
Java 8 中默认的池大小增加到 60013
Java 6 中的 String.intern()
在美好的过去所有共享的 String 对象都存储在 PermGen 中 -- 堆中固定大小的部分主要用于存储加载的类对象和字符串池。除了明确的共享字符串，PermGen 字符串池还包含所有程序中使用过的字符串（这里要注意是使用过的字符串，如果类或者方法从未加载或者被条用，在其中定义的任何常量都不会被加载）
Java 6 中字符串池的最大问题是它的位置 -- PermGen。PermGen 的大小是固定的并且在运行时是无法扩展的。你可以使用 -XX:MaxPermSize=N 配置来调整它的大小。据我了解，对于不同的平台默认的 PermGen 大小在 32M 到 96M 之间。你可以扩展它的大小，不过大小使用都是固定的。这个限制需要你在使用 String.intern 时需要非常小心 -- 你最好不要使用这个方法 intern 任何无法控制的用户输入。这是为什么在 JAVA6 中大部分使用手动管理 Map 来实现字符串池
Java 7 中的 String.intern()
字符串池的位置被调整到 heap 中了。这意味着你再也不会被固定的内存空间限制了。所有的字符串都保存在堆（heap）中同其他普通对象一样，这使得你在调优应用时仅需要调整堆大小。这 个改动使得我们有足够的理由让我们重新考虑在 Java 7 中使用 String.intern()。
Java堆和栈的区别(栈stack---堆heap )
总结在Java里面Heap和Stack分别存储数据的不同。
Heap(堆) | Stack(栈) | |
JVM中的功能 | 内存数据区 | 内存指令区 |
存储数据 | 对象实例(1) | 基本数据类型, 指令代码,常量,对象的引用地址(2) |
对象实例在heap中分配好以后，需要在stack中保存一个4字节的heap内存地址，用来定位该对象实例在heap中的位置，便于找到该对象实例。
函数方法属于指令.
"Java 的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。"
“栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。 ”
可见，垃圾回收GC是针对堆Heap的，而栈因为本身是FILO - first in, last out. 先进后出，能够自动释放。 这样就能明白到new创建的，都是放到堆Heap！
我们首先要搞清楚的是什么是数据以及什么是指令。然后要搞清楚对象的方法和对象的属性分别保存在哪里。
1）方法本身是指令的操作码部分，保存在Stack中；
2）方法内部变量作为指令的操作数部分，跟在指令的操作码之后，保存在Stack中（实际上是简单类型保存在Stack中，对象类型在Stack中保存地址，在Heap 中保存值）；上述的指令操作码和指令操作数构成了完整的Java 指令。
3）对象实例包括其属性值作为数据，保存在数据区Heap 中。
非静态的对象属性作为对象实例的一部分保存在Heap 中，而对象实例必须通过Stack中保存的地址指针才能访问到。因此能否访问到对象实例以及它的非静态属性值完全取决于能否获得对象实例在Stack中的地址指针。
非静态方法和静态方法的区别：
非静态方法有一个和静态方法很重大的不同：非静态方法有一个隐含的传入参数，该参数是JVM给它的，和我们怎么写代码无关，这个隐含的参数就是对象实例在Stack中的地址指针。因此非静态方法（在Stack中的指令代码）总是可以找到自己的专用数据（在Heap 中的对象属性值）。当然非静态方法也必须获得该隐含参数，因此非静态方法在调用前，必须先new一个对象实例，获得Stack中的地址指针，否则JVM将无法将隐含参数传给非静态方法。
静态方法无此隐含参数，因此也不需要new对象，只要class文件被ClassLoader load进入JVM的Stack，该静态方法即可被调用。当然此时静态方法是存取不到Heap 中的对象属性的。
总结一下该过程：当一个class文件被ClassLoader load进入JVM后，方法指令保存在Stack中，此时Heap 区没有数据。然后程序技术器开始执行指令，如果是静态方法，直接依次执行指令代码，当然此时指令代码是不能访问Heap 数据区的；如果是非静态方法，由于隐含参数没有值，会报错。因此在非静态方法执行前，要先new对象，在Heap 中分配数据，并把Stack中的地址指针交给非静态方法，这样程序技术器依次执行指令，而指令代码此时能够访问到Heap 数据区了。
静态属性和动态属性：
前面提到对象实例以及动态属性都是保存在Heap 中的，而Heap 必须通过Stack中的地址指针才能够被指令（类的方法）访问到。因此可以推断出：静态属性是保存在Stack中的，而不同于动态属性保存在Heap 中。正因为都是在Stack中，而Stack中指令和数据都是定长的，因此很容易算出偏移量，也因此不管什么指令（类的方法），都可以访问到类的静态属性。也正因为静态属性被保存在Stack中，所以具有了全局属性。
在JVM中，静态属性保存在Stack指令内存区，动态属性保存在Heap数据内存区。
栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
Java的堆是一个运行时数据区,类的对象从中分配空间。这些对象通过new、newarray、anewarray和 multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。
栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。
栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
int a = 3;
int b = 3；
编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。
这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。
要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。
1）String.intern()，存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个 方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用， 如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用
- 由于 Java 6 中使用固定的内存大小（PermGen）因此不要使用 String.intern() 方法
- Java7 和 8 在堆内存中实现字符串池。这以为这字符串池的内存限制等于应用程序的内存限制。
- 在 Java 7 和 8 中使用 -XX:StringTableSize 来设置字符串池 Map 的大小。它是固定的，因为它使用 HashMap 实现。近似于你应用单独的字符串个数（你希望保留的）并且设置池的大小为最接近的质数并乘以 2 （减少碰撞的可能性）。它是的 String.intern 可以使用相同（固定）的时间并且在每次插入时消耗更小的内存(同样的任务，使用java WeakHashMap将消耗4-5倍的内存)。
- 在 Java 6 和 7（Java7u40以前） 中 -XX:StringTableSize 参数的值是 1009。Java7u40 以后这个值调整为 60013 （Java 8 中使用相同的值）
- 如果你不确定字符串池的用量，参考：-XX:+PrintStringTableStatistics JVM 参数，当你的应用挂掉时它告诉你字符串池的使用量信息。
2）public String subString（int beginIndex, int endIndex)当字符串很大时会发生内存泄漏，因为该方法返回的是new String（offset + beginIndex, endIndex - beginIndex, value），是一种以空间换时间的策略，浪费了内存空间，却提高了字符串的生成速度。
3）在性能敏感的系统中，StringTokenizer("abc;sdfdd;dfdfddffdsss",";")方法比str.split(";")方法更快，还可以用subString方法空间换时间会更快。
还有chatAt()方法比StartWith（String str）方法更快。
4）Java编译时，就会对字符串处理进行一定的优化，因此String不一定就比StringBuffer慢。
不考虑同步的情况下，StringBuilder比StringBuffer要快。容量参数，如StringBuffer sb = new StringBuffer(10000);效果会比较好，因为容量扩容时，需要进行数组复制。
5）遍历列表，经测试，对于ArrayList和LinkedList（LinkedList没有for循环操作），时间：foreach操作 > 迭代器 > for循环
6）native方法通常比一般的方法快，因为它直接调用操作系统本地链接库的API。
7）默认情况下，HashMap初始大小为16，负载因子为0.75。并且是无序的。
LinkedHashMap基于hash的快速元素插入，同时维护着元素插入集合时的先后顺序。遍历集合时，总是按照先进先出的顺序排序。
基于红黑树的实现，有着高效的基于元素key的排序算法。
8）优化集合访问代码：1.分离循环中被重复调用的代码2.省略相同的操作3.减少方法调用
9）程序中需要通过索引下表对List进行随机访问，尽量不哟个LinkedList，而ArrayList和Vector都是不错的选择，因为其实现了RandomAccess接口
10）慎用异常，尤其是在循环中用异常
11）复制数组中，尽量使用System.arraycopy(array, 0, arraydst, 0, size);比自己使用循环进行复制要快一个数量级。因为System.arraycopy(...)方法使用的是native函数，调用操作系统的API，所有快。
12）FileReader 和 FileWrite 的性能要优于直接使用FileInputStream和FileOutputStream。读取文件时，适当的使用缓存，可以提高系统的文件读写性能。
13）Object.clone()方法可以绕过对象构造函数，快速复制一个对象实例。由于不需要调用对象构造函数，因此，clone（）方法不会受到构造函数性能的影响，能够快速生成一个实例。但是默认情况下，clone（）方法生成的实例只是原对象的浅拷贝。若需要深拷贝，则需要实现Cloneable接口的JavaBean，重新实现clone（）方法。
14）若没有必要进行重载的必要时，将其声明为static，可以加速方法的调用。静态方法要明显快于实例方法。
15）某些情况下可以用数组形式来替换switch
16）一维数组代替二维数组
17）提取公共表达式
18）展开循环，即在循环中，可以多次多次的循环工作，减少循环的次数
19）布尔运算代替位运算；
字符串池是使用一个拥有固定容量的 HashMap 每个元素包含具有相同 hash 值的字符串列表。默认的池大小是 1009 (出现在上面提及的 bug 报告的源码中，在 Java7u40 中增加了)。你必须设置一个更大的 -XX:StringTalbeSize 值(相比较默认的 1009 ),如果你希望更多的使用 String.intern() -- 否则这个方法将很快递减到 0 （池大小）。
Java 8 中默认的池大小增加到 60013
Java 6 中的 String.intern()
在美好的过去所有共享的 String 对象都存储在 PermGen 中 -- 堆中固定大小的部分主要用于存储加载的类对象和字符串池。除了明确的共享字符串，PermGen 字符串池还包含所有程序中使用过的字符串（这里要注意是使用过的字符串，如果类或者方法从未加载或者被条用，在其中定义的任何常量都不会被加载）
Java 6 中字符串池的最大问题是它的位置 -- PermGen。PermGen 的大小是固定的并且在运行时是无法扩展的。你可以使用 -XX:MaxPermSize=N 配置来调整它的大小。据我了解，对于不同的平台默认的 PermGen 大小在 32M 到 96M 之间。你可以扩展它的大小，不过大小使用都是固定的。这个限制需要你在使用 String.intern 时需要非常小心 -- 你最好不要使用这个方法 intern 任何无法控制的用户输入。这是为什么在 JAVA6 中大部分使用手动管理 Map 来实现字符串池
Java 7 中的 String.intern()
Java 7 中 Oracle 的工程师对字符串池的逻辑做了很大的改变 -- 字符串池的位置被调整到 heap 中了。这意味着你再也不会被固定的内存空间限制了。所有的字符串都保存在堆（heap）中同其他普通对象一样，这使得你在调优应用时仅需要调整堆大小。这 个改动使得我们有足够的理由让我们重新考虑在 Java 7 中使用 String.intern()。
Java堆和栈的区别(栈stack---堆heap )
总结在Java里面Heap和Stack分别存储数据的不同。
Heap(堆) | Stack(栈) | |
JVM中的功能 | 内存数据区 | 内存指令区 |
存储数据 | 对象实例(1) | 基本数据类型, 指令代码,常量,对象的引用地址(2) |
对象实例在heap中分配好以后，需要在stack中保存一个4字节的heap内存地址，用来定位该对象实例在heap中的位置，便于找到该对象实例。
函数方法属于指令.
"Java 的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。"
“栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。 ”
可见，垃圾回收GC是针对堆Heap的，而栈因为本身是FILO - first in, last out. 先进后出，能够自动释放。 这样就能明白到new创建的，都是放到堆Heap！
我们首先要搞清楚的是什么是数据以及什么是指令。然后要搞清楚对象的方法和对象的属性分别保存在哪里。
1）方法本身是指令的操作码部分，保存在Stack中；
2）方法内部变量作为指令的操作数部分，跟在指令的操作码之后，保存在Stack中（实际上是简单类型保存在Stack中，对象类型在Stack中保存地址，在Heap 中保存值）；上述的指令操作码和指令操作数构成了完整的Java 指令。
3）对象实例包括其属性值作为数据，保存在数据区Heap 中。
非静态的对象属性作为对象实例的一部分保存在Heap 中，而对象实例必须通过Stack中保存的地址指针才能访问到。因此能否访问到对象实例以及它的非静态属性值完全取决于能否获得对象实例在Stack中的地址指针。
非静态方法和静态方法的区别：
非静态方法有一个和静态方法很重大的不同：非静态方法有一个隐含的传入参数，该参数是JVM给它的，和我们怎么写代码无关，这个隐含的参数就是对象实例在Stack中的地址指针。因此非静态方法（在Stack中的指令代码）总是可以找到自己的专用数据（在Heap 中的对象属性值）。当然非静态方法也必须获得该隐含参数，因此非静态方法在调用前，必须先new一个对象实例，获得Stack中的地址指针，否则JVM将无法将隐含参数传给非静态方法。
静态方法无此隐含参数，因此也不需要new对象，只要class文件被ClassLoader load进入JVM的Stack，该静态方法即可被调用。当然此时静态方法是存取不到Heap 中的对象属性的。
总结一下该过程：当一个class文件被ClassLoader load进入JVM后，方法指令保存在Stack中，此时Heap 区没有数据。然后程序技术器开始执行指令，如果是静态方法，直接依次执行指令代码，当然此时指令代码是不能访问Heap 数据区的；如果是非静态方法，由于隐含参数没有值，会报错。因此在非静态方法执行前，要先new对象，在Heap 中分配数据，并把Stack中的地址指针交给非静态方法，这样程序技术器依次执行指令，而指令代码此时能够访问到Heap 数据区了。
静态属性和动态属性：
前面提到对象实例以及动态属性都是保存在Heap 中的，而Heap 必须通过Stack中的地址指针才能够被指令（类的方法）访问到。因此可以推断出：静态属性是保存在Stack中的，而不同于动态属性保存在Heap 中。正因为都是在Stack中，而Stack中指令和数据都是定长的，因此很容易算出偏移量，也因此不管什么指令（类的方法），都可以访问到类的静态属性。也正因为静态属性被保存在Stack中，所以具有了全局属性。
在JVM中，静态属性保存在Stack指令内存区，动态属性保存在Heap数据内存区。
栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
Java的堆是一个运行时数据区,类的对象从中分配空间。这些对象通过new、newarray、anewarray和 multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。
栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。
栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
int a = 3;
int b = 3；
编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。
这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。
要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。
