java编译中提升性能的小技巧
Java中代码优化的几种方法
Java中代码优化的几种方法Java中代码优化是提高程序性能和效率的关键。
在开发过程中，大部分程序员都会遇到性能瓶颈或效率低下的情况。
为了解决这些问题，我们需要对代码进行优化。
第一种方法是使用合适的数据结构。
在Java中，数据结构的选择直接影响程序的性能。
比如，使用ArrayList代替LinkedList可以提高随机访问元素的效率，而使用HashMap代替TreeMap可以提高插入和查找的效率。
第二种方法是避免重复计算。
在一些场景中，我们可能会多次计算相同的值。
为了提高效率，我们可以使用缓存技术，将计算结果缓存起来，下次需要的时候直接使用。
这样可以减少计算的次数，提高程序的性能。
第三种方法是减少对象的创建。
在Java中，对象的创建和销毁是比较耗时的操作。
为了提高程序的效率，我们可以尽量减少对象的创建次数。
比如，可以使用对象池来重复利用对象，避免频繁的创建和销毁。
第四种方法是使用适当的算法和数据结构。
在某些情况下，算法的选择直接影响程序的性能。
我们可以使用时间复杂度较低的算法，并选择合适的数据结构来提高程序的效率。
比如，使用快速排序而不是冒泡排序，可以大大提高排序的效率。
第五种方法是使用合适的编程技巧。
在编写代码时，我们可以使用一些常用的编程技巧来提高程序的性能。
比如，使用位运算来替代乘法和除法可以提高计算的效率，使用按位与运算来判断奇偶数可以提高程序的执行速度。
总结起来，Java中代码优化可以通过使用合适的数据结构、避免重复计算、减少对象的创建、使用适当的算法和数据结构，以及使用合适的编程技巧来实现。
通过优化代码，我们可以提高程序的性能和效率，提升用户体验。
在实际开发中，我们需要根据具体情况选择合适的优化方法，以达到最佳的效果。
Java性能调优技巧提升程序运行效率的方法
Java性能调优技巧提升程序运行效率的方法在软件开发领域中，性能调优是一项至关重要的工作。
对于使用Java编程语言开发的应用程序来说，性能调优尤为重要。
优化程序的性能可以加快程序的运行速度、提升用户体验，并节省计算资源。
本文将介绍一些Java性能调优的技巧，帮助提升程序的运行效率。
1. 使用合适的数据结构和算法在编写程序时，选取合适的数据结构和算法是至关重要的。
不同的数据结构和算法在处理同一问题时可能会有不同的性能表现。
因此，程序员应该了解各种数据结构和算法的特点，并选择最适合特定场景的实现方式，以提升程序的性能。
比如，对于需要频繁插入和删除元素的场景，选择链表可能比选择数组更加高效。
2. 减少对象的创建在Java中，对象的创建和销毁是非常消耗资源的操作。
因此，减少对象的创建可以有效提高程序的性能。
可以通过对象池技术或者缓存重用对象，避免频繁地创建新的对象。
另外，在循环中避免在每次迭代中创建新的对象，可以通过重复使用对象来提高性能。
3. 使用StringBuilder代替String在Java中，String类型是不可变的，每次对String进行拼接、修改等操作时，都会创建新的String对象，导致额外的内存开销。
为了避免这种情况，可以使用StringBuilder类来处理字符串的拼接操作。
StringBuilder类是可变的，并且性能更好，因为它不需要每次都创建新的对象。
4. 使用局部变量和常量在编写Java程序时，尽可能使用局部变量和常量。
局部变量的作用域仅限于方法体或代码块，不需要额外的内存空间来存储，因此比全局变量更加高效。
常量在编译时会被替换为实际的值，减少了运行时的开销。
5. 避免使用同步关键字在多线程编程中，使用同步关键字来保证线程安全是必要的。
然而，同步关键字会带来一定的性能开销。
如果某个代码块并不涉及共享资源的读写，可以避免使用同步关键字，以减少性能开销。
可以考虑使用其他线程安全的数据结构或者使用锁机制来代替同步关键字。
JAVA提高代码效率的方法
JAVA提高代码效率的方法Java是一种高性能语言，但是在编写代码时，我们仍然可以使用一些技巧来提高代码效率。
以下是一些提高Java代码效率的方法：1.使用合适的数据结构：选择正确的数据结构可以显著提高代码效率。
例如，如果需要频繁地进行插入和删除操作，使用链表比使用数组更高效。
如果需要快速访问元素，使用哈希表或树结构。
2.减少循环嵌套：嵌套循环是代码效率低下的一个常见原因。
尽量避免多层嵌套的循环，并考虑使用更高效的算法来处理问题。
3. 使用StringBuilder代替String拼接：在Java中，String对象是不可变的，每次对字符串进行拼接操作都会创建一个新的String对象，这会导致大量的内存分配和垃圾回收。
使用StringBuilder可以避免这个问题，并显著提高字符串拼接的效率。
4.使用局部变量：在循环中，将需要频繁访问的对象保存为局部变量可以减少访问成员变量的开销。
这是因为局部变量存储在栈中，而成员变量存储在堆中。
5. 缓存计算结果：对于一些需要重复计算的结果，可以将其缓存起来以避免重复计算。
这可以通过使用HashMap或其他缓存机制来实现。
6.懒加载：延迟加载是一种在需要时才创建对象的技术。
这可以减少内存的使用和对象的创建时间，并提高代码的效率。
7. 使用并发集合：当多个线程同时访问和修改集合对象时，使用并发集合（如ConcurrentHashMap、CopyOnWriteArrayList等）可以提高代码效率和线程安全性。
8. 使用原生数据类型：原生数据类型（如int、float、long等）在处理大规模数据时比对象类型更高效。
避免将原生类型包装为对象类型，尽量使用原生类型进行计算。
9.避免使用过多的异常处理：异常处理是一种开销较高的操作。
在一些性能要求较高的场景中，尽量避免频繁抛出和捕获异常。
10.减少输入输出：输入输出（IO）是代码效率的一个瓶颈。
可以使用批量读写、缓冲流等技术来减少IO操作的次数。
编程技巧提高代码性能的10个技巧
编程技巧提高代码性能的10个技巧代码性能对于程序的运行效率和用户体验至关重要。
通过一些简单的技巧和方法，可以有效提高代码的性能。
下面是提高代码性能的10个技巧：1.使用合适的数据结构：选择合适的数据结构对于代码的性能至关重要。
例如，当需要频繁插入和删除元素时，使用链表而不是数组可以提高性能。
2.减少函数调用：函数调用会产生额外的开销，因此减少函数调用可以提高代码性能。
可以将一些简单的操作内联到调用的地方，或使用递归替代迭代。
3.避免不必要的循环：避免不必要的循环可以减少代码的执行时间。
可以通过合理的条件判断或使用缓存结果来避免重复的计算。
4.减少内存分配：频繁的内存分配和释放会导致内存碎片化和性能下降。
可以尽量使用栈而不是堆来分配内存，或者使用对象池和缓存来重复使用已分配的内存。
5.使用合适的算法和数据结构：选择合适的算法和数据结构可以大大提高代码的性能。
例如，对于查找和排序操作，使用哈希表和二叉树比线性和冒泡排序更高效。
6.并行化和异步化：利用并行化和异步化可以提高代码的并发性和响应性。
可以将任务分解为多个子任务，并使用多线程或异步编程来并行执行。
7.懒加载和延迟加载：使用懒加载和延迟加载可以提高程序的启动和加载性能。
只有在需要时才加载或初始化对象、模块或资源。
8.数据预处理和缓存：对于一些长时间不变的数据，可以预先进行处理或缓存，避免重复的计算或读取操作，从而提高代码性能。
9.优化关键路径：通过分析程序的关键路径，优化其中的性能瓶颈可以获得显著的性能提升。
可以使用性能分析工具来找出瓶颈并优化代码。
10.减少资源的使用：减少资源的使用可以提高代码的性能和资源利用率。
可以避免内存泄露、关闭不必要的连接、释放文件句柄等。
通过应用上述技巧，可以有效提高代码的性能。
然而，要注意在优化代码性能时要权衡代码的易读性和可维护性，避免过度优化和牺牲其他方面的需求。
编程技巧：提高代码性能的十个实用技巧
编程技巧：提高代码性能的十个实用技巧1. 运行时间复杂度分析在编写代码之前，对算法的运行时间复杂度进行分析是非常重要的。
尽量避免使用具有高时间复杂度的算法，例如嵌套循环和递归调用。
使用效率更高的数据结构和算法可以极大地提高代码的性能。
2. 减少内存使用注意代码中的内存使用情况，避免不必要的变量和数据结构占用过多内存。
及时释放不再需要的资源，比如关闭文件句柄和释放动态分配的内存。
3. 优化循环循环是程序中常见的操作，但如果处理不当可能会降低代码性能。
尽量减少循环次数和循环体中运算量较大的操作，通过合理地设计算法或者采用并行计算技术来提高效率。
4. 使用合适的数据结构选择合适的数据结构可以显著影响程序性能。
根据具体问题需求选择数组、链表、栈、队列、哈希表等数据结构，并掌握它们各自特点和适用场景。
5. 避免过度编译器优化编译器的优化可以提高代码性能，但有时过度优化可能导致一些错误的结果。
了解编译器的优化选项，并避免使用可能引起问题的选项或语法。
6. 使用缓存合理地利用计算机的缓存机制可以加速程序运行。
对于频繁访问的数据，在内存中创建缓存，避免重复读取硬盘或网络数据。
7. 并行与并发当需要处理大量数据时，考虑使用并行和并发技术来提高代码性能。
合理地划分任务、利用多核处理器和线程池等技术都可以提高程序运行效率。
8. 降低函数调用开销函数调用会带来额外的开销，尤其是在循环中频繁调用函数。
因此，尽量减少不必要的函数调用，将重复执行的代码直接嵌入到循环中。
9. 使用高效的算法和库选择高效的算法和使用经过优化的库可以极大地提高代码性能。
比如使用排序算法时选择快速排序而不是冒泡排序，使用哈希表而不是线性查找等。
10. 进行性能测试和优化最后一点也是非常关键：定期进行性能测试和优化。
通过测试工具对代码进行分析，找出存在性能瓶颈的地方，并针对性地进行优化，使代码持续保持高效率。
通过运用以上十个实用技巧，我们可以大大提高代码的性能和运行效率。
JAVA提高代码效率的方法
JAVA提高代码效率的方法Java是一种高级编程语言，可以用于开发各种应用程序，包括桌面应用程序、Web应用程序和移动应用程序等。
提高Java代码的效率对于开发高性能和可扩展的应用程序是非常重要的。
以下是一些提高Java代码效率的方法：1.使用适当的数据结构：选择与问题域相适应的数据结构可以显著提高代码效率。
例如，使用散列表来进行快速的数据查找，使用数组来进行快速的数据访问，使用栈或队列来进行快速的数据插入和删除等。
2. 避免过度使用嵌套循环：循环是Java程序中最常用的结构之一，但过度嵌套循环会导致代码效率低下。
尽量避免使用多层嵌套循环，可以通过使用更高效的算法或数据结构来减少循环的次数。
3. 尽量避免使用递归：递归是一种简洁而优雅的编程技术，但在Java中，递归调用会导致额外的方法调用开销，影响代码的效率。
如果可能，尽量使用迭代方式来替代递归。
4. 使用合适的集合类：Java提供了多种集合类，如ArrayList、LinkedList、HashSet和TreeSet等。
选择合适的集合类可以根据需要进行快速的插入、删除和查找操作。
例如，如果需要快速的插入和删除操作，可以使用LinkedList；如果需要高效的查找操作，可以使用HashSet或TreeSet。
5. 避免不必要的对象创建：Java中的每个对象都会占用一定的内存空间，并且对垃圾回收器会有一定的压力。
因此，尽量避免不必要的对象创建，可以通过重用对象或使用对象池来提高代码效率。
6. 避免过度使用字符串连接操作：字符串连接操作在Java中是比较耗时的操作，特别是在循环中频繁进行字符串连接操作会导致严重的性能问题。
尽量使用StringBuilder类来进行字符串的拼接，可以显著提高代码的效率。
7. 使用并发编程：Java提供了多线程和并发编程的支持，可以充分利用多核处理器的性能。
合理地使用多线程和并发编程可以有效地提高代码的效率，特别是在处理大量数据或执行密集型计算任务时。
Java中的性能优化有哪些常见方法
Java中的性能优化有哪些常见方法在 Java 开发中，性能优化是一个至关重要的环节。
随着应用规模的不断扩大和用户需求的日益增长，确保程序能够高效运行、快速响应变得尤为重要。
下面我们就来探讨一下 Java 中的一些常见性能优化方法。
一、算法和数据结构的选择选择合适的算法和数据结构是性能优化的基础。
例如，对于频繁的插入和删除操作，链表可能比数组更合适；对于快速查找操作，哈希表可能比线性搜索更高效。
在实际开发中，需要根据具体的业务需求和数据特点，选择最优的数据结构和算法。
比如，在一个需要快速查找元素是否存在的场景中，如果使用线性搜索，时间复杂度为 O(n)，而使用哈希表，平均时间复杂度可以达到O(1)。
这将大大提高程序的执行效率。
二、减少对象创建和销毁在 Java 中，对象的创建和销毁是相对耗费资源的操作。
因此，应尽量减少不必要的对象创建和销毁。
可以通过对象复用、使用对象池等方式来实现。
例如，在一个循环中，如果每次都创建一个新的对象，会导致大量的内存分配和垃圾回收操作。
可以将对象创建放在循环外部，或者使用对象池来重复利用已经创建的对象。
另外，使用基本数据类型代替对象类型也能减少对象创建的开销。
比如，如果只需要存储一个整数，使用`int`类型而不是`Integer`对象。
三、字符串操作的优化字符串操作在很多应用中都非常常见，因此对字符串操作进行优化也能显著提升性能。
避免频繁的字符串拼接操作，因为这会创建新的字符串对象。
可以使用`StringBuilder`或`StringBuffer`类来进行字符串的拼接，它们在内部进行了优化，能够减少对象的创建。
在字符串比较时，如果不需要区分大小写，可以使用`equalsIgnoreCase(）｀方法，而不是先将字符串转换为小写或大写后再进行比较，这样可以减少额外的字符串转换操作。
四、合理使用缓存缓存是一种常见的性能优化手段。
可以将经常使用的数据或计算结果缓存起来，避免重复计算或重复获取数据。
Java性能优化技巧
Java性能优化技巧Java作为一种广泛使用的编程语言，有着强大的跨平台特性和高度可靠的稳定性。
然而，在处理大规模数据以及高并发请求等场景下，Java应用程序可能会面临性能瓶颈的挑战。
为了充分发挥Java的潜力并提高应用程序的性能，开发人员需要掌握一些Java性能优化的技巧。
本文将介绍一些Java性能优化的方法和技巧，帮助开发人员克服这些挑战。
1、使用高效的数据结构和算法在编写Java代码时，使用高效的数据结构和算法是提升性能的关键。
例如，在处理大规模数据集时，使用HashMap代替ArrayList可以提高查找效率；使用二分查找算法代替线性查找算法可以快速定位目标元素。
此外，合理选择适当的数据结构，如使用栈来实现递归算法等，也是优化Java性能的一种有效方式。
2、避免创建过多的对象在Java中，对象的创建和销毁是一项开销较大的操作。
频繁的对象创建不仅会消耗内存资源，还会导致垃圾回收器频繁触发，影响应用程序的性能。
因此，合理使用对象池技术，复用已创建的对象，可以减少对象创建的次数，提高Java应用程序的性能。
3、使用合理的缓存策略缓存是提高Java应用程序性能的常用手段之一。
合理地使用缓存可以减少对底层资源的频繁访问，从而加快应用程序的响应速度。
例如，可以使用内存缓存来缓存频繁读取的数据，减少数据库查询的次数；可以使用页面缓存来缓存渲染结果，减少页面生成的开销。
4、使用并发编程技术Java提供了丰富的并发编程工具和框架，如线程池、同步容器、并发集合等，可以帮助开发人员更好地利用多核处理器的优势，提高Java应用程序的并发性能。
使用并发编程技术可以将任务分配给多个线程并行处理，提高系统的吞吐量和响应速度。
5、优化IO操作在Java应用程序中，IO操作是非常耗时的操作之一。
合理地优化IO操作可以显著提高Java应用程序的性能。
例如，可以使用缓冲流来减少磁盘读写次数，使用NIO（非阻塞IO）技术来实现高效的网络通信等。
Java调优技巧：提升程序运行速度的方法
Java调优技巧：提升程序运行速度的方法随着计算机技术的不断发展，软件的运行速度成为了一个重要的指标。
在众多的编程语言中，Java因其跨平台性、面向对象的特性和丰富的类库而备受开发者的青睐。
然而，由于Java是一门解释性语言，相比于编译型语言，其运行效率相对较低。
为了提升Java程序的运行速度，我们可以采取一些调优技巧。
本文将介绍一些常用的Java调优方法，帮助开发者提高程序的性能。
首先，我们可以通过优化算法和数据结构来提升程序的运行速度。
在编写代码时，我们应该选择最适合问题的数据结构和算法。
例如，当需要频繁地插入和删除元素时，使用链表而不是数组可以提高效率。
另外，我们还可以使用哈希表来加快查找操作的速度。
此外，合理选择排序算法，如快速排序、归并排序等，也能够提高程序的性能。
其次，我们可以通过使用多线程来实现并发编程，从而提高程序的运行速度。
Java提供了多线程的支持，开发者可以通过创建多个线程来并发执行任务。
在编写多线程程序时，我们需要注意线程的同步和互斥，以避免出现数据竞争和死锁等问题。
此外，合理地利用线程池和线程池的大小也能够提高程序的性能。
另外，我们可以通过使用缓存来提高程序的运行速度。
缓存是一种将数据存储在高速存储器中的技术，可以减少对慢速存储器的访问次数，从而提高程序的响应速度。
在Java中，我们可以使用内存缓存库，如Ehcache、Guava Cache等，来实现缓存功能。
通过将经常访问的数据存储在缓存中，可以避免频繁地进行磁盘或网络访问，从而提高程序的性能。
此外，我们还可以通过使用JIT编译器来提高Java程序的运行速度。
JIT （Just-In-Time）编译器是Java虚拟机的一部分，它可以将字节码实时编译成本地机器码。
通过使用JIT编译器，Java程序可以在运行时进行优化，从而提高程序的性能。
在Java 8之后的版本中，我们可以通过设置JIT编译器的参数来调整其优化策略，以适应不同的应用场景。
Java代码优化技巧
Java 是一种广泛使用的高级编程语言，它的特点之一就是可移植性和面向对象的特性。
然而，对于大型应用程序来说，Java 的性能可能成为一个问题。
因此，优化 Java 代码是提高程序性能的关键。
下面将介绍一些常用的 Java 代码优化技巧。
1.使用局部变量: 局部变量的访问速度比全局变量快。
因此，在开发过程中，尽量使用局部变量来存储临时计算结果。
这不仅可以提高代码的可读性，还可以减少内存的使用。
2.使用 StringBuilder 替代 String: 在 Java 中，String 是不可变的，当对一个 String 对象进行修改时，实际上是创建了一个新的对象。
而StringBuilder 是可变的，它可以直接在原有的字符串上进行修改，避免了创建新的对象，提高了性能。
3.使用 ArrayList 替代数组: 在 Java 中，数组是固定长度的，一旦创建就无法改变大小。
而 ArrayList 是可以动态改变大小的，它的插入和删除操作比数组更高效，因此，在需要频繁插入和删除元素时，应使用ArrayList。
4.避免使用嵌套循环: 嵌套循环会导致代码的复杂度增加，执行时间变长。
对于大型数据集，尤其需要注意避免多重嵌套循环。
可以考虑使用其他数据结构，如哈希表，来提高代码的执行效率。
5.使用缓存技术: 对于一些会重复计算的结果，可以使用缓存技术来提高性能。
例如，使用缓存来存储数据库查询结果，减少数据库的访问次数，从而提高代码的执行速度。
6.使用并行编程: 在多核处理器上，使用并行编程可以更充分地利用硬件资源。
Java 提供了多线程和并发包来支持并行编程。
通过将任务分解成独立的子任务，并在多个线程上执行，可以加快代码的执行速度。
7.尽量避免使用递归: 递归在某些情况下可以简化代码逻辑，但它的性能较差。
递归调用需要频繁地进行方法调用和堆栈操作，增加了代码的执行时间。
如果可以使用循环或其他更高效的方法替代递归，应尽量避免使用递归。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
java中提升性能的小技巧1. 尽量在合适的场合使用单例使用单例可以减轻加载的负担，缩短加载的时间，提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面：第一，控制资源的使用，通过线程同步来控制资源的并发访问；第二，控制实例的产生，以达到节约资源的目的；第三，控制数据共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信。
2. 尽量避免随意使用静态变量要知道，当某个对象被定义为stataic变量所引用，那么gc通常是不会回收这个对象所占有的内存，如1 public class A{2 static B b = new B();3 }此时静态变量b的生命周期与A类同步，如果A类不会卸载，那么b对象会常驻内存，直到程序终止。
3. 尽量避免过多过常的创建Java对象尽量避免在经常调用的方法，循环中new对象，由于系统不仅要花费时间来创建对象，而且还要花时间对这些对象进行垃圾回收和处理，在我们可以控制的范围内，最大限度的重用对象，最好能用基本的数据类型或数组来替代对象。
4. 尽量使用final修饰符带有final修饰符的类是不可派生的。
在Java核心API中，有许多应用final的例子，例如ng.String。
为String类指定final防止了使用者覆盖length()方法。
另外，如果一个类是final的，则该类所有方法都是final的。
Java编译器会寻找机会内联（inline）所有的final 方法（这和具体的编译器实现有关）。
此举能够使性能平均提高50%。
5. 尽量使用局部变量调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。
其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。
6. 尽量处理好包装类型和基本类型两者的使用场所虽然包装类型和基本类型在使用过程中是可以相互转换，但它们两者所产生的内存区域是完全不同的，基本类型数据产生和处理都在栈中处理，包装类型是对象，是在堆中产生实例。
在集合类对象，有对象方面需要的处理适用包装类型，其他的处理提倡使用基本类型。
7. 慎用synchronized，尽量减小synchronize的方法都知道，实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
synchronize方法被调用时，直接会把当前对象锁了，在方法执行完之前其他线程无法调用当前对象的其他方法。
所以synchronize的方法尽量小，并且应尽量使用方法同步代替代码块同步。
8. 尽量使用StringBuilder和StringBuffer进行字符串连接这个就不多讲了。
9. 尽量不要使用finalize方法实际上，将资源清理放在finalize方法中完成是非常不好的选择，由于GC的工作量很大，尤其是回收Y oung代内存时，大都会引起应用程序暂停，所以再选择使用finalize方法进行资源清理，会导致GC负担更大，程序运行效率更差。
10. 尽量使用基本数据类型代替对象String str = "hello";上面这种方式会创建一个“hello”字符串，而且JVM的字符缓存池还会缓存这个字符串；String str = new String("hello");此时程序除创建字符串外，str所引用的String对象底层还包含一个char[]数组，这个char[]数组依次存放了h,e,l,l,o11. 单线程应尽量使用HashMap、ArrayListHashTable、V ector等使用了同步机制，降低了性能。
12. 尽量合理的创建HashMap当你要创建一个比较大的hashMap时，充分利用另一个构造函数public HashMap(int initialCapacity, float loadFactor)避免HashMap多次进行了hash重构,扩容是一件很耗费性能的事，在默认中initialCapacity 只有16，而loadFactor是0.75，需要多大的容量，你最好能准确的估计你所需要的最佳大小，同样的Hashtable，V ectors也是一样的道理。
13. 尽量减少对变量的重复计算for(int i=0;i<list.size();i++)应该改为for(int i=0,len=list.size();i<len;i++)并且在循环中应该避免使用复杂的表达式，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。
14. 尽量避免不必要的创建如A a = new A();if(i==1){list.add(a);}应该改为if(i==1){A a = new A();list.add(a);}15. 尽量在finally块中释放资源程序中使用到的资源应当被释放，以避免资源泄漏。
这最好在finally块中去做。
不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。
16. 尽量使用移位来代替'a/b'的操作"/"是一个代价很高的操作，使用移位的操作将会更快和更有效如int num = a / 4;int num = a / 8;应该改为int num = a >> 2;int num = a >> 3;但注意的是使用移位应添加注释，因为移位操作不直观，比较难理解17.尽量使用移位来代替'a*b'的操作同样的，对于'*'操作，使用移位的操作将会更快和更有效如int num = a * 4;int num = a * 8;应该改为int num = a << 2;int num = a << 3;18. 尽量确定StringBuffer的容量StringBuffer 的构造器会创建一个默认大小（通常是16）的字符数组。
在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。
在大多数情况下，你可以在创建StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。
如：StringBuffer buffer = new StringBuffer(1000);19. 尽量早释放无用对象的引用大部分时，方法局部引用变量所引用的对象会随着方法结束而变成垃圾，因此，大部分时候程序无需将局部，引用变量显式设为null。
例如：1 Public void test(){2 Object obj = new Object();3 ……4 Obj=null;5 }上面这个就没必要了，随着方法test()的执行完成，程序中obj引用变量的作用域就结束了。
但是如果是改成下面：1 Public void test(){2 Object obj = new Object();3 ……4 Obj=null;5 //执行耗时，耗内存操作；或调用耗时，耗内存的方法6 ……7 }这时候就有必要将obj赋值为null，可以尽早的释放对Object对象的引用。
20. 尽量避免使用二维数组二维数据占用的内存空间比一维数组多得多，大概10倍以上。
21. 尽量避免使用split除非是必须的，否则应该避免使用split，split由于支持正则表达式，所以效率比较低，如果是频繁的几十，几百万的调用将会耗费大量资源，如果确实需要频繁的调用split，可以考虑使用apache的StringUtils.split(string,char)，频繁split的可以缓存结果。
22. ArrayList & LinkedList一个是线性表，一个是链表，一句话，随机查询尽量使用ArrayList，ArrayList优于LinkedList，LinkedList还要移动指针，添加删除的操作LinkedList优于ArrayList，ArrayList还要移动数据，不过这是理论性分析，事实未必如此，重要的是理解好2 者得数据结构，对症下药。
23. 尽量使用System.arraycopy ()代替通过来循环复制数组System.arraycopy() 要比通过循环来复制数组快的多24. 尽量缓存经常使用的对象尽可能将经常使用的对象进行缓存，可以使用数组，或HashMap的容器来进行缓存，但这种方式可能导致系统占用过多的缓存，性能下降，推荐可以使用一些第三方的开源工具，如EhCache，Oscache进行缓存，他们基本都实现了FIFO/FLU等缓存算法。
25. 尽量避免非常大的内存分配有时候问题不是由当时的堆状态造成的，而是因为分配失败造成的。
分配的内存块都必须是连续的，而随着堆越来越满，找到较大的连续块越来越困难。
26. 慎用异常当创建一个异常时，需要收集一个栈跟踪(stack track)，这个栈跟踪用于描述异常是在何处创建的。
构建这些栈跟踪时需要为运行时栈做一份快照，正是这一部分开销很大。
当需要创建一个Exception 时，JVM 不得不说：先别动，我想就您现在的样子存一份快照，所以暂时停止入栈和出栈操作。
栈跟踪不只包含运行时栈中的一两个元素，而是包含这个栈中的每一个元素。
如果您创建一个Exception ，就得付出代价。
好在捕获异常开销不大，因此可以使用try-catch 将核心内容包起来。
从技术上讲，您甚至可以随意地抛出异常，而不用花费很大的代价。
招致性能损失的并不是throw 操作——尽管在没有预先创建异常的情况下就抛出异常是有点不寻常。
真正要花代价的是创建异常。
幸运的是，好的编程习惯已教会我们，不应该不管三七二十一就抛出异常。
异常是为异常的情况而设计的，使用时也应该牢记这一原则。