Archive for the ‘java-general’ Category

PermGen space Exception in Eclipse

April 25, 2014

Well a quick post. Sometimes Eclipse really go nuts and starts throwing this exception for each and every action :

————————–
Unhandled event loop exception
PermGen space
————————–

You can solve this by editing the eclipse.ini file which is residing in the same directory as the eclipse.exe. Towards the end of the file add this line :

-XX:MaxPermSize=128M

You can give whatever space you like such as 256M or 512M. After this restart your eclipse and forget about the PermGen Space Exception. (I Hope So. :P)

For those who are more interested in permGen, The permanent generation (or permgen) was used for class definitions and associated metadata prior to Java 8. Permanent generation was not part of the heap. The permanent generation was removed from Java 8. Originally there was no permanent generation, and objects and classes were stored together in the same area. But as class unloading occurs much more rarely than objects are collected, moving class structures to a specific area allowed significant performance improvements. In short, PermGen is used by the JVM to hold loaded classes.

For More information on Eclipse permGen space Exception read this : More

Happy Coding Guys…

Apache POI Lost Document Summary Information

April 24, 2013

Being working on Intranet projects, lot of my work runs around exporting records into excel and pdf files. For excel exporting mostly we use Apache POI, the awesome tool to deal with Office files. Recently I came around a problem, where after generating the excel file, while trying to open it , it gave error and the log file states : “Lost document summary information.”.

On inspecting my code, I came across these lines :

byte[] b = report.getBytes();

I was using this byte array to flush to the output. In fact this was causing the problem. On detail research I found out that getBytes() method will not give the complete bytes and some of the bytes are lost. Unfortunately those lost bytes are of the summary information, which was causing Excel to throw error. As a workaround, you can do like this, which solved my problem :

ByteArrayOutputStream bos = new ByteArrayOutputStream();
report.write(bos);
byte[] b = bos.toByteArray();

That’s all for now. Happy Coding. 🙂

Java Optimization Tips

July 27, 2012

When writing Java code it can be easy to make simple mistakes that seem harmless on the surface but, as our applications grow larger, they can show themselves to be slow, resource intensive processes that could use a tune-up. Luckily there are some easy ways to optimize your Java code that you can begin using today. Here, we will introduce you to five of them.

1. Avoid unnecessary casting

Casting, for the new developer, is a way of converting between reference data types. Most casting is done to allow a more generic form of programming where your code will be able to work with all types of objects and classes that are descended from some type of base class.

However, new programmers do not always write these casting statements correctly and are creating a situation where they are improperly casting and creating more overhead for their application in the VM than necessary. An example:

class MyCastingClass {
    public Object myMethod() {
        String myString = "Some data";
        Object myObj = (Object) myString;
        return myObj;
    }
}

Ok, let’s examine the statement Object myObj = (Object) myString; which is violating the unnecessary casting rule. There would be no reason to explicitly cast the string to an Object type since the string class already inherits from Object. Casting also bypasses the safety checks of the Java compiler and can end up causing errors at execution. The proper way to write this code would be:

class MyCastingClass {
    public Object myMethod() {
        return "Some data";
    }
}

Clean, easy to read and maintainable while preserving the rules of the compiler and creating less memory overhead. A very simple fix.

2. Eliminating Common Sub Expressions

A common mistake is the use of the same common sub-expression repeatedly in your code, yet you continue to type it out for each calculation. An Example:

int someNumber = (someValue * number1 / number2) + otherValue;
int someNumber2 = (someValue * number1 / number2) + otherValue2;

You may not realize it but you do this all the time. Performing a calculation that has a portion repeated over and over for each calculation. Because part of the calculation changes each time, you didn’t think to loop it and save yourself some trouble. Instead you are being redundant and slowing down the speed of your calculations. Here is a fix:

final int constantCalculation = (someValue * number1 / number2);
int someNumber = (constantCalculation) + otherValue;
int someNumber2 = (constantCalculation) + otherValue2;

Bingo! By placing the repeated portion of the sub-expression into a constant we can reuse it for multiple calculations without being redundant. A deceptively simple optimization.

3. Use StringBuffer (or StringBuilder) instead of String for non-constant strings.

Since strings are immutable objects and cannot change it creates a lot of overhead when you perform actions with string objects that the compiler must transform in order to interpret. Operations that appear to change string objects are actually creating new ones behind the scenes in order to perform your operation. The overhead on this becomes higher when you use String instead of StringBuffer (or StringBuilder). For Example:

class MyStringClass {
    public void myMethod() {
        String myString = "Some data";
        for (int i = 0; i < 20; i++) {
            myString += getMoreChars();
        }
    }
}  

This is the reason that the StringBuffer class exists, to provide assistance when concatenating strings since a new object would need to be created to transform the string. The new object the compiler will create is of type StringBuffer. A new string object would then be created to copy the finished string at the end of the transformation, thus creating two new objects to perform this simple step.

The difference between StringBuffer and StringBuilder is that the former is thread-safe, which is great in some cases, and an overhead in others. All StringBuffer‘s methods are synchronized. StringBuilder isn’t thread-safe and its methods aren’t synchronized, which is much more performant when you just need to use it as a local variable.

The solution would be to cut out the StringBuffer middle-man and make our own StringBuffer object so the compiler doesn’t have to:

class MyCastingClass {
    public Object myMethod() {
        String myString = "Some data";
        StringBuffer myBuffer = new StringBuffer();
        for (int i = 0; i < 20; i++) {
            myBuffer.append(getMoreChars());
        }
        myString = myBuffer.toString();
    }
}

Voila! By creating our own StringBuffer class the compiler no longer has to create one for us to do the transformation. This means there is now only one new string object being created during this process when we call the toString() method of the buffer to transfer that data to myString.

4. Use Short Circuit Boolean Operators

When making logical checks or tests in your code, the use of short-circuit evaluation will almost always speed up the time it takes to make the evaluation because the compiler does not have to check the second condition. When two expressions are joined by an OR (||) as long as the first one is true the compiler will not check the second condition, it will assume the whole statement to be true. This also works with AND (&&) where the compiler will evaluate the first state and if false, will evaluate the whole statement to false. However, the logical OR (|) does not use the short circuit evaluation.

Using || saves the compiler time by not having to check both conditions because it wouldn’t change the outcome of the statement. Here is an example of what usually happens:

class MyShortCircuitClass {
    public void myMethod() {
        if (someValue.equals("true") | someValue.equals("false")) {
            System.out.println("valid boolean");
        }
    }
}

What ends up happening in the above example is that the compiler has to check both conditions and evaluate a true or false for each even through the OR logic would have made it true if the first condition evaluated to true. Here is a better way to write these kinds of statements:

class MyCastingClass {
    public void myMethod() {
        if ("true".equals(someValue) || "false".equals(someValue)) {
            System.out.println("valid boolean");
        }
    }
}

By using short-circuit evaluation you will speed up the time it takes for the compiler to make boolean logical decisions and thus the overall processing time of your application.

Here’s a table describing four of Java’s boolean operators:

Meaning Short circuit?
&& and yes
& and no
|| or yes
| or no

The && and || operators are short circuit operators. A short circuit operator is one that doesn’t evaluate all of its operands.

5. Use length() instead of equals() to find the length of a string

It seems to be common practice among developers that when testing for an empty string to use the equals() method, like so:

class MyStringClass {
    public boolean myTestMethod() {
        return myString.equals("");
    }
}

The problem here is the sheer overkill taking place by using equals() due to the higher overhead. The issue comes from the implementation of equals() which is designed to test if two objects reference back to the same object class. The alternative, length() (or isEmpty()), just tests to see if the references point to the same underlying object type. This is a much more efficient way if you are just testing for an empty string. You don’t care about object types or if they reference back to the same class, so quit using a sledgehammer to pound the nail. Here is how you should be testing for empty strings:

class MyCastingClass {
    public void myMethod() {
        public boolean myTestMethod() {
            // which really does myString.length() == 0 behind the schenes
            return myString.isEmpty();
        }
    }
}

Using length() provides a much more efficient method for testing for empty strings that does not require object reference overhead from the compiler.

Remember that code optimization doesn’t require fancy tricks and unreadable code. These are often simple changes that you can start making today that will speed up your processing time and make your code better. A lot of optimization is getting into the underlying processing of the compiler and understanding what is taking place in the code that you write. By learning these tips now you can begin to implement them into your solutions every time, thus making you a better developer in the process.

Courtsey : 5 Easy Java Optimization Tips/

Pausing Execution of Java Program

March 31, 2011

Sometimes, we may need to wait for in between the execution of our java program. Thread.sleep() is the best way to do so. A sample code taken directly from Oracle Site :

public static void main(String args[]) throws InterruptedException {
String importantInfo[] = {
“Mares eat oats”,
“Does eat oats”,
“Little lambs eat ivy”,
“A kid will eat ivy too”
};

for (int i = 0; i < importantInfo.length; i++) {
Thread.sleep(4000);
System.out.println(importantInfo[i]);
}
}

Happy Coding 😉

 

Get the version of Java runtime

March 16, 2011

There may be occasions when you will need to do different processing for different servers based on the java versions present. You can simple use the System.getProperty(“java.version”) to get the current java version of the runtime.

public class Test {
public static void main(String[] args){
System.out.println(System.getProperty(“java.version”));
}
}

If you want to get the major minor version of Java you can use :

System.out.println(System.getProperty(“java.class.version”));

Similarly there are a set of system properties which can come handy at many times. To get a complete list of all the java properties, run the following program ::

import java.util.Enumeration;
import java.util.Properties;

public class Test {

public static void main(String[] args){
Properties p = System.getProperties();
Enumeration e = p.propertyNames();
while(e.hasMoreElements()){
String pro = (String) e.nextElement();
System.out.println(pro + ” :: ” + System.getProperty(pro));
}
}
}

Happy Coding 🙂

Splitting string using period or dot or any basic symbol in Java

December 14, 2010

Have you tried splitting a string in Java using the period or dot (.) with the inbuilt method split. On trying str.split(“.”) will give you an array of zero elements. This is because unlike Javascript, java wants a regular expression as the parameter for split method. You can solve this simply by giving regular expression instead of simple ‘.’ like this :

String fieldId = “1.3.0.1.i”;
String[] s = fieldId.split(“\\.”);
System.out.println(“Length of splitted array :: ” + s.length);

The output will show you Length of splitted array :: 5

The same expression applies to comma (,) as well as pipe symbol also  (|).

Just scribbled down the issue I just faced, hope this will come to help for someone like me also.

Happy Coding Guys… 🙂

Redirecting the Eclipse/Flex Builder Console output to a log file

August 17, 2010

Usually we write some Java standalone programs / try to debug some web applications in Eclipse, which will generate lots of SOP / log statements. The console has a limited amount of capacity of displaying logs (even though we can change the capacity). Also if we run it again the previous console output will go away. In these cases we would require the output of the console to be written to one log file in the hard disk. You can do this in the following way :

In the eclipse Run / Debug configurations dialogue box, on the right side, you can see several tabs, where you will provide classpath, parameters, etc.
Click on the last tab, labelled as ‘Common’.
Look for the control group with title ‘Standard input and output’. There you can see one checkbox with label ‘File’.
Checking on this will activate the text box next to it. You can give the path of the log file in that text box.
You can otherwise select a directory from either workspace or file system using the corresponding buttons under that.

Don’t forget to check on the ‘Append’ checkbox if you want the log file to be keep on appending.

Now click on ‘RUN’ and you can see the new log file generated on the selected location.

Happy Coding 🙂

Add / Subtract Date using Calendar

January 7, 2009

Many methods of Date() class is deprecated and the replacement is Calendar class. The following example shows how to display last month’s date.

java.text.SimpleDateFormat dateFormat = new java.text.SimpleDateFormat(“dd-MMMM-yyyy);
Calendar c1 = Calendar.getInstance();
c1.add(Calendar.MONTH,-1);
System.out.println(“Last Month Date : ” + dateFormat.format(c1.getTime()));

Adding Copyright Symbol

December 5, 2008

I was working in java to generate PDF report using itext. There I had one requirement for inserting one copy right symbol at footer. I thought of it to be difficult, but it turned around to be very very simple. Inside the string we need to put “\u00A9” thats all. Copyright symbol is there in your app.

🙂


%d bloggers like this: