Limite de tamanho

Galera,
estou tentando gerar um arranjo aleatório de um tipo abstrato, que possui dois campos: ChPrim e ChSec. Só que não estou coseguindo gerar mais do que 10008 registros e NÃO APARECE ERRO NENHUM. Alguem consegue explicar?

package TP1.InterfaceUnica; import java.util.Random; //para gerar valores inteiros aleatórios
import java.io.*; // Permite o uso dos métodos FileReader, BufferedReader
//e FileWriter.
import java.util.*; // Permite o uso do método StringTokenizer.

public class Registros
//Classe responsável pelo tratamento dos registros a serem ordenados.
//Aqui é definido como será o tipo abstrato: seqüencia de caracteres, sendo que
//somente o primeiro caracter da chave primária é maiúsculo.
//Para arquivos recebidos externamente, deve haver um espaço em branco entre
//a chave primária e a secundária
{

public static void main(String[] args)

{
//para testar
int NumRegs=100000;//HÁ LIMITE DE 10.007 registros. Não sei se é memório ou do método. Sugestão: se for maior que 10.000 faz separado e junta depois
int LimTamChPrim=1;
int LimTamChSec=1;

TipoAbstrato[]retorno=GeraRegistros(NumRegs, LimTamChPrim, LimTamChSec);//=new TipoAbstrato[NumRegs];
//retorno=GeraRegistros(NumRegs, LimTamChPrim, LimTamChSec);
// try{
// TipoAbstrato[]retorno=RegArq();}
// catch(IOException ex) {new error ("Arquivo não encontrado","");}
// catch(NullPointerException ex){new error("Arquivo não encontrado",""); }

for(int i=0; i<retorno.length; i++)
System.out.println(retorno[i].ChPrim+"\t\t\t"+ retorno[i].ChSec);

//TipoAbstrato[]teste=new TipoAbstrato[100001];
//for(int i=0; i<teste.length;i++)teste[i]=new TipoAbstrato();
//for(int i=0; i<teste.length;i++)teste[i].ChPrim=i+"";

// System.out.println(teste[teste.length-1].ChPrim);
}

public static TipoAbstrato[] GeraRegistros(int NumRegs, int LimTamChPrim, int LimTamChSec)
//Gera um arranjo do TipoEntrada, contendo uma quantidade determinada de registros. Esses registros são aleatórios em seu conteúdo e tamanho para cada um dos campos Tipo e Subtipo.
{

//fazer tratamento de NumRegs
//fazer tratamento de erro para Limites de tamanho
TipoAbstrato[]retorno=new TipoAbstrato[NumRegs];

//se no for abaixo for gerar tipo e subtipo individualmente
for(int i=0; i<NumRegs;i++)retorno[i]=new TipoAbstrato();

Random CharAleatorio = new Random();//para criar caracteres aleatorios nos campos do tipo abstrato
Random TamanhoAleatorio=new Random();//para que a quantidade desses caracteres seja aleatória
for(int i=0; i<NumRegs; i++)
{
int TamChPrim=GeraNumero(LimTamChPrim, TamanhoAleatorio);//Cria tipo com caracteres aleatórios e tamanho aleatório limitado por LimiteTamTipo
int TamChSec=GeraNumero(LimTamChSec, TamanhoAleatorio);//Cria subtipo com caracteres aleatórios e tamanho alatório limitado por LimiteTamSubtipo

retorno[i].ChPrim=GeraChPrim(TamChPrim, CharAleatorio);
retorno[i].ChSec=GeraChSec(TamChSec, CharAleatorio);

//retorno[i]=new TipoEntrada(GeraTipo(TamTipo, CharAleatorio), GeraSubtipo(TamSubtipo, CharAleatorio));//Faz o mesmo que o método acima, mas de uma só vez e elimina a necessidade do for anterior

}//end for

CharAleatorio=null;
TamanhoAleatorio=null;
return retorno;
}//end GeraRegistros

public static String GeraChPrim (int TamChPrim, Random CharAleatorio)
//Gera o campo ChPrim do TipoEntrada
{
String retorno="";
retorno+=GeraMaiuscula(CharAleatorio);//garante que a primeira letra da chave primária seja minuscula

//completa aleatóriamente a chave primária. pode não ter nada complementado (o que é um episódio aleatorio)
for(int i=1; i<TamChPrim;i++)
retorno+=GeraMinuscula(CharAleatorio);
return retorno;
}//end GeraChPrim

public static String GeraChSec (int TamChSec, Random CharAleatorio)
//Gera o campo ChSec do TipoEntrada
{
String retorno="" ;
retorno+=GeraMinuscula(CharAleatorio); //garante que o a chave secundária irá ter pelo menos uma letra

//completa aleatóriamente a chave secundária. pode não ter nada complementado (o que é um episódio aleatorio)
for(int i=0; i<TamChSec;i++)
retorno+=GeraMinuscula(CharAleatorio);

return retorno;
}//end GeraChSec

public static char GeraMaiuscula (Random CharAleatorio)
//Gera uma letra Maiuscula aleatória
{
byte[]ByteAleatorio=new byte[1];
CharAleatorio.nextBytes(ByteAleatorio); //cria um byte de tamanho aleatório - equivalente a um int de -128 a 256

int ascii=ByteAleatorio[0];
if(ascii<0)ascii=-ascii;//o método nextNytes gera numeros negativos, aqui essa situaçao é tratada eliminando-se o sinal
ascii=(ascii%26)+65;//converte o inteiro para o código ascii de letras maiusculas

char LetraMaiuscula=(char)ascii;//retorna o char que tenha o código ascii encontrado acima
return LetraMaiuscula;
}//end GeraMaiuscula

public static char GeraMinuscula(Random CharAleatorio)
//Gera uma letra minuscula aleatória
{
byte[]ByteAleatorio=new byte[1];//cria um byte de tamanho aleatório - equivalente a um int de -128 a 256
CharAleatorio.nextBytes(ByteAleatorio);

int ascii=ByteAleatorio[0];//converte o byte para um int
if(ascii<0)ascii=-ascii;//o método nextNytes gera numeros negativos, aqui essa situaçao é tratada eliminando-se o sinal
ascii=(ascii%26)+97;//converte o inteiro para o código ascii de letras minusculas

char LetraMinuscula=(char)ascii; //retorna o char que tenha o código ascii encontrado acima
return LetraMinuscula;
}//end GeraMinuscula

public static int GeraNumero(int maximo)
//Gera um numero aleatório. Compartilha o Random com outros métodos
{
//se colocar valor de máximo acima de 256*256 é como se não executasse mod. numero menor que zero dá erro. mÁXIMO IGUAL A ZERO TAMBÉM DÁ ERRO
//if(maximo<=0)**ERRO
Random aleatorio=new Random();
byte[]ByteAleatorio=new byte[2];
aleatorio.nextBytes(ByteAleatorio);

int tamanho=ByteAleatorio[0]*ByteAleatorio[1];
if (tamanho<0)tamanho=-tamanho;
tamanho%=maximo;
return tamanho;
}//end GeraNumero

public static int GeraNumero(int maximo, Random NumeroAleatorio)
//Gera um número aleatório. Não compartilha o Random
{
//se colocar valor de máximo acima de 256*256 é como se não executasse mod. numero menor que zero dá erro. mÁXIMO IGUAL A ZERO TAMBÉM DÁ ERRO
//if(maximo<=0)**ERRO

byte[]ByteAleatorio=new byte[2];//cria dois bytes aleatórios, cada um na faixa de -128 a 256
NumeroAleatorio.nextBytes(ByteAleatorio);

int tamanho=ByteAleatorio[0]*ByteAleatorio[1];
if (tamanho<0)tamanho=-tamanho;//trata casos de sinal negativo aplicando o módulo
tamanho%=maximo;//limita o tamanho no tamanho máximo desejado
return tamanho;
}//end GeraNumero

public static TipoAbstrato[] RegArq () throws IOException, NullPointerException
{
TipoAbstrato[]retorno;

FileReader fr;
BufferedReader br;
String linha;
String aux="";

fr = new FileReader("tp1.txt");
br = new BufferedReader(fr);

linha=br.readLine(); //coloca tudo em uma só linha
while(linha!=null)
{
aux+=linha+"*";
linha=br.readLine();
}

String[]aux2=separa(aux,"*");//separa cada uma das linhas

retorno=new TipoAbstrato[aux2.length];

for(int i=0;i<retorno.length;i++)
{
String[]aux3=separa(aux2[i], " ");
if(aux3.length!=2)//Erro de formatação.
{
new error("Problema de formatação da linha "+i+" Programa será fechado.","");
System.exit(0);
}
retorno[i]=new TipoAbstrato();
retorno[i].ChPrim=aux3[0];
retorno[i].ChSec=aux3[1];
}//end for
fr.close();
br.close();

return retorno;

}

/** Fornecidos uma String com o texto
* que se deseja obter os elementos, e um separador, retorna um
* arranjo de Strings com esses elementos. */
public static String[] separa(String texto, String separador)
{
String[] retorno;
StringTokenizer st;
int numeroDeElementos;

// Obtendo número de elementos em "texto" para iniciar arranjo
// a ser retornado como resposta. Quebra a string em tokens,
// separados por "separador".
st = new StringTokenizer(texto, separador);
numeroDeElementos=0;

while(st.hasMoreTokens())
{numeroDeElementos++; st.nextToken();}

// Identificados quantos elementos a String contém,
// inicia arranjo de retorno.
retorno = new String[numeroDeElementos];

// Obtém os elementos e os armazena em retorno.
// Reinicia quebra do texto em tokens, mas armazenando
// os valores.
st = new StringTokenizer(texto, separador);
for(int i=0;i<numeroDeElementos;i++)
retorno[i] = st.nextToken();

return retorno;
} // end separa()

}

Meu tipo abstrato é:

package TP1.InterfaceUnica;



public class TipoAbstrato 
//Tipo abstrato de dados a ser ordenanado. Consta de uma chave primária e 
//outra secundária. Nessa etapa não e feita qualquer restrição quando ao tipo
//do dado, salvo o fato de que ele será tratado como uma String.
&#123;
   public String ChPrim, ChSec;
       
   //cria nova instancia do tipo. É colocado &quot;&quot; em cada um dos campo para facilitar a concatenaçao;
   //construtor Simples
   public TipoAbstrato&#40;&#41;
   &#123;
      ChPrim=&quot;&quot;;
      ChSec=&quot;&quot;;
   &#125;       
             
   public TipoAbstrato&#40;String a, String b&#41;
  &#123;
    ChPrim=a;
    ChSec=b;
  &#125;   
&#125;

1 Resposta

Topicos relacionados