GC overhead limit excedeed (java heap space excedida)[SOLUCIONADO]

[Eskizoide]

Buenas, estoy trabajando en un problema el cual ya tengo resulto y funcionando con instancias pequeñas, pero al cual cuando le paso un fichero más grande no termina de ejecutarse, acaba saltando un error de "GC overhead limit excedeed" y por más que le aumento la memoria a eclipse sigue fallando, además de que me he puesto la barrita esta en la que ves el heap space que tienes y nunca llega ni a la mitad, y me está molestando un poquito ya porque me estoy quedando atascado aquí cuando lo difícil era resolver el problema. Pongo aquí el código y el error que me dió a ver si alguien puede ayudarme, ¿quizá el problema está en los objetos que creo en la función listPermutations?

He puesto en negrita las líneas que saltan error y donde creo que debe estar el problema

Error:

Código [Seleccionar] Expandir

Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
at java.util.Arrays.copyOf(Unknown Source)
at java.util.ArrayList.toArray(Unknown Source)
at java.util.ArrayList.<init>(Unknown Source)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:117)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.listPermutations(HiddenNumbers.java:114)
at SegundoReto.HiddenNumbers.calculatePossibilities(HiddenNumbers.java:59)
at SegundoReto.HiddenNumbers.calculateNumbers(HiddenNumbers.java:45)
at SegundoReto.HiddenNumbers.<init>(HiddenNumbers.java:29)
at SegundoReto.HiddenNumbers.main(HiddenNumbers.java:130)

Y aquí el código:

Código [Seleccionar] Expandir

package SegundoReto;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class HiddenNumbers {
private String inputFile;
private Scanner reader;
private FileReader fileReader;
private List<Integer> numeros = new ArrayList<Integer>();
private ArrayList<Integer> resultados;
private BufferedWriter writer;

public HiddenNumbers(String fileName) throws IOException {
this.inputFile = fileName;
try {
fileReader = new FileReader(inputFile);
reader = new Scanner(new File(inputFile));
writer = new BufferedWriter(new FileWriter("src/output.txt"));
calculateNumbers();

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public void calculateNumbers() throws IOException {
int limit = Integer.parseInt(reader.nextLine());
for (int i = 1; i <= limit; i++) {
resultados = new ArrayList<Integer>();
int k = 1;
String currentWord =  reader.nextLine();
if (currentWord.length() > 26 | currentWord.length() < 2) System.out.println("Error.La palabra solo puede tener una longitud entre 2 y 26");
else {
writer.write("Case #" + i + ": " + calculatePossibilities(currentWord, k));
writer.newLine();
 }
}
System.out.println("Programa finalizando..");
writer.close();
reader.close();
}

public int calculatePossibilities(String palabra, int k) {
int valor = 0;
for (int i=0; i<palabra.length();i++) {
numeros.add(i);
}
List<List<Integer>> myLists = listPermutations(numeros);

   for (List<Integer> al : myLists) {
    if (al.get(0) == 0) {
           continue;
       }
   
    resultados.add(calculateValue(al));
    /**
       String appender = "";
       for (Integer i : al) {
           System.out.print(appender + i);
           appender = "";
       }
       System.out.println();
       **/
   }
   valor = calculateMinMax(resultados);
   return valor;
}

public int calculateMinMax(ArrayList<Integer> results) {
int max = Collections.max(results);
int min = Collections.min(results);
//System.out.println("El máximo es: " + max + " y el mínimo es " + min);
return (max-min);
}

public int calculateValue(List<Integer> lista) {
System.out.println("La lista es: " + lista + " y tiene un tamaño de " + lista.size());
int exponente= lista.size()-1;
int base = lista.size();
int valor = 0;
//System.out.println("La base es :" + base + " y el exponente es " + exponente);
for (int i = 0;i<lista.size();i++) {
//System.out.println("Vamos a multiplicar " + lista.get(i) + " por " + base + " elevado a " + exponente);
valor += lista.get(i) * (int) Math.pow(base, exponente);
exponente--;
}
System.out.println("Uno de los posibles valores para " + lista + " es " + valor);
return valor;
}

public static List<List<Integer>> listPermutations(List<Integer> list) {

   if (list.size() == 0) {
       List<List<Integer>> result = new ArrayList<List<Integer>>();
       result.add(new ArrayList<Integer>());
       return result;
   }

   List<List<Integer>> returnMe = new ArrayList<List<Integer>>();

   Integer firstElement = list.remove(0);

  [b] List<List<Integer>> recursiveReturn = listPermutations(list);[/b]
   for (List<Integer> li : recursiveReturn) {
       for (int index = 0; index <= li.size(); index++) {
           [b]List<Integer> temp = new ArrayList<Integer>(li);[/b]
           temp.add(index, firstElement);
           returnMe.add(temp);
       }

   }
   return returnMe;
}



public static void main(String[] args) throws IOException {

HiddenNumbers hiddenNumbers = new HiddenNumbers("src/testInput2.txt");
}

}

Y por si alguno lo puede probar en su equipo, aquí les dejo al fichero que le estoy pasando al programa para que trabaje con el:

100
cojhn
qkflsczuantb
qswagdzcpxe
dxwupsqhknfciozgbrtjma
wjxgnyzvbakimqfdt
qmyf
ma
mvongxtqdypsbfjzlhruc
bfujhpnxdgyilowcrqkm
mpuzgkwe
vd
bxdpcirwkvanzmefogsyj
alejmqt
urmnskcjhl
ogqmnte
mqoldkhwfryjutpv
nupolktzdmsv
kvxoecmgnrzuayptjidbwl
cyafdkgivrxpeujhozbm
htfdxycnkserjiz
kxypedsbvhzgfuoqi
htlfusmrvadckgenxiwbzqj
qcjktbhywnoxslrfauzdepmvg
obewgiahkctxmlpsjfnv
fickmtolqndzwvpasreuxb
hxptymkzgbwanvcjedfqoiursl
kogxc
sgomyxhda
lkspxtcweziybaqovhurjfgd
xiokcnydbmjqvu
yxkdanuzwmlerihjcvqpfstb
yneltcsbvwqukdagfjmzx
ofnhgquxiyvwck
ywxzmuvalbscdk
sdp
kozubhaepcw
nbiqztdj
saonctfgjdbkqu
yqomxjedrztbwislvuanphcf
lchrn
hmovs
dfpxhelagvcmoyzbukr
bwmfn
uv
ukbvzfgsnlhxe
rpfhaxoisblezqwydgcuk
cmnjgh
sjx
ivn
kxqwvrlsthfjbngcd
fdx
qkaublyrvpdx
qzcmy
gpjkilhxnou
lxocdniryftqea
fsro
zmajgdihurkoblscnwpqfvxye
ewimuqoxrtcbgf
hqcvrbkmgeindyfszjupaolt
rjstoynlmuvhgebqcpfx
ghymxufkzrdnolitvwep
psvwmuxthdoejcbgkqif
fduvzonmhiglrbcqpetjkx
bnxlckrjhvowmzid
eqy
uwg
ghitqjnslvcpuzwrxbyod
irkwajhnfpmezdgsvutlcoq
ql
vclwinjbteuszfmydokraxpqh
swocbamnhvkuxltrip
dgjyup
ewudxyjlrbs
xmkiawcrfjvhg
rewfybacgpdhvkmqiun
nizrgevt
edxqvj
rzgbp
kxehpdfya
iasdkolztwfgm
lgijk
gyoxqfrhs
agjdluecbohtwqkmxrfpiv
zjgtlyuiwnvkbefrpax
dc
hckpivxoarlsbujfeywgmqtd
bwun
xsiyt
vwygmtho
kjidpnqsmxahglocbztfeuwyr
ialwcbtexghnqmkrdz
qihwso
mnsebatdxzol
xifhogvmbndztueqpalsyj
ry
emvdqkflowijgytcxzaubsr
jhbysenmzoqvluxfpcdw
lipdnmqecousxfrjv
xdzerwgqf
ctubdnxerwiplqgfovahzjyksm

Mil gracias si alguien puede ayudarme, de verdad!!! un saludo

[Serapis]

Solo  he mirado el código por encima, y...
...en cuanto he visto que tratas de crear permutaciones y que el tamaño de palabra le dejas hastas 26 caracteres... me basta.

Ahora te pregunto: serías capaz de decirme cuantas permutaciones totales resultan para un alfabeto de 26 letras + 10 cifras (un alfabeto de 36 caracteres), para palabras de 26 caracteres de largo?. Y una vez calculado el número de permutaciones, multiplícalo por 26, para saber los bytes que ocupará en memoria/disco...

Cuando me digas el resultado, y me cuentes que pretendes que quepa en la memoria de tu equipo, confío que tú mismo entiendas la raíz del problema...

Pásate por este hilo, para responder a tus preguntas y hacer algo eficaz.
https://foro.elhacker.net/abril_negro/abril_negro_spok_simple_production_of_keys-t468239.10.html

[Eskizoide]

Solo  he mirado el código por encima, y...
...en cuanto he visto que tratas de crear permutaciones y que el tamaño de palabra le dejas hastas 26 caracteres... me basta.

Ahora te pregunto: serías capaz de decirme cuantas permutaciones totales resultan para un alfabeto de 26 letras + 10 cifras (un alfabeto de 36 caracteres), para palabras de 26 caracteres de largo?. Y una vez calculado el número de permutaciones, multiplícalo por 26, para saber los bytes que ocupará en memoria/disco...

Cuando me digas el resultado, y me cuentes que pretendes que quepa en la memoria de tu equipo, confío que tú mismo entiendas la raíz del problema...

Pásate por este hilo, para responder a tus preguntas y hacer algo eficaz.
https://foro.elhacker.net/abril_negro/abril_negro_spok_simple_production_of_keys-t468239.10.html

Justo venía a decir que el problema era que no me había parado a pensar en el número de combinaciones posibles. Ya lo solucioné así que se puede cerrar. Gracias!