java，OutOfMemoryError:java堆空间

本课程旨在确定文本的语言；用户必须输入英语、丹麦语、意大利语和拉丁语的4个文本，然后输入要确定其语言的文本。 控制台说

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at Riconoscimento2.creaTabellaTotale(Riconoscimento2.java:365)
    at Riconoscimento2.main(Riconoscimento2.java:25)

我在运行配置中使用eclipse—我编写的参数—Xms2g-Xmx3g。我不明白问题出在哪里

代码是

 import java.io.*;

import java.util.*;

import prog.io.*;

public class Riconoscimento2 {

public static void main(String[] args) {
            char[] array = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ' '};
            System.out.println("Immetti l'intero n per il calcolo degli n-grammi ");  // questa istruzione richiede di immettere l'intero n 
            BufferedReader sc = new BufferedReader(new InputStreamReader(System.in));
            Scanner in = new Scanner(System.in);
            int n = in.nextInt();
            StringBuffer[] tabellaTotale = creaTabellaTotale(n, array);

            System.out.println("Immetti un testo in inglese, che poi verrà utilizzato come paradigma. Ricordati di non inserire rientri a capo."); // con questa e le successive istruzioni si chiede di immettere dei testi campioni scritti in inglese, danese, italiano, latino

             String testo_inglese ="";
             try{
                 testo_inglese = sc.readLine();
             }catch(IOException e1){
                 System.out.println("Input non corretto. Immetti un testo in inglese. ");
             }




            System.out.println("Immetti un testo in danese, che poi verrà utilizzato come paradigma. Ricordati di non inserire rientri a capo.");



             String testo_danese ="";
             try{
                 testo_danese = sc.readLine();
             }catch(IOException e1){
                 System.out.println("Input non corretto. Immetti un testo in danese. ");
             }






            System.out.println("Immetti un testo in italiano, che poi verrà utilizzato come paradigma. Ricordati di non inserire rientri a capo.");



             String testo_italiano ="";
             try{
                 testo_italiano = sc.readLine();
             }catch(IOException e1){
                 System.out.println("Input non corretto. Immetti un testo in italiano. ");
             }









            System.out.println("Immetti un testo in latino, che poi verrà utilizzato come paradigma. Ricordati di non inserire rientri a capo.");



             String testo_latino ="";
             try{
                 testo_latino = sc.readLine();
             }catch(IOException e1){
                 System.out.println("Input non corretto. Immetti un testo in latino. ");
             }



            System.out.println("Immetti il testo di cui vuoi determinare la lingua. Ricordati di non inserire rientri a capo.");



             String testo ="";
             try{
                 testo = sc.readLine();
             }catch(IOException e1){
                 System.out.println("Input non corretto. Immetti il testo di cui vuoi determinare la lingua. ");
             }



            StringBuffer testo_inglese_formattato = formatta(testo_inglese);   // testo_inglese_formattato rappresenta il testo inglese immesso dall'utente in cui i caratteri non alfabetici sono stati trasformati in spazi 
                                                                               // e sono stati rimossi gli spazi multipli. Lo stesso discorso vale per le righe successive.
            StringBuffer testo_danese_formattato = formatta(testo_danese);
            StringBuffer testo_italiano_formattato = formatta(testo_italiano);
            StringBuffer testo_latino_formattato = formatta(testo_latino);
            StringBuffer testo_formattato = formatta(testo);
            if ( n > testo.length() ) // questo controllo serve per gestire il caso in cui l'intero immesso dall'utente è più lungo della lunghezza del testo
            System.out.println("Hai immesso un intero troppo grande se confrontato al testo");
            else { 

                int[] lista_testo = creaLista(testo_formattato, tabellaTotale, n)   ;                   // questa istruzione crea la sequenza delle occorrenze degli n-grammi presenti nel testo immesso dall'utente e poi formattato
                int[] lista_inglese = creaLista(testo_inglese_formattato, tabellaTotale, n) ;
                int[] lista_danese = creaLista(testo_danese_formattato, tabellaTotale, n)   ;
                int[] lista_italiano = creaLista(testo_italiano_formattato, tabellaTotale, n );
                int[] lista_latino = creaLista(testo_latino_formattato, tabellaTotale, n)   ;
                double scarto_inglese = calcolaScarto(tabellaTotale, testo_formattato, testo_inglese_formattato, n);
                double scarto_danese = calcolaScarto( tabellaTotale, testo_formattato, testo_danese_formattato, n);
                double scarto_italiano = calcolaScarto(tabellaTotale, testo_formattato, testo_italiano_formattato, n);
                double scarto_latino = calcolaScarto(tabellaTotale, testo_formattato, testo_latino_formattato, n);
                double[] v = {scarto_inglese, scarto_danese, scarto_italiano, scarto_latino};
                double min = v[0];                    
                for (int j =0; j<4; j++){    // una volta calcolati gli scarti, si determina lo scarto minimo; il programma 
                    if ( v[j]<min )          // comunicherà poi all'utente che la lingua del testo è quella che ha dato lo scarto minimo.
                        min = v[j];          // Chiaramente si tratta di un procedimento probabilistico, tanto più efficiente quanto più i testi forniti sono lunghi.
                }

                String lingua = "italiano";
                if ( min == v[0])
                    lingua = "inglese";

                if ( min == v[1])
                    lingua = "danese";

                if ( min == v[2])
                    lingua = "italiano";

                if ( min == v[3])
                    lingua = "latino";

                System.out.println("E' molto probabile che il testo inserito sia scritto in " + lingua);
            }

            in.close();
        }

        public static StringBuffer  formatta (String s){  // questo metodo serve per formattare il testo, trasformando i caratteri non alfabetici in spazi
                                                          // ed eliminando gli spazi multipli

        s = s.toLowerCase();
        StringBuffer b = new StringBuffer();
        int m = s.length();
        int conta_spazi = 0;
        StringBuffer h = new StringBuffer(s);
        for (int i = 0; i < m ; i++ ){
        switch(h.charAt(i)) {
        case 'a':
            break;

        case 'A':
            break;

        case 'b':
            break;

        case 'B':
            break;

        case 'c':
            break;

        case 'C':
            break;


        case 'd':
            break;

        case 'D':
            break;

        case 'e':
            break;

        case 'E':
            break;

        case 'f':
            break;

        case 'F':
            break;

        case 'g':
            break;

        case 'G':
            break;

        case 'h':
            break;

        case 'H':
            break;

        case 'i':
            break;

        case 'I':
            break;

        case 'j':
            break;

        case 'J':
            break;

        case 'k':
            break;

        case 'K':
            break;

        case 'l':
            break;

        case 'L':
            break;

        case 'm':
            break;

        case 'M':
            break;

        case 'n':
            break;

        case 'N':
            break;

        case 'o':
            break;

        case 'O':
            break;

        case 'p':
            break;

        case 'P':
            break;

        case 'q':
            break;

        case 'Q':
            break;

        case 'r':
            break;

        case 'R':
            break;

        case 's':
            break;

        case 'S':
            break;

        case 't':
            break;

        case 'T':
            break;

        case 'u':
            break;

        case 'U':
            break;

        case 'v':
            break;

        case 'V':
            break;

        case 'w':
            break;

        case 'W':
            break;

        case 'x':
            break;

        case 'X':
            break;

        case 'y':
            break;

        case 'Y':
            break;

        case 'z':
            break;

        case 'Z':
            break;

        default:
            h.setCharAt(i, ' ');


        }
        }
        for (int i = 0; i < m ; i++ ){

            if ( h.charAt(i) == ' ' )
            conta_spazi++;
            else
                conta_spazi = 0;

            if ( conta_spazi <= 1)
            b = b.append(h.charAt(i));

          }

        return b;

        }


        public static int[] creaLista (StringBuffer str , StringBuffer[] tabella, int n){   

            int[] tavolaOccorrenze = new int[pow(27,n)];

            for(int i =0; i < pow(27, n); i++ ) 
            tavolaOccorrenze[i] = numeroOccorrenze(str, tabella[i]);



            return tavolaOccorrenze;

        }

        public static double calcolaFrequenza( int[] tavolaOccorrenze, StringBuffer testo, String st, int n){ 

            double tot = 0;
            for(int i =0; i < pow(27, n); i++ )
                tot += tavolaOccorrenze[i];
            double frequenza = 0;
            double occorrenze_st = numeroOccorrenze(testo, new StringBuffer(st));
            return occorrenze_st / tot;

        }

        public static double calcolaScarto (StringBuffer[] tabella, StringBuffer testo1, StringBuffer testo2, int n){  

            double scarto = 0;
            int[] tavolaOccorrenze1 = creaLista(testo1, tabella, n);
            int[] tavolaOccorrenze2 = creaLista(testo2, tabella, n);
            for(int i =0; i < pow(27, n); i++ )
                scarto += Math.pow(calcolaFrequenza(tavolaOccorrenze1, testo1, tabella[i].toString(), n)-calcolaFrequenza(tavolaOccorrenze2, testo2, tabella[i].toString(), n), 2);

            return scarto;
        }


        public static StringBuffer[] creaTabellaTotale(int n, char[] a) {   /* questa funzione crea la tabella che definisce l'ordine degli n-grammi*/


             StringBuffer[] tabella = new StringBuffer[ pow(27, n)];

             for(int h = 1; h <= n ; h++){
                for(int u =0; u < pow ( 27, h-1); u++){

                for (int j = 0; j<27; j++){

                    for( int x =pow(27, n-h+1)*u + pow(27, n-h)*j; x< pow(27, n-h+1)*u + pow(27, n-h)*(j+1); x++)
                        tabella[x] = tabella[x].append(a[j]);
                }

                }

             }

             return tabella;
        }


        public static int pow(int a, int b){                                            
              int tot = 1;
              for(int i =0; i<b ; i++)
              tot = a * tot ;
              return tot;
             }


         public static int numeroOccorrenze ( StringBuffer testo, StringBuffer parola){   
             int tot =0;
             if(parola.length() > testo.length())
                System.out.println("L' n-gramma da cercare è troppo lungo in confronto al testo inserito ");
             else{
                int n = parola.length();
                for(int i = 0; i <= testo.length() - n; i++ ){
                    if(testo.substring(i,i+n) == parola.toString())
                        ++tot;
                }


             }

             return tot;
            }



     }

import java.io.*；
导入java.util.*；
导入程序io.*；
公共级Riconosciment2{
公共静态void main（字符串[]args）{
char[]数组={'a'，'b'，'c'，'d'，'e'，'f'，'g'，'h'，'i'，'j'，'k'，'l'，'m'，'n'，'o'，'p'，'q'，'r'，'s'，'t'，'u'，'v'，'w'，'x'，'y'，'z'，''}；
System.out.println（“Immetti l'intero n per il calcolo degli n-GRAMI”）；//IMMETTER l'intero n中的istruzione richiede
BufferedReader sc=新的BufferedReader（新的InputStreamReader（System.in））；
扫描仪输入=新扫描仪（系统输入）；
int n=in.nextInt（）；
StringBuffer[]tabellaTotale=CreateAbellaTotale（n，数组）；
System.out.println（“inglese中的Immetti un testo，che poi verráutilizato come paradigma.Ricordati di non inserire rientri a capo.”；//关于inglese、danese、italiano、latino中的Immeter dei testi campioni Scretti的后续问题
字符串testo_inglese=“”；
试一试{
testo_inglese=sc.readLine（）；
}捕获（IOE1异常）{
System.out.println（“在inglese中输入非corretto.Immetti un testo”）；
}
System.out.println（“丹麦语中的Immetti un testo，che poi verráutilizza come paradigma.Ricordati di non inserire rientri a capo.”）；
字符串testo_danese=“”；
试一试{
testo_danese=sc.readLine（）；
}捕获（IOE1异常）{
System.out.println（“输入非corretto.Immetti-un-testo-in-danese.”）；
}
System.out.println（“意大利语中的Immetti un testo，che poi verráutilizza to come paradigma.Ricordati di non inserire rientri a capo.”）；
字符串testo_意大利语=”；
试一试{
testo_意大利语=sc.readLine（）；
}捕获（IOE1异常）{
System.out.println（“用意大利语输入非corretto.Immetti un testo”）；
}
System.out.println（“拉丁语中的Immetti un testo，che poi verráutilizaza to come paradigma.Ricordati di non inserire rientri a capo.”）；
字符串testo_latino=“”；
试一试{
testo_latino=sc.readLine（）；
}捕获（IOE1异常）{
System.out.println（“输入拉丁语中的非corretto.Immetti un testo”）；
}
System.out.println（“非插入式capo中的语言测试结果”）；
字符串testo=“”；
试一试{
testo=sc.readLine（）；
}捕获（IOE1异常）{
System.out.println（“输入非正确的Immetti il testo di cui vuoi determinatore la lingua.”）；
}
StringBuffer testo_inglese_formattato=formatta（testo_inglese）；//testo_inglese_formattato rappresenta il testo inglese Immeso dall'tente在spazi的非阿尔法贝蒂奇sono stati trasformati中
//这是一个多功能的声纳站，它的每一个角落都有不同的声音。
StringBuffer testo_danese_formattato=formatta（testo_danese）；
StringBuffer testo_italiano_formattato=formatta（testo_italiano）；
StringBuffer testo_latino_formattato=formatta（testo_latino）；
StringBuffer testo_formattato=formatta（testo）；
if（n>testo.length（）//ques to controller to serve per gestire il caso in cui l'intero immesso dall'uenteèpiùlunggo della lunghezza del testo
System.out.println（“Hai immesso un intero troppo grande se conferentato al testo”）；
否则{
int[]lista_testo=creaLista（testo_formattato，tabellotale，n）；//语法呈现的顺序是如何在数据格式和数据格式之间进行测试
int[]lista_inglese=creaLista（testo_inglese_formattato，tabellotale，n）；
int[]lista_danese=creaLista（testo_danese_formattato，tabellotale，n）；
int[]lista_italiano=creaLista（testo_italiano_formattato，tabellaTotale，n）；
int[]lista_latino=creaLista（testo_latino_formattato，tabellaTotale，n）；
双scarto_inglese=calcolaScarto（表列，格式测试，格式测试，n）；
double scarto_danese=calcolaScarto（表列、格式测试、格式测试，n）；
double scarto_italiano=calcolaScarto（tabellaTotale，testo_formattato，testo_italiano_formattato，n）；
双重scarto_latino=calcolaScarto（表列、格式测试、格式测试，n）；
双[]v={scarto_inglese，scarto_danese，scarto_意大利人，scarto_拉丁人}；
双最小值=v[0]；
对于（int j=0；j对于初学者，您没有关闭输入流，我看不到对in.close（）的任何调用。为什么不尝试添加它，保存，然后关闭正在运行的jre以释放可能仍在内存中的输入流连接，然后再次运行它？
这一行引发异常：

StringBuffer[] tabella = new StringBuffer[pow(27, n)];

为什么？嗯，你的函数
pow（a，b）
是正确的，但是
n
变量有点不正确。你从那里读取它：

n = in.read();

这将为您在控制台中输入的字符提供ascii码，而不是数字。如果您写入“1”，则
n
将为49，而pow（27，4