Code too large error in java

Chirag’s Computer Blog

Today while browsing through the internet, I found a very strange thing. I am sure it will be a very new and unknown fact for most of the java programmers, even the well experienced ones. The reason is because while working on a project, problem of this type does not occur very often. Now what kind of problem am I talking about? Well, most of you must have had a slight idea by looking at the title of the post. It says something when we have written a very large code and the compiler produces the error. Here is the snapshot of what I tried myself after reading this thing on internet:

C:\Documents and Settings\chirag.jain\Desktop>javac LargeCode.java
LargeCode.java:3: code too large
void largeMethod()
1 error

So does the java compiler enforces any limitation on the size of the code? The answer is yes, and that boundary is 65536 Bytes. This limitation is not on the size of whole file, but on a single method.
Now lets us delve a bit in the details. When we compile a java source file(.java file), compiler produces the byte code in .class file. When the size of the byte code of a single method crosses 65536 bytes, the compiler is not able to compile that method, and gives “code too large” error for that particular method.
Now here is one thing to notice. The overall size of your class file can grow more than 65536 bytes, but the byte code for a single method should not be more than this. Notice that here I am getting this error for a method named largeMethod(), not for the whole file.
Now for the folks who want to try this by themselves. First thing is how would you generate such a large amount of code. Although there are some code generation tools like Groovy, but these are for large projects. To try it by yourselves, you can do what I did. Here is my code:

class WriteFile
<
public static void main(String args[])
<
BufferedWriter bw=null;
try <
File f= new File(«LargeCode.java»);
FileWriter fr= new FileWriter(f);
bw= new BufferedWriter(fr);
String s= «System.out.println(\»hello\»);»;
for(int i=0;i <10000;i++)
<
bw.write(s);
>

Here I have generated a new file using java IO API. It writes the statement
System.out.println(«hello»);
10,000 times in a separate file. Now you can add other things (class name, method name) to compile the program. If you write the whole code in a single method and compile it, you will get the error.

Источник

How to fix «code too large» compilation error in java?

The «Code too large» error in Java occurs when the compiled code size exceeds the limit set by the Java Virtual Machine (JVM). This error can be encountered when trying to compile and run large applications or when trying to build applications with excessive use of anonymous inner classes or string literals. The error can be frustrating and can prevent the application from being compiled and executed. However, there are several ways to overcome this error and get the application up and running again.

Method 1: Split the Code into Multiple Classes

One of the common compilation errors in Java is the «Code too large» error. This error occurs when a single Java file has too much code in it, typically over 64KB. To fix this error, we can split the code into multiple classes. Here’s how to do it:

Step 1: Identify the code to be split

First, we need to identify the code that needs to be split. Look for large methods or inner classes that can be moved to their own files.

Step 2: Create new classes

Next, we create new classes for the code that we identified in step 1. Each new class should have a meaningful name that describes its purpose.

// File: MyClass.java public class MyClass  // . > // File: MyLargeMethod.java public class MyLargeMethod  // . > // File: MyInnerClass.java public class MyInnerClass  // . >

Step 3: Move the code

Now, we move the code from the original file to the new classes. We can use the extends keyword to inherit from the original class.

// File: MyClass.java public class MyClass  // . > // File: MyLargeMethod.java public class MyLargeMethod extends MyClass  // . > // File: MyInnerClass.java public class MyInnerClass extends MyClass  // . >

Step 4: Update the original class

Finally, we need to update the original class to use the new classes. We can create instances of the new classes and call their methods.

// File: MyClass.java public class MyClass  private MyLargeMethod largeMethod; private MyInnerClass innerClass; public MyClass()  largeMethod = new MyLargeMethod(); innerClass = new MyInnerClass(); > public void doSomething()  largeMethod.doSomething(); innerClass.doSomething(); > >

By splitting the code into multiple classes, we can avoid the «Code too large» error and make our code more modular and maintainable.

Method 2: Use Proguard for Code Optimization and Shrinking

Proguard is a free, open-source tool that can be used to optimize and shrink Java code. It can help to reduce the size of the compiled code and make it more efficient. In this tutorial, we will show you how to use Proguard to fix the «Code too large» compilation error in Java.

Step 1: Add Proguard to your project

To use Proguard, you need to add it to your project. You can download the latest version of Proguard from the official website (https://www.guardsquare.com/en/products/proguard). Once you have downloaded Proguard, extract the files to a directory of your choice.

Step 2: Configure Proguard

Next, you need to configure Proguard to optimize and shrink your code. You can do this by creating a Proguard configuration file. Here is an example configuration file:

-injars your_input_jar.jar -outjars your_output_jar.jar -libraryjars path/to/your/library.jar -dontoptimize -dontobfuscate -dontwarn -keep public class com.yourcompany.yourpackage.** < public *; >-keep public interface com.yourcompany.yourpackage.**

This configuration file tells Proguard to:

• Input the jar file you want to optimize and shrink (-injars)
• Output the optimized and shrunk jar file (-outjars)
• Use the library jar file (-libraryjars)
• Don’t optimize the code (-dontoptimize)
• Don’t obfuscate the code (-dontobfuscate)
• Don’t show warnings (-dontwarn)
• Keep all public classes and interfaces in your package (-keep)

You can customize this configuration file to suit your needs.

Step 3: Run Proguard

Once you have configured Proguard, you can run it to optimize and shrink your code. Here is an example command to run Proguard:

java -jar path/to/proguard.jar @path/to/your/configuration/file.pro

This command tells Java to run Proguard and use the configuration file you created.

Method 3: Refactor the Code to Use StringBuilder Instead of Concatenation

When you encounter a «Code too large» error during compilation in Java, you can refactor your code to use StringBuilder instead of concatenation to reduce the size of the compiled code.

Here’s an example of how to refactor your code to use StringBuilder:

String result = ""; for (int i = 0; i  10000; i++)  result += i + " "; >

Refactored code using StringBuilder:

StringBuilder sb = new StringBuilder(); for (int i = 0; i  10000; i++)  sb.append(i).append(" "); > String result = sb.toString();

The StringBuilder class provides a more efficient way to concatenate strings because it modifies the same StringBuilder object instead of creating a new String object each time. The append() method is used to add characters or strings to the StringBuilder object. The toString() method is used to convert the StringBuilder object to a String object.

Here are the steps to refactor your code to use StringBuilder:

1. Create a StringBuilder object.
2. Replace the concatenation operator (+) with the append() method to add characters or strings to the StringBuilder object.
3. Use the toString() method to convert the StringBuilder object to a String object.

By following these steps, you can reduce the size of the compiled code and avoid the «Code too large» error during compilation in Java.

Method 4: Reduce the Number of Anonymous Inner Classes

One way to fix the «Code too large» compilation error in Java is to reduce the number of anonymous inner classes. Anonymous inner classes can quickly increase the size of the compiled code and cause this error.

Here’s an example of a class that uses anonymous inner classes:

public class MyClass < public void doSomething() < ActionListener listener = new ActionListener() < public void actionPerformed(ActionEvent e) < // do something >>; JButton button = new JButton("Click me"); button.addActionListener(listener); // more code > >

To reduce the number of anonymous inner classes, you can extract the inner class into a separate class. Here’s an example of how to do this:

public class MyClass < public void doSomething() < ActionListener listener = new MyActionListener(); JButton button = new JButton("Click me"); button.addActionListener(listener); // more code >private class MyActionListener implements ActionListener < public void actionPerformed(ActionEvent e) < // do something >> >

By extracting the inner class, you have reduced the number of anonymous inner classes in your code. This can help to reduce the size of the compiled code and prevent the «Code too large» compilation error.

In summary, to fix the «Code too large» compilation error in Java, you can reduce the number of anonymous inner classes. This can be done by extracting the inner class into a separate class.

Method 5: Increase the JVM Maximal Size Limit

One way to fix the «Code too Large» compilation error in Java is to increase the JVM maximal size limit. This can be done by adding the -J-Xmx option to the javac command, followed by the desired maximum size in bytes.

Here is an example command that sets the maximum size to 2 gigabytes:

Alternatively, you can set the maximum size to a percentage of the available memory on your system by using the -J-Xmx% option, followed by the desired percentage:

This sets the maximum size to 50% of the available memory.

It is important to note that increasing the maximal size limit can have performance implications, as it may cause the JVM to use more memory and potentially slow down your application. Therefore, it is recommended to only increase the limit if absolutely necessary.

That’s it! By increasing the JVM maximal size limit, you should be able to fix the «Code too Large» compilation error in Java.

Источник

«Code too large» compilation error in Java

A single method in a Java class may be at most 64KB of bytecode.

But you should clean this up!

Use .properties file to store this data, and load it via java.util.Properties

You can do this by placing the .properties file on your classpath, and use:

Properties properties = new Properties(); InputStream inputStream = getClass().getResourceAsStream("yourfile.properties"); properties.load(inputStream); 

Solution 2

There is a 64K byte-code size limit on a method

Having said that, I have to agree w/Richard; why do you need a method that large? Given the example in the OP, a properties file should suffice . or even a database if required.

Solution 3

The value of the code_length item gives the number of bytes in the code array for this method.

The value of code_length must be greater than zero (as the code array must not be empty) and less than 65536.

code_length defines the size of the code[] attribute which contains the actual bytecode of a method:

The code array gives the actual bytes of Java Virtual Machine code that implement the method.

Solution 4

This seems a bit like madness. Can you not initialize the array by reading the values from a text file, or some other data source?

Solution 5

This error sometimes occur due to too large code in a single function. To solve that error, split that function in multiple functions, like

//Too large code function private void mySingleFunction() < . . 2000 lines of code >//To solve the problem private void mySingleFunction_1() < . . 500 lines of code >private void mySingleFunction_2() < . . 500 lines of code >private void mySingleFunction_3() < . . 500 lines of code >private void mySingleFunction_4() < . . 500 lines of code >private void MySingleFunction()

Источник