Shulou(Shulou.com)06/02 Report--

This article mainly explains "what are the optimization methods of Java skills". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what are the optimization methods of Java skills".

1 general article

The issues discussed in the General Chapter are suitable for most Java applications.

1.1 create an instance of a class without new keywords

When you create an instance of a class with the new keyword, all constructors in the constructor chain are called automatically. But if an object implements the Cloneable interface, we can call its clone () method. The clone () method does not call any class constructors.

In the case of using the design pattern (Design Pattern), if you use the Factory pattern to create an object, it is easy to create a new object instance using the clone () method instead. For example, here is a typical implementation of the Factory pattern:

Public static Credit getNewCredit () {return new Credit ();}

The improved code uses the clone () method, as shown below:

Private static Credit BaseCredit = new Credit (); public static Credit getNewCredit () {return (Credit) BaseCredit.clone ();}

The above ideas are also useful for array processing.

1.2 use non-blocking Istroke O

Non-blocking JDK O API is not supported in older versions. In order to avoid blocking of I pact O, some applications use the method of creating a large number of threads (in better cases, a buffer pool is used). This technique can be seen in many applications that must support concurrent I / O streams, such as Web servers, bidding and auction applications. However, creating a Java thread requires considerable overhead.

JDK 1. 4 introduces the non-blocking iAccord O library (java.nio). If the application requires an earlier version of JDK, there is a package here that supports non-blocking iCandle O.

See the Sun China website "adjusting Java's Icano performance".

1.3 use of exceptions with caution

Exceptions are bad for performance. The first step in throwing an exception is to create a new object. The constructor of the Throwable interface calls a local (Native) method named fillInStackTrace (), and the fillInStackTrace () method checks the stack and collects call trace information. Whenever an exception is thrown, VM must adjust the call stack because a new object is created during processing.

Exceptions can only be used for error handling and should not be used to control program flow.

1.4 do not repeat initialization variables

By default, when you call the constructor of a class, Java initializes the variables to certain values: all objects are set to null, integer variables (byte, short, int, long) are set to 0, float and double variables are set to 0.0, and logical values are set to false. This is especially important when a class derives from another class, because when you create an object with the new keyword, all constructors in the constructor chain are called automatically.

1.5 try to specify the final modifier of the class

Classes with final modifiers are not derivable. In the core API of Java, there are many examples of using final, such as java.lang.String. Specifying final for the String class prevents people from overriding the length () method.

In addition, if you specify a class as final, all methods of that class are final. The Java compiler will look for opportunities to inline (inline) all final methods (this is related to the specific compiler implementation). This can improve performance by an average of 50%.

1.6 try to use local variables

The parameters passed when the method is called and the temporary variables created in the call are stored in the Stack, which is faster. Other variables, such as static variables, instance variables, and so on, are created in the Heap and are slow. In addition, depending on the specific compiler / JVM, local variables may be further optimized. See "using stack variables whenever possible."

1.7 multiplication and division

Consider the following code:

For (val = 0; val < 1000000; val + = 5) {alterX = val * 8; myResult = val * 2;}

Using shift operation instead of multiplication operation can greatly improve performance. The following is the modified code:

For (val = 0; val < 1000000; val + = 5) {alterX = val

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.