导航:首页 > 源码编译 > 编译器优化的作用java

编译器优化的作用java

 发布时间：2023-03-15 18:37:56

㈠ java编译器的代码优化问题

理论上的就不说了，你自己搜也能搜到很多。
举个例子，你从一个方法a调用了另一个方法b。
我们知道，在a和b之中是可以创建相同名称的变量的，比如都有int i = 0;这句话。这种现象的根本原因在于，方法的调用会产生中断，中断产生后，cpu会做现场保护，包括把变量等进行压栈操作，即把方法a的相关资源进行了压栈，而方法b的相关资源放在栈顶，只有栈顶资源可以与cpu交互（就把方法a中的变量i保护起来），当方法b结束后出栈，a就又回到了栈顶，并获取了方法b运行的结果，然后继续运行。

哎，有些啰嗦了。方法的调用、中断、压栈出栈等等这些操作你说一点不消耗资源吧，那是不可能的，多少都会消耗一些，虽然很非常十分微不足道。那么编译器的优化过程，我知道的其作用之一，就是会把这些做一个优化。原本方法a一共10句话，你偏要只写1句，然后第2句写成方法b，第3句写成方法c。。。。。，然后依次嵌套调用。这样的源代码，编译器优化后，就跟你直接写10句是一个结果，即做了一定程度上的优化。

㈡ 应用编译优化三种模式

应用编译优化三种模式分别是：编译时间优化模式、执行时间优化模式和代码大小优化模式。
1、编译时间优化模式：关注编译速度的提升，以缩短应用程序高脊的编译时间为目标。在这种模式下，编译器会减少编译时间，会降低应用程序的执行效率。
2、执行时间优化模式：关注应用程序的执行效率，以提高应用程序的性能为目标。在这种模式下，编译器会优化应用程序的代码，以提高执行效率，会增加编译时间。
3、代码大小优化模式：关注应用程序的大小，以减小应兆培用程序的体积为目标。族念唯在这种模式下，编译器会减小应用程序的代码大小，以减小应用程序的体积，会降低应用程序的执行效率。

㈢ Java代码如何优化

今天就跟中公优就业一起来看看java代码优化细节。

1、尽量指定类、方法的final修饰符

带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String，整个类都是final的。为类指定final修饰符可以让类不可以被继承，为方法指定final修饰符可以让方法不可以被重写。如果指定了一个类为final，则该类所有的方法都是final的。Java编译器会寻找机会内联所有的final方法，内联对于提升Java运行效率作用重大，具体参见Java运行期优化。此举能够使性能平均提高50%。

2、尽量重用对象

特别是String对象的使用，出现字符串连接时应该使用StringBuilder/StringBuffer代替。由于Java虚拟机不仅要花时间生成对象，以后可能还需要花时间对这些对象进行垃圾回收和处理，因此，生成过多的对象将会给程序的性能带来很大的影响。

3、尽可能使用局部变量

调用方法时传递的参数以及在调用中创建的临时变量都保存在栈中速度较快，其他变量，如静态变量、实例变量等，都在堆中创建，速度较慢。另外，栈中创建的变量，随着方法的运行结束，这些内容就没了，不需要额外的垃圾回收。

4、及时关闭流

Java编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，及时关闭以释放资源。因为对这些大对象的操作会造成系统大的开销，稍有不慎，将会导致严重的后果。

5、尽量减少对变量的重复计算

明确一个概念，对方法的调用，即使方法中只有一句语句，也是有消耗的，包括创建栈帧、调用方法时保护现场、调用方法完毕时恢复现场等。所以例如下面的操作：

for (int i = 0; i < list.size(); i++){...}

建议替换为：

for (int i = 0, int length = list.size(); i < length; i++){...}

这样，在list.size()很大的时候，就减少了很多的消耗

6、尽量采用懒加载的策略，即在需要的时候才创建

例如：

String str = "aaa";if (i == 1){list.add(str);}

建议替换为：

if (i == 1){String str = "aaa";list.add(str);}

7、慎用异常

异常对性能不利。抛出异常首先要创建一个新的对象，Throwable接口的构造函数调用名为fillInStackTrace()的本地同步方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，Java虚拟机就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。异常只能用于错误处理，不应该用来控制程序流程。

8、不要在循环中使用try…catch…，应该把其放在最外层

除非不得已。如果毫无理由地这么写了，只要你的领导资深一点、有强迫症一点，八成就要骂你为什么写出这种垃圾代码来了

9、如果能估计到待添加的内容长度，为底层以数组方式实现的集合、工具类指定初始长度

比如ArrayList、LinkedLlist、StringBuilder、StringBuffer、HashMap、HashSet等等，以StringBuilder为例：

(1)StringBuilder() // 默认分配16个字符的空间

(2)StringBuilder(int size) // 默认分配size个字符的空间

(3)StringBuilder(String str)// 默认分配16个字符+str.length()个字符空间

可以通过类(这里指的不仅仅是上面的StringBuilder)的来设定它的初始化容量，这样可以明显地提升性能。比如StringBuilder吧，length表示当前的StringBuilder能保持的字符数量。因为当StringBuilder达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，无论何时只要StringBuilder达到它的最大容量，它就不得不创建一个新的字符数组然后将旧的字符数组内容拷贝到新字符数组中—-这是十分耗费性能的一个操作。试想，如果能预估到字符数组中大概要存放5000个字符而不指定长度，最接近5000的2次幂是4096，每次扩容加的2不管，那么：

(1)在4096 的基础上，再申请8194个大小的字符数组，加起来相当于一次申请了12290个大小的字符数组，如果一开始能指定5000个大小的字符数组，就节省了一倍以上的空间

(2)把原来的4096个字符拷贝到新的的字符数组中去

这样，既浪费内存空间又降低代码运行效率。所以，给底层以数组实现的集合、工具类设置一个合理的初始化容量是错不了的，这会带来立竿见影的效果。但是，注意，像HashMap这种是以数组+链表实现的集合，别把初始大小和你估计的大小设置得一样，因为一个table上只连接一个对象的可能性几乎为0。初始大小建议设置为2的N次幂，如果能估计到有2000个元素，设置成new HashMap(128)、new HashMap(256)都可以。

10、当复制大量数据时，使用System.array()命令

㈣ Java的核心技术有哪些

㈤ Java代码优化有哪些常用的方法

1、 尽量指定类的final修饰符 带有final修饰符的类是不可派生的。
在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了人们覆盖length()方法。另外，如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50% 。
2、 尽量重用对象。
特别是String 对象的使用中，出现字符串连接情况时应用StringBuffer 代替。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。
3、 尽量使用局部变量，调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。
其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化。请参见《尽可能使用堆栈变量》。
4、 不要重复初始化变量
默认情况下，调用类的构造函数时， Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量（byte、short、int、long）设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链中的所有构造函数都会被自动调用。
5、 在JAVA + ORACLE 的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担。
6、 Java 编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，即使关闭以释放资源。
因为对这些大对象的操作会造成系统大的开销，稍有不慎，会导致严重的后果。
7、 由于JVM的有其自身的GC机制，不需要程序开发者的过多考虑，从一定程度上减轻了开发者负担，但同时也遗漏了隐患，过分的创建对象会消耗系统的大量内存，严重时会导致内存泄露，因此，保证过期对象的及时回收具有重要意义。
JVM回收垃圾的条件是：对象不在被引用；然而，JVM的GC并非十分的机智，即使对象满足了垃圾回收的条件也不一定会被立即回收。所以，建议我们在对象使用完毕，应手动置成null。
8、 在使用同步机制时，应尽量使用方法同步代替代码块同步。
9、 尽量减少对变量的重复计算
例如：for(int i = 0;i < list.size; i ++) {
…
}
应替换为：
for(int i = 0,int len = list.size();i < len; i ++){
…
}
10、尽量采用lazy loading 的策略，即在需要的时候才开始创建。

例如： String str = “aaa”;
if(i == 1) {
list.add(str);
}
应替换为：
if(i == 1) {
String str = “aaa”;
list.add(str);
}

11、慎用异常

异常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地（Native）方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。 异常只能用于错误处理，不应该用来控制程序流程。
12、不要在循环中使用：

Try {
} catch() {
}
应把其放置在最外层。
13、StringBuffer 的使用：

StringBuffer表示了可变的、可写的字符串。
有三个构造方法 :
StringBuffer (); //默认分配16个字符的空间
StringBuffer (int size); //分配size个字符的空间
StringBuffer (String str); //分配16个字符+str.length()个字符空间
你可以通过StringBuffer的构造函数来设定它的初始化容量，这样可以明显地提升性能。
这里提到的构造函数是StringBuffer(int length)，length参数表示当前的StringBuffer能保持的字符数量。你也可以使用ensureCapacity(int minimumcapacity)方法在StringBuffer对象创建之后设置它的容量。首先我们看看StringBuffer的缺省行为，然后再找出一条更好的提升性能的途径。
StringBuffer在内部维护一个字符数组，当你使用缺省的构造函数来创建StringBuffer对象的时候，因为没有设置初始化字符长度，StringBuffer的容量被初始化为16个字符，也就是说缺省容量就是16个字符。当StringBuffer达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，也就是（2*旧值+2）。如果你使用缺省值，初始化之后接着往里面追加字符，在你追加到第16个字符的时候它会将容量增加到34（2*16+2），当追加到34个字符的时候就会将容量增加到70（2*34+2）。无论何事只要StringBuffer到达它的最大容量它就不得不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍――这也太昂贵了点。所以总是给StringBuffer设置一个合理的初始化容量值是错不了的，这样会带来立竿见影的性能增益。StringBuffer初始化过程的调整的作用由此可见一斑。所以，使用一个合适的容量值来初始化StringBuffer永远都是一个最佳的建议。
14、合理的使用Java类 java.util.Vector。

简单地说，一个Vector就是一个java.lang.Object实例的数组。Vector与数组相似，它的元素可以通过整数形式的索引访问。但是，Vector类型的对象在创建之后，对象的大小能够根据元素的增加或者删除而扩展、缩小。请考虑下面这个向Vector加入元素的例子：
Object bj = new Object();
Vector v = new Vector(100000);
for(int I=0;
I<100000; I++) { v.add(0,obj); }
除非有绝对充足的理由要求每次都把新元素插入到Vector的前面，否则上面的代码对性能不利。在默认构造函数中，Vector的初始存储能力是10个元素，如果新元素加入时存储能力不足，则以后存储能力每次加倍。Vector类就对象StringBuffer类一样，每次扩展存储能力时，所有现有的元素都要复制到新的存储空间之中。下面的代码片段要比前面的例子快几个数量级：
Object bj = new Object();
Vector v = new Vector(100000);
for(int I=0; I<100000; I++) { v.add(obj); }
同样的规则也适用于Vector类的remove()方法。由于Vector中各个元素之间不能含有“空隙”，删除除最后一个元素之外的任意其他元素都导致被删除元素之后的元素向前移动。也就是说，从Vector删除最后一个元素要比删除第一个元素“开销”低好几倍。
假设要从前面的Vector删除所有元素，我们可以使用这种代码：
for(int I=0; I<100000; I++)
{
v.remove(0);
}
但是，与下面的代码相比，前面的代码要慢几个数量级：
for(int I=0; I<100000; I++)
{
v.remove(v.size()-1);
}
从Vector类型的对象v删除所有元素的最好方法是：
v.removeAllElements();
假设Vector类型的对象v包含字符串“Hello”。考虑下面的代码，它要从这个Vector中删除“Hello”字符串：
String s = "Hello";
int i = v.indexOf(s);
if(I != -1) v.remove(s);
这些代码看起来没什么错误，但它同样对性能不利。在这段代码中，indexOf()方法对v进行顺序搜索寻找字符串“Hello”，remove(s)方法也要进行同样的顺序搜索。改进之后的版本是：
String s = "Hello";
int i = v.indexOf(s);
if(I != -1) v.remove(i);
这个版本中我们直接在remove()方法中给出待删除元素的精确索引位置，从而避免了第二次搜索。一个更好的版本是：
String s = "Hello"; v.remove(s);
最后，我们再来看一个有关Vector类的代码片段：
for(int I=0; I++;I < v.length)
如果v包含100,000个元素，这个代码片段将调用v.size()方法100,000次。虽然size方法是一个简单的方法，但它仍旧需要一次方法调用的开销，至少JVM需要为它配置以及清除堆栈环境。在这里，for循环内部的代码不会以任何方式修改Vector类型对象v的大小，因此上面的代码最好改写成下面这种形式：
int size = v.size(); for(int I=0; I++;I<size)
虽然这是一个简单的改动，但它仍旧赢得了性能。毕竟，每一个CPU周期都是宝贵的。
15、当复制大量数据时，使用System.array()命令。
int[] src={1,3,5,6,7,8};
int[] dest = new int[6];
System.array(src, 0, dest, 0, 6);
src:源数组; srcPos:源数组要复制的起始位置;
dest:目的数组; destPos:目的数组放置的起始位置;
length:复制的长度.
注意：src and dest都必须是同类型或者可以进行转换类型的数组．
16、代码重构：增强代码的可读性。
public class ShopCart {
private List carts ;
…
public void add (Object item) {
if(carts == null) {
carts = new ArrayList();
}
crts.add(item);
}
public void remove(Object item) {
if(carts. contains(item)) {
carts.remove(item);
}
}
public List getCarts() {
//返回只读列表
return Collections.unmodifiableList(carts);
}

//不推荐这种方式
//this.getCarts().add(item);
}
17、不用new关键词创建类的实例

用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。
在使用设计模式（Design Pattern）的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。例如，下面是Factory模式的一个典型实现：
public static Credit getNewCredit() {
return new Credit();
}
改进后的代码使用clone()方法，如下所示：
private static Credit BaseCredit = new Credit();
public static Credit getNewCredit() {
return (Credit) BaseCredit.clone();
}
上面的思路对于数组处理同样很有用。
18、乘法和除法

考虑下面的代码：
for (val = 0; val < 100000; val +=5) {
alterX = val * 8; myResult = val * 2;
}
用移位操作替代乘法操作可以极大地提高性能。下面是修改后的代码：
for (val = 0; val < 100000; val += 5) {
alterX = val << 3; myResult = val << 1;
}
修改后的代码不再做乘以8的操作，而是改用等价的左移3位操作，每左移1位相当于乘以2。相应地，右移1位操作相当于除以2。值得一提的是，虽然移位操作速度快，但可能使代码比较难于理解，所以最好加上一些注释。
19、在JSP页面中关闭无用的会话。

一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 <> 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。
对于那些无需跟踪会话状态的页面，关闭自动创建的会话可以节省一些资源。使用如下page指令：<%@ page session="false"%>
20、JDBC与I/O

如果应用程序需要访问一个规模很大的数据集，则应当考虑使用块提取方式。默认情况下，JDBC每次提取32行数据。举例来说，假设我们要遍历一个5000行的记录集，JDBC必须调用数据库157次才能提取到全部数据。如果把块大小改成512，则调用数据库的次数将减少到10次。
21、Servlet与内存使用
许多开发者随意地把大量信息保存到用户会话之中。一些时候，保存在会话中的对象没有及时地被垃圾回收机制回收。从性能上看，典型的症状是用户感到系统周期性地变慢，却又不能把原因归于任何一个具体的组件。如果监视JVM的堆空间，它的表现是内存占用不正常地大起大落。
解决这类内存问题主要有二种办法。第一种办法是，在所有作用范围为会话的Bean中实现HttpSessionBindingListener接口。这样，只要实现valueUnbound()方法，就可以显式地释放Bean使用的资源。
另外一种办法就是尽快地把会话作废。大多数应用服务器都有设置会话作废间隔时间的选项。另外，也可以用编程的方式调用会话的setMaxInactiveInterval()方法，该方法用来设定在作废会话之前，Servlet容器允许的客户请求的最大间隔时间，以秒计。
22、使用缓冲标记

一些应用服务器加入了面向JSP的缓冲标记功能。例如，BEA的WebLogic Server从6.0版本开始支持这个功能，Open Symphony工程也同样支持这个功能。JSP缓冲标记既能够缓冲页面片断，也能够缓冲整个页面。当JSP页面执行时，如果目标片断已经在缓冲之中，则生成该片断的代码就不用再执行。页面级缓冲捕获对指定URL的请求，并缓冲整个结果页面。对于购物篮、目录以及门户网站的主页来说，这个功能极其有用。对于这类应用，页面级缓冲能够保存页面执行的结果，供后继请求使用。
23、选择合适的引用机制

在典型的JSP应用系统中，页头、页脚部分往往被抽取出来，然后根据需要引入页头、页脚。当前，在JSP页面中引入外部资源的方法主要有两种：include指令，以及include动作。
include指令：例如<%@ include file="right.html" %>。该指令在编译时引入指定的资源。在编译之前，带有include指令的页面和指定的资源被合并成一个文件。被引用的外部资源在编译时就确定，比运行时才确定资源更高效。
include动作：例如<jsp:include page="right.jsp" />。该动作引入指定页面执行后生成的结果。由于它在运行时完成，因此对输出结果的控制更加灵活。但时，只有当被引用的内容频繁地改变时，或者在对主页面的请求没有出现之前，被引用的页面无法确定时，使用include动作才合算。
24、及时清除不再需要的会话

为了清除不再活动的会话，许多应用服务器都有默认的会话超时时间，一般为30分钟。当应用服务器需要保存更多会话时，如果内存容量不足，操作系统会把部分内存数据转移到磁盘，应用服务器也可能根据“最近最频繁使用”（Most Recently Used）算法把部分不活跃的会话转储到磁盘，甚至可能抛出“内存不足”异常。在大规模系统中，串行化会话的代价是很昂贵的。当会话不再需要时，应当及时调用HttpSession.invalidate()方法清除会话。HttpSession.invalidate()方法通常可以在应用的退出页面调用。
25、不要将数组声明为：public static final 。
26、HashMap的遍历效率讨论

经常遇到对HashMap中的key和value值对的遍历操作，有如下两种方法：
Map<String, String[]> paraMap = new HashMap<String, String[]>();
//第一个循环
Set<String> appFieldDefIds = paraMap.keySet();
for (String appFieldDefId : appFieldDefIds) {
String[] values = paraMap.get(appFieldDefId);
......
}

//第二个循环
for(Entry<String, String[]> entry : paraMap.entrySet()){
String appFieldDefId = entry.getKey();
String[] values = entry.getValue();
.......
}
第一种实现明显的效率不如第二种实现。
分析如下 Set<String> appFieldDefIds = paraMap.keySet(); 是先从HashMap中取得keySet
代码如下：
public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}

private class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return newKeyIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
}
其实就是返回一个私有类KeySet, 它是从AbstractSet继承而来，实现了Set接口。
再来看看for/in循环的语法
for(declaration : expression)
statement
在执行阶段被翻译成如下各式
for(Iterator<E> #i = (expression).iterator(); #i.hashNext();){
declaration = #i.next();
statement
}
因此在第一个for语句for (String appFieldDefId : appFieldDefIds) 中调用了HashMap.keySet().iterator()
而这个方法调用了newKeyIterator()
Iterator<K> newKeyIterator() {
return new KeyIterator();
}
private class KeyIterator extends HashIterator<K> {
public K next() {
return nextEntry().getKey();
}
}
所以在for中还是调用了
在第二个循环for(Entry<String, String[]> entry : paraMap.entrySet())中使用的Iterator是如下的一个内部
类
private class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}
此时第一个循环得到key，第二个循环得到HashMap的Entry效率就是从循环里面体现出来的第二个循环此致可以直接取key和value值而第一个循环还是得再利用HashMap的get(Object key)来取value值现在看看HashMap的get(Object key)方法
public V get(Object key) {
Object k = maskNull(key);
int hash = hash(k);
int i = indexFor(hash, table.length); //Entry[] table
Entry<K,V> e = table;
while (true) {
if (e == null)
return null;
if (e.hash == hash && eq(k, e.key))
return e.value;
e = e.next;
}
}
其实就是再次利用Hash值取出相应的Entry做比较得到结果，所以使用第一中循环相当于两次进入HashMap的Entry
中而第二个循环取得Entry的值之后直接取key和value，效率比第一个循环高。其实按照Map的概念来看也应该是用第二个循环好一点，它本来就是key和value的值对，将key和value分开操作在这里不是个好选择。
27、array(数组) 和 ArryList的使用

array（[]）：最高效；但是其容量固定且无法动态改变；
ArrayList：容量可动态增长；但牺牲效率；
基于效率和类型检验，应尽可能使用array，无法确定数组大小时才使用ArrayList！
ArrayList是Array的复杂版本
ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。
ArrayList存入对象时，抛弃类型信息，所有对象屏蔽为Object，编译时不检查类型，但是运行时会报错。
注：jdk5中加入了对泛型的支持，已经可以在使用ArrayList时进行类型检查。
从这一点上看来，ArrayList与数组的区别主要就是由于动态增容的效率问题了
28、尽量使用HashMap 和ArrayList ,除非必要，否则不推荐使用HashTable和Vector ，后者由于使用同步机制，而导致了性能的开销。
29、StringBuffer 和StringBuilder的区别：

java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。
StringBuilder。与该类相比，通常应该优先使用 java.lang.StringBuilder类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。为了获得更好的性能，在构造 StirngBuffer 或 StirngBuilder 时应尽可能指定它的容量。当然，如果你操作的字符串长度不超过 16 个字符就不用了。 相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%-15% 左右的性能提升，但却要冒多线程不安全的风险。而在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非你能确定你的系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，否则还是用 StringBuffer 吧。
30、尽量避免使用split
除非是必须的，否则应该避免使用split，split由于支持正则表达式，所以效率比较低，如果是频繁的几十，几百万的调用将会耗费大量资源，如果确实需要频繁的调用split，可以考虑使用apache的 StringUtils.split(string,char)，频繁split的可以缓存结果。
其他补充:
1、及时清除不再使用的对象，设为null
2、尽可能使用final,static等关键字
3、尽可能使用buffered对象
如何优化代码使JAVA源文件及编译后CLASS文件更小
1 尽量使用继承，继承的方法越多，你要写的代码量也就越少
2 打开JAVA编译器的优化选项： javac -O 这个选项将删除掉CLASS文件中的行号，并能把
一些private, static,final的小段方法申明为inline方法调用
3 把公用的代码提取出来
4 不要初始化很大的数组，尽管初始化一个数组在JAVA代码中只是一行的代码量，但
编译后的代码是一行代码插入一个数组的元素，所以如果你有大量的数据需要存在数组
中的话，可以先把这些数据放在String中，然后在运行期把字符串解析到数组中
5 日期类型的对象会占用很大的空间，如果你要存储大量的日期对象，可以考虑把它存储为
long型，然后在使用的时候转换为Date类型
6 类名，方法名和变量名尽量使用简短的名字，可以考虑使用Hashjava, Jobe, Obfuscate and Jshrink等工具自动完成这个工作
7 将static final类型的变量定义到Interface中去
8 算术运算 能用左移/右移的运算就不要用*和/运算，相同的运算不要运算多次
2. 不要两次初始化变量
Java通过调用独特的类构造器默认地初始化变量为一个已知的值。所有的对象被设置成null，integers (byte, short, int, long)被设置成0，float和double设置成0.0，Boolean变量设置成false。这对那些扩展自其它类的类尤其重要，这跟使用一个新的关键词创建一个对象时所有一连串的构造器被自动调用一样。
3. 在任何可能的地方让类为Final
标记为final的类不能被扩展。在《核心Java API》中有大量这个技术的例子，诸如java.lang.String。将String类标记为final阻止了开发者创建他们自己实现的长度方法。
更深入点说，如果类是final的，所有类的方法也是final的。Java编译器可能会内联所有的方法（这依赖于编译器的实现）。在我的测试里，我已经看到性能平均增加了50%。
9. 异常在需要抛出的地方抛出，try catch能整合就整合
try {
some.method1(); // Difficult for javac
} catch( method1Exception e ) { // and the JVM runtime
// Handle exception 1 // to optimize this
} // code
try {
some.method2();
} catch( method2Exception e ) {
// Handle exception 2
}

try {
some.method3();
} catch( method3Exception e ) {
// Handle exception 3
}
已下代码 更容易被编译器优化
try {
some.method1(); // Easier to optimize
some.method2();
some.method3();
} catch( method1Exception e ) {
// Handle exception 1
} catch( method2Exception e ) {
// Handle exception 2
} catch( method3Exception e ) {
// Handle exception 3
}
10. For循环的优化
Replace…
for( int i = 0; i < collection.size(); i++ ) {
...
}
with…
for( int i = 0, n = collection.size(); i < n; i++ ) {
...
}

5、 在JAVA + ORACLE 的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担。
10、尽量采用lazy loading 的策略，即在需要的时候才开始创建。
例如： String str = “aaa”;
if(i == 1) {
list.add(str);
}
应替换为：
if(i == 1) {
String str = “aaa”;
list.add(str);
}
12、不要在循环中使用：
Try {
} catch() {
}
应把其放置在最外层

㈥ Java代码如何优化从哪些方面入手分析

1）尽量指定类、方法的final修饰符。带有final修饰符的类是不可派生的，Java编译器会寻找机会内联所有的final方法，内联对于提模键升Java运行效率作用重大，此举能够使性能平均提高50%。

2）尽量重用对象。由于Java虚拟机不仅要花时间生成对象，以后可能还需要花时间对这些对象进行垃圾回收和处理，因此生成过多的对象将会给程序的性能带来很大的影响。

3）尽可能使用局部变量。调用方法时传递的参数以及在调用中创建的临时变量都保存在栈中速度较快，其他变量，如静态变量、实例变量等，都在堆中创建速度较慢。

4）慎用异常。异常对性能不利，只要有异常被抛出，Java虚拟机就必须调整调用堆栈，因为在处理过程态码胡中创建了一个新的对象。异常只能用于错误处理，不应该用来控制程序流程。

5）乘法和除法使用移位操作。用移位操作可以极大地提高性能，因为在计算机底层，对位的操作是最方便、最快的，但是移位操作虽然快，可能会使代码不太好理解，因此最帆拦好加上相应的注释。

6）尽量使用HashMap、ArrayList、StringBuilder，除非线程安全需要，否则不推荐使用 Hashtable、Vector、StringBuffer，后三者由于使用同步机制而导致了性能开销。

㈦ Java代码的优化方法有哪些

说到代码优化，每个人或多或少都掌握一到两种方法，但是这样的方法对提升代码运行效率效果不大，最重要是对代码的重视和了解，这样才能提升代码的运行效率。在进行代码优化的过程中，方法是非常重要的，多掌握几种方法，根据代码的不同情况选择适合的方法进行优化。下面电脑培训为大家介绍Java代码优化的几种方法。


1、使用指定类、方法的final修饰符

具有final修饰符的类不可派生。在Java核心API中，有许多最终应用程序的例子，例如java.lang.String，整个类都是final。为类指定final修饰符允许继承类，并且为方法指定final修饰符允许覆盖该方法。如果将类指定为final，IT培训认为该类的所有方法都是final。Java编译器将寻找内联所有最终方法的机会。内联对于提高Java操作的效率非常重要。这可以将性能平均提高50％。

2、重用对象

String对象的使用是非常重要的，StringBuilder/StringBuffer并不是字符串连接。由于Java虚拟机需要时间来生成对象，所以将来垃圾收集和处理这些对象可能需要一些时间。因此，生成太多对象将对程序的性能产生很大影响。

3、使用局部变量

调用方法时传递的参数以及在调用中创建的临时变量都保存在堆栈中，速度更快。其他变量（如静态变量和实例变量）在堆中创建并且速度较慢。此外，昆明北大青鸟发现在堆栈中创建的变量，当方法完成运行时，内容消失，不需要进行额外的垃圾收集。

4、及时关闭流

在Java编程过程中，在执行数据库连接和I/O流操作时要小心。使用后，北大青鸟云南嘉荟校区官网建议应及时关闭以释放资源。因为这些大型物体的操作会导致系统的大量开销，稍微粗心会导致严重的后果。


㈧ java 编译优化问题

java编译的结果是字节码而不是二进制，所以在运行时vm的优化才是重要的，包括VM的回收策略、分配给VM内存的大小都能在一定程度上影响性能。Sun的VM支持热点编译，对高频执行的代码段翻译的2进制会进行缓存，这也是VM的一种优化。

IBM JVM处理数学运算速度最快，BEA JVM处理大量线程和网络socket性能最好，而Sun JVM处理通常的商业逻辑性能最好。不过Hotspot的Server mode被报告有稳定性的问题。

Java 的最大优势不是体现在执行速度上，所以对Compiler的要求并不如c++那样高，代码级的优化还需要程序员本身的功底。

贴个java的运行参数：

Usage: java [-options] class [args...]
(to execute a class)
or java [-options] -jar jarfile [args...]
(to execute a jar file)

where options include:
-client to select the "client" VM
-server to select the "server" VM
-hotspot is a synonym for the "client" VM [deprecated]
The default VM is client.

-cp <class search path of directories and zip/jar files>
-classpath <class search path of directories and zip/jar files>
A ; separated list of directories, JAR archives,
and ZIP archives to search for class files.
-D<name>=<value>
set a system property
-verbose[:class|gc|jni]
enable verbose output
-version print proct version and exit
-version:<value>
require the specified version to run
-showversion print proct version and continue
-jre-restrict-search | -jre-no-restrict-search
include/exclude user private JREs in the version search
-? -help print this help message
-X print help on non-standard options
-ea[:<packagename>...|:<classname>]
-enableassertions[:<packagename>...|:<classname>]
enable assertions
-da[:<packagename>...|:<classname>]
-disableassertions[:<packagename>...|:<classname>]
disable assertions
-esa | -enablesystemassertions
enable system assertions
-dsa | -disablesystemassertions
disable system assertions
-agentlib:<libname>[=<options>]
load native agent library <libname>, e.g. -agentlib:hprof
see also, -agentlib:jdwp=help and -agentlib:hprof=help
-agentpath:<pathname>[=<options>]
load native agent library by full pathname
-javaagent:<jarpath>[=<options>]
load Java programming language agent, see

java.lang.instrument

-Xmixed mixed mode execution (default)
-Xint interpreted mode execution only
-Xbootclasspath:<directories and zip/jar files separated by ;>
set search path for bootstrap classes and resources
-Xbootclasspath/a:<directories and zip/jar files separated by ;>
append to end of bootstrap class path
-Xbootclasspath/p:<directories and zip/jar files separated by ;>
prepend in front of bootstrap class path
-Xnoclassgc disable class garbage collection
-Xincgc enable incremental garbage collection
-Xloggc:<file> log GC status to a file with time stamps
-Xbatch disable background compilation
-Xms<size> set initial Java heap size
-Xmx<size> set maximum Java heap size
-Xss<size> set java thread stack size
-Xprof output cpu profiling data
-Xfuture enable strictest checks, anticipating future default
-Xrs rece use of OS signals by Java/VM (see

documentation)
-Xcheck:jni perform additional checks for JNI functions
-Xshare:off do not attempt to use shared class data
-Xshare:auto use shared class data if possible (default)
-Xshare:on require using shared class data, otherwise fail.

Java虚拟机（JVM）参数配置说明

在Java、J2EE大型应用中，JVM非标准参数的配置直接关系到整个系统的性能。
JVM非标准参数指的是JVM底层的一些配置参数，这些参数在一般开发中默认即可，不需

要任何配置。但是在生产环境中，为了提高性能，往往需要调整这些参数，以求系统达

到最佳新能。
另外这些参数的配置也是影响系统稳定性的一个重要因素，相信大多数Java开发人员都

见过“OutOfMemory”类型的错误。呵呵，这其中很可能就是JVM参数配置不当或者就没

有配置没意识到配置引起的。

为了说明这些参数，还需要说说JDK中的命令行工具一些知识做铺垫。

首先看如何获取这些命令配置信息说明：
假设你是windows平台，你安装了J2SDK，那么现在你从cmd控制台窗口进入J2SDK安装目

录下的bin目录，然后运行java命令，出现如下结果，这些就是包括java.exe工具的和

JVM的所有命令都在里面。

-----------------------------------------------------------------------
D:\j2sdk15\bin>java
Usage: java [-options] class [args...]
(to execute a class)
or java [-options] -jar jarfile [args...]
(to execute a jar file)

where options include:
-client to select the "client" VM
-server to select the "server" VM
-hotspot is a synonym for the "client" VM [deprecated]
The default VM is client.

-cp <class search path of directories and zip/jar files>
-classpath <class search path of directories and zip/jar files>
A ; separated list of directories, JAR archives,
and ZIP archives to search for class files.
-D<name>=<value>
set a system property
-verbose[:class|gc|jni]
enable verbose output
-version print proct version and exit
-version:<value>
require the specified version to run
-showversion print proct version and continue
-jre-restrict-search | -jre-no-restrict-search
include/exclude user private JREs in the version search
-? -help print this help message
-X print help on non-standard options
-ea[:<packagename>...|:<classname>]
-enableassertions[:<packagename>...|:<classname>]
enable assertions
-da[:<packagename>...|:<classname>]
-disableassertions[:<packagename>...|:<classname>]
disable assertions
-esa | -enablesystemassertions
enable system assertions
-dsa | -disablesystemassertions
disable system assertions
-agentlib:<libname>[=<options>]
load native agent library <libname>, e.g. -agentlib:hprof
see also, -agentlib:jdwp=help and -agentlib:hprof=help
-agentpath:<pathname>[=<options>]
load native agent library by full pathname
-javaagent:<jarpath>[=<options>]
load Java programming language agent, see

java.lang.instrument
-----------------------------------------------------------------------
在控制台输出信息中，有个-X（注意是大写）的命令，这个正是查看JVM配置参数的命

令。

其次，用java -X 命令查看JVM的配置说明：
运行后如下结果，这些就是配置JVM参数的秘密武器，这些信息都是英文的，为了方便

阅读，我根据自己的理解翻译成中文了（不准确的地方还请各位博友斧正）
-----------------------------------------------------------------------
D:\j2sdk15\bin>java -X
-Xmixed mixed mode execution (default)
-Xint interpreted mode execution only
-Xbootclasspath:<directories and zip/jar files separated by ;>
set search path for bootstrap classes and resources
-Xbootclasspath/a:<directories and zip/jar files separated by ;>
append to end of bootstrap class path
-Xbootclasspath/p:<directories and zip/jar files separated by ;>
prepend in front of bootstrap class path
-Xnoclassgc disable class garbage collection
-Xincgc enable incremental garbage collection
-Xloggc:<file> log GC status to a file with time stamps
-Xbatch disable background compilation
-Xms<size> set initial Java heap size
-Xmx<size> set maximum Java heap size
-Xss<size> set java thread stack size
-Xprof output cpu profiling data
-Xfuture enable strictest checks, anticipating future default
-Xrs rece use of OS signals by Java/VM (see

documentation)
-Xcheck:jni perform additional checks for JNI functions
-Xshare:off do not attempt to use shared class data
-Xshare:auto use shared class data if possible (default)
-Xshare:on require using shared class data, otherwise fail.

The -X options are non-standard and subject to change without notice.
-----------------------------------------------------------------------

JVM配置参数中文说明：
-----------------------------------------------------------------------
1、-Xmixed mixed mode execution (default)
混合模式执行

2、-Xint interpreted mode execution only
解释模式执行

3、-Xbootclasspath:<directories and zip/jar files separated by ;>
set search path for bootstrap classes and resources
设置zip/jar资源或者类（.class文件）存放目录路径

3、-Xbootclasspath/a:<directories and zip/jar files separated by ;>
append to end of bootstrap class path
追加zip/jar资源或者类（.class文件）存放目录路径

4、-Xbootclasspath/p:<directories and zip/jar files separated by ;>
prepend in front of bootstrap class path
预先加载zip/jar资源或者类（.class文件）存放目录路径

5、-Xnoclassgc disable class garbage collection
关闭类垃圾回收功能

6、-Xincgc enable incremental garbage collection
开启类的垃圾回收功能

7、-Xloggc:<file> log GC status to a file with time stamps
记录垃圾回日志到一个文件。

8、-Xbatch disable background compilation
关闭后台编译

9、-Xms<size> set initial Java heap size
设置JVM初始化堆内存大小

10、-Xmx<size> set maximum Java heap size
设置JVM最大的堆内存大小

11、-Xss<size> set java thread stack size
设置JVM栈内存大小

12、-Xprof output cpu profiling data
输入CPU概要表数据

13、-Xfuture enable strictest checks, anticipating future default
执行严格的代码检查，预测可能出现的情况

14、-Xrs rece use of OS signals by Java/VM (see

documentation)
通过JVM还原操作系统信号

15、-Xcheck:jni perform additional checks for JNI functions
对JNI函数执行检查

16、-Xshare:off do not attempt to use shared class data
尽可能不去使用共享类的数据

17、-Xshare:auto use shared class data if possible (default)
尽可能的使用共享类的数据

18、-Xshare:on require using shared class data, otherwise fail.
尽可能的使用共享类的数据，否则运行失败

The -X options are non-standard and subject to change without notice.

㈨ 编译器的组成及各部分的功能及作用

1. 词法分析 词法分析器根据词法规则识别出源程序中的各个记号（token），每个记号代表一类单词（lexeme）。源程序中常见的记号可以归为几大类：关键字、标识符、字面量和特殊符号。词法分析器的输入是源程序，输出是识别的记号流。词法分析器的任务是把源文件的字符流转换成记号流。本质上它查看连续的字符然后把它们识别为“单词”。 2. 语法分析 语法分析器根据语法规则识别出记号流中的结构（短语、句子），并构造一棵能够正确反映该结构的语法树。 3. 语义分析 语义分析器根据语义规则对语法树中的语法单元进行静态语义检查，如果类型检查和转换等，其目的在于保证语法正确的结构在语义上也是合法的。 4. 中间代码生成 中间代码生成器根据语义分析器的输出生成中间代码。中间代码可以有若干种形式，它们的共同特征是与具体机器无关。最常用的一种中间代码是三地址码，它的一种实现方式是四元式。三地址码的优点是便于阅读、便于优化。 5. 中间代码优化 优化是编译器的一个重要组成部分，由于编译器将源程序翻译成中间代码的工作是机械的、按固定模式进行的，因此，生成的中间代码往往在时间和空间上有很大浪费。当需要生成高效目标代码时，就必须进行优化。 6. 目标代码生成 目标代码生成是编译器的最后一个阶段。在生成目标代码时要考虑以下几个问题：计算机的系统结构、指令系统、寄存器的分配以及内存的组织等。编译器生成的目标程序代码可以有多种形式：汇编语言、可重定位二进制代码、内存形式。 7 符号表管理 符号表的作用是记录源程序中符号的必要信息，并加以合理组织，从而在编译器的各个阶段能对它们进行快速、准确的查找和操作。符号表中的某些内容甚至要保留到程序的运行阶段。 8 出错处理用户编写的源程序中往往会有一些错误，可分为静态错误和动态错误两类。所谓动态错误，是指源程序中的逻辑错误，它们发生在程序运行的时候，也被称作动态语义错误，如变量取值为零时作为除数，数组元素引用时下标出界等。静态错误又可分为语法错误和静态语义错误。语法错误是指有关语言结构上的错误，如单词拼写错、表达式中缺少操作数、begin和end不匹配等。静态语义错误是指分析源程序时可以发现的语言意义上的错误，如加法的两个操作数中一个是整型变量名，而另一个是数组名等。

㈩ 为什么需要改变编译器

答案如下：
1.编译器是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机可以直接以机器语言来运行此程序,速度很快;
2.解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快的.
3.因为计算机不能直接认识并执行我们写的语句,它只能认识机器语言(是二进制的形式).
4.编译是将源程序翻译成可执行的目标代码，翻译与执行是分开的；而解释是对源程序的翻译与执行一次性完成，不生成可存储的目标代码。这只是表象，二者背后的最大区别是：对解释执行而言，程序运行时的控制权在解释器而不在用户程序；对编译执行而言，运行时的控制权在用户程序。
4.编译器在优化过程中采用了自动或半自动的代码生成用以替代人工优化。人的精力是有限的，通过（接近无限）的算力去适配每一个应用场景看到的网络，改变编译器，这是编译技术比人工路线强的所在。

阅读全文

与编译器优化的作用java相关的资料

热点内容
橙app如何开启聊天 浏览：899
访问服务器公网地址 浏览：666
pdf打印底色去掉 浏览：463
java快递接口 浏览：397
哪个app可以教新爸爸 浏览：210
如何查看服务器系统版本信息 浏览：524
成都市土地出让金算法 浏览：702
钢筋加密标记 浏览：576
ps中扩展功能在文件夹的什么位置 浏览：904
双极压缩机为什么要先高压 浏览：527
苹果手机服务器填什么 浏览：832
android移动动画效果 浏览：691
电子和服务器是什么意思 浏览：691
phpurl中文乱码问题 浏览：893
程序员那么可爱大结局陆漓产子 浏览：538
java如何从云服务器读取本地文件 浏览：924
压缩空气软管制作方法 浏览：912
天河三号算法 浏览：926
php队列教程 浏览：634
洪水命令 浏览：531
  • 情圣插曲泰国歌
  • 爱在榆树下神马影视
  • 斗鱼tv郭mini更衣种子
  • 胖子行动对
  • 歪歪漫画账号vip大全
  • 诱红楼11
  • 吴越在线
  • 金曲捞2之挑战主打歌
  • 黄磊私下挺乱
  • rosi口罩系列破解
  • 黄色a一级
  • 十三邀第三季
  • 两个爸爸泰剧资源
  • 阿德与五大美女四部曲
  • 天狼星行动
  • 444vod
  • mx4参数
  • 老柿子树
  • 魔戒3王者归来完整版
  • 人民的名义11集
  • 母娘乱
  • 宇都宫紫苑高清 在线
  • 前列腺按摩手法图解
  • 纹理烫发型图男
  • 东北抗日联军电视剧
  • 致命复活国语全集
  • 字幕网yellow免费
  • 星际冒险王在线观看
  • 房东趁我出差女友陈伯
  • 长风万里txt
  • 萌漫乡在线动漫
  • 小77大陆论坛永久地址
  • 透明时装表演歨光
  • 射雕英雄传2017年
  • 佐山爱在线观看免费
  • 日本屌丝
  • 寄生兽结局
  • 还我本色
  • 球王
  • 若是如此电视剧
  • 谢霆锋发型图片
  • 夜夜春宵伴儿娇媳
  • 免费的黄页播放器
  • 31vacom棉花糖直播v1
  • 中国功夫
  • 台湾黑道电影
  • 仔仔网日本r动漫
  • 爆肝工程师在线播放
  • 大灌篮演员表
  • 全媒体大开讲
  • 99e热在这里只有精品23
  • x龙时代漫画全集免费
  • 爆丸
  • 香港第一凶宅在线观看
  • vivo什么时候出新款
  • 女主葡萄h下一颗颗
  • 呼啸山乡
  • 爆裂说唱
  • 闫盼盼33套视频百度云
  • 北京档案解密全集
  • 人未尽 杯莫停
  • 月光光心慌慌在线观看
  • 在自己家里玩朋友妻子
  • 韩国潜规视频135部
  • 向前
  • dvd8090cnm免费
  • 悠宝三岁幼儿园
  • 山村风流小子有声小说
  • 乡野情迷之干柴烈火
  • 五香丁香在线观看 大片
  • 保税科技股吧
  • 合肥万达影城影讯
  • 书香门第是什么生肖
  • 母亲的职业在线播放
  • 小姐姐直播改成什么名
  • 日本一级毛网站
  • 4080新觉视电影院大全
  • 镜中奇遇记
  • 美味人3妻高清good
  • 岛城风云
  • 用力点深一点公车小说
  • 奇兵
  • 幺幺见我心txt下载
  • 绝世唐门之死神之瞳
  • 六度影六度影院在线观看
  • 柠檬tv免费观
  • 化教师4
  • 亚洲最大免费网站视频
  • 速度与
  • 极限挑战在线观看
  • 冰与火的青春
  • 一吻定情柏原崇
  • 大猫网电影网
  • 手指最多能插几根
  • 无翼鸟52kkm
  • 光荣岁月
  • 历史进程
  • 垓下之战的过程
  • 脚下奴张斌阿姨踩踏
  • 驭风男孩