Esta excepción la lanza la JVM, y especifica que una de las regiones de memoria que gestiona fue consumida, en este caso la memoria HEAP, que es la encargada de alojar los objetos creados, esta memoria es liberada o bien cuando el objeto muere o bien cuando el recolector de basura hace su trabajo.Normalmente antes de lanzarte la excepción OutOfMemoryError, la JVM intenta lanzar el recolector de basura para intentar evitarlo.
Una solución, aunque no es la más óptima es aumentar la memoria de la maquina virtual, esto realmente no soluciona el problema, ya que es tienes un problema con tu código.
Para averiguar en que parte del código puede estar el problema, te recomiendo que quites y añadas funcionalidades a tu código hasta dar con la parte que te provoca el problema, imaginemos que tu código lee un fichero, después de leer hace unas updates en bbdd y finalmente termina sacándonos un informe, puedes ir quitando funcionalidades y ver cuando te da los problemas de memoria y cuando no.
A parte de eso, voy a darte unos consejos sobre el código copiado y como podría ser mejorado.
Tienes como unas 40 variables primitivas declaradas, seguro que puedes agruparlas por funcionalidad y crearte unas cuantas clases, ayudará a que tu código sea mas legible, y sobre todo porque cuando iguales a null los objetos de clase, ayudaras al recolector de basura a eliminarlos de la memoria HEAP.
No he visto en 800 líneas de código ni una excepción capturada, ni una excepción lanzada, las excepciones nos ayudan a afrontar eventos o situaciones inesperadas dándoles el tratamiento necesario para corregir la situación. Tal vez seas estudiante y no halláis trabajado ni con excepciones ni con objetos todavía.
Uso de constantes, importante, sería muy bueno que utilizaras constantes, hay caracteres repetidos innumerables de veces, el día que en vez de comparar con 'a' compares con 'b', tendrás que buscar todas las apariciones de la misma para modificar la comparación, si utilizas constantes, sólo deberás modificar la constante.
Complejidad ciclomática, tu código es totalmente ilegible, la complejidad ciclomática nos permite saber como de legible es un código, te orienta sobre la fiabilidad del mismo, y sobre la complejidad de ser mantenido.
Código Otro:
Ver originalComplejidad Ciclomática Evaluación del Riesgo
1-10 Programa Simple, sin mucho riesgo
11-20 Más complejo, riesgo moderado
21-50 Complejo, Programa de alto riesgo
50 Programa no testeable, Muy alto riesgo
He calculado la complejidad ciclomática de tu código y es de 86 puntos más o menos, básicamente se podría definir como no testeable, de alto riesgo e ilegible.
Buceemos ahora en el código:
Tenemos lo siguiente :
Código Java:
Ver originalvoid resetases2() {
this.i = 0;
while (this.i < 9) {
this.datosaa[this.i] = 0; // _m2 indica datos de la ases 1
this.i++;
}
this.i = 0;
while (this.i < 9) {
this.datosbb[this.i] = 0;
this.i++;
}
this.i = 0;
while (this.i < 9) {
this.datoscc[this.i] = 0;
this.i++;
}
this.i = 0;
while (this.i < 9) {
this.datosdd[this.i] = 0;
this.i++;
}
this.i = 0;
}
Iteras 4 bucles 9 veces y haces exactamente lo mismo en todos ellos, no sería mejor lo siguiente?
Código Java:
Ver originalvoid resetases2() {
this.i = 0;
while (this.i < 9) {
this.datosaa[this.i] = 0; // _m2 indica datos de la ases 1
this.datosbb[this.i] = 0;
this.datoscc[this.i] = 0;
this.datosdd[this.i] = 0;
this.i++;
}
}
Hablemos del equals o equalsIgnoreCase:
Código Java:
Ver originalthis.result.equalsIgnoreCase("ases 1")
Esto esta bien, pero en ningún momento tienes en cuenta que la variable result pueda ser nula, si lo fuera te daría NullPointerException, esa excepción la podrías evitar cambiando el orden de la comparación, algo así como :
Código Java:
Ver original"ases 1".equalsIgnoreCase(this.result)
Ojo con instanciar objetos dentro de los bucles sino es estrictamente necesario.
Hay más cosas que mejorar pero bueno, vete poco a poco mejorando el código y optimizándolo.
Siento no poder ayudarte a ver exactamente donde esta el problema de memoria.
Buena suerte.