Errore di compilazione "Codice troppo grande" in Java

Esiste una dimensione massima per il codice in Java? Ho scritto una funzione con più di 10.000 righe. In realtà, ogni riga assegna un valore a una variabile di matrice.

arts_bag[10792]="newyorkartworld";
arts_bag[10793]="leningradschool";
arts_bag[10794]="mailart";
arts_bag[10795]="artspan";
arts_bag[10796]="watercolor";
arts_bag[10797]="sculptures";
arts_bag[10798]="stonesculpture"; 

E durante la compilazione, ottengo questo errore: codice troppo grande

Come posso superarlo?

Un singolo metodo in una classe Java può essere al massimo 64 KB di bytecode.

Ma dovresti ripulirlo!

Usa .propertiesfile per memorizzare questi dati e caricali tramitejava.util.Properties

Puoi farlo inserendo il .propertiesfile nel tuo classpath e usa:

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

Esiste un limite di dimensione del codice byte 64 KB su un metodo

Detto questo, sono d'accordo con Richard; perché hai bisogno di un metodo così ampio? Dato l'esempio nell'OP, dovrebbe essere sufficiente un file delle proprietà ... o anche un database, se necessario.

Secondo la specifica Java Virtual Machine , il codice di un metodo non deve essere più grande di 65536 byte :

Il valore di code_length dell'elemento fornisce il numero di byte codenell'array per questo metodo.

Il valore di code_length deve essere maggiore di zero (poiché la matrice del codice non deve essere vuota) e minore di 65536.

code_lengthdefinisce la dimensione code[]dell'attributo che contiene il bytecode effettivo di un metodo:

L' codearray fornisce i byte effettivi del codice Java Virtual Machine che implementa il metodo.

Sembra un po 'una follia. Non puoi inizializzare l'array leggendo i valori da un file di testo o da qualche altra fonte di dati?

Prova a eseguire il refactoring del codice. Esiste un limite alla dimensione del metodo in Java.

Come accennato in altre risposte, esiste un limite di 64 KB di bytecode per un metodo (almeno nel compilatore java di Sun)

Anche per me avrebbe più senso suddividere quel metodo in più metodi, ognuno dei quali assegna determinate cose correlate all'array (potrebbe avere più senso usare un ArrayList per farlo)

per esempio:

public void addArrayItems()
{
  addSculptureItems(list);
  ...
}

public void addSculptureItems(ArrayList list)
{
  list.add("sculptures");
  list.add("stonesculpture");
}

In alternativa è possibile caricare gli elementi da una risorsa statica se sono corretti come da un file delle proprietà

Mi sono imbattuto in questo problema da solo. La soluzione che ha funzionato per me è stata il refactoring e la riduzione del metodo a parti più gestibili. Come te, ho a che fare con un metodo di quasi 10K linee. Tuttavia, con l'uso di variabili statiche e funzioni modulari più piccole, il problema è stato risolto.

Sembra che ci sarebbe una soluzione migliore, ma usando Java 8, non ce n'è ...

Questo errore a volte si verifica a causa di un codice troppo grande in una singola funzione ... Per risolvere quell'errore, dividi quella funzione in più funzioni, come

//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(){
mySingleFunction_1();
mySingleFunction_2();
mySingleFunction_3();
mySingleFunction_4();
}

Puoi aggiungere un altro metodo per creare spazio per il tuo codice per ulteriore spazio dati, potresti avere un metodo che occupa una grande quantità di spazio dati. Prova a dividere i tuoi metodi perché ho avuto lo stesso problema e risolverlo creando un altro metodo aggiuntivo per gli stessi dati nel mio codice Android Java, Il problema era scomparso dopo averlo fatto.

Ho un enum che fa sì che il file .java abbia una dimensione superiore a 500 KB. Eclipse può costruirlo per qualche motivo; l'ant build.xml esportato da eclipse non può. Sto esaminando questo e aggiornerò questo post.

Poiché esiste un limite di dimensione per i metodi e non si desidera ridisegnare il codice in questo momento, potrebbe essere possibile dividere l'array in 4-5 parti e quindi inserirle in metodi diversi. Al momento della lettura dell'array, chiama tutti i metodi in una serie. Puoi anche mantenere un contatore per sapere quanti indici hai analizzato.

ciò è dovuto a tutto il codice nella soluzione dei metodi singoli: creare più metodi piccoli, quindi questo errore sarà scomparso

ok forse questa risposta è troppo tardi ma penso che in questo modo sia meglio di un altro modo

ad esempio, abbiamo 1000 righe di dati nel codice

1. romperli

   private void rows500() {
        //you shoud write 1-500 rows here
   }
   
   private void rows1000() {
        you shoud write 500-1000 rows here
   }

2. per prestazioni migliori, inserire un "se" nei codici

   if (count < 500) {
       rows500();
   } else if (count > 500) {
       rows1000();
   }

Spero che questo codice ti aiuti