obrigado pessoal pela dica. Quando tiver um tempo vou dar uma olhada nisso. É que eu já tinha feito uma classe que fazia isso, mas por meio da brutalidade, ele provavelmente não é tão eficiente quando esse que voces me indicaram . Fiz assim :transformei um hashtable em array de bytes… sendo que os dados que poderiam ir na hashtable seriam: Hashtable(String, String[][]), sendo String um identificador (tipo uma coluna), e o Strin[][] as linhas, para poder ter quantos dados quiser.
vou colar ele aqui, para se alguem algum dia quiser aproveitar:
os metodos encryptData e decryptData são os que fazem esse trabalho. para otimizar mais ele é preciso trocar string por stringbuffer… se alguem quiser contribuir:
[code]
package Util;
import java.util.Enumeration;
import java.util.Hashtable;
import javax.microedition.rms.InvalidRecordIDException;
import javax.microedition.rms.RecordStore;
import javax.microedition.rms.RecordStoreException;
import javax.microedition.rms.RecordStoreFullException;
import javax.microedition.rms.RecordStoreNotFoundException;
import javax.microedition.rms.RecordStoreNotOpenException;
public class DataBaseManager {
RecordStore recStore;
private static final byte KEY_VALUE = -33;
private static final byte ELEMENT_START = -34;
private static final byte ELEMENT_COMMA = -35;
private static final byte ELEMENT_END = -36;
private static final byte ELEMENT_DIMENSION = -37;
public DataBaseManager(){
}
public DataBaseManager(String recordStore) throws RecordStoreNotFoundException,
RecordStoreFullException, RecordStoreException{
openFile(recordStore);
}
public void deleteRecordStore(String recordStore){
try {
RecordStore.deleteRecordStore(recordStore);
} catch (RecordStoreNotFoundException ex) {
ex.printStackTrace();
} catch (RecordStoreException ex) {
ex.printStackTrace();
}
}
public void openFile(String recordStore) throws
RecordStoreNotFoundException, RecordStoreFullException, RecordStoreException{ //MainOptions
// Abre ou Cria um RecordStore com o nome "LoginOptions"
recStore = RecordStore.openRecordStore(recordStore, true );//, RecordStore.AUTHMODE_PRIVATE, true);
}
public String[] readAllFile() throws
RecordStoreNotOpenException, InvalidRecordIDException, RecordStoreException{
// Lê o conteúdo do RecordStore
byte data[];
int recLength = 0;
String[] item = new String[recStore.getNumRecords()];
for (int recId=1; recId <= recStore.getNumRecords(); recId++){
// O método getRecord retorna o tamanho do registro
data = new byte[recStore.getRecordSize(recId)];
recLength = recStore.getRecord(recId, data, 0);
// Converte para String um array de bytes
//recId-1 pq o rray comeca em 0 mas o recordset comeca em 1
item[recId-1] = new String(data, 0, recLength);
}
return item;
}
public Hashtable readHashtableFile() throws
RecordStoreNotOpenException, InvalidRecordIDException, RecordStoreException{
// Lê o conteúdo do RecordStore
byte data[];
// O método getRecordSize retorna o tamanho array a ser criado
data = new byte[recStore.getRecordSize(1)];
//getRecord() pega o registro e coloca em data[]
data = recStore.getRecord(1);
// Converte para String um array de bytes
//recId-1 pq o rray comeca em 0 mas o recordset comeca em 1
return decryptData(data);
}
public void saveInFile(Object value, int pos) throws
RecordStoreNotOpenException, RecordStoreFullException{
// Converte a String para o array de bytes
byte[] bytes = String.valueOf(value).getBytes();
try {
//se ele nao achar o registro
recStore.getRecord(pos);
recStore.setRecord(pos, bytes, 0, bytes.length);
} catch (InvalidRecordIDException ex) {
try {
//ele cria um novo
recStore.addRecord(bytes, 0, bytes.length);
} catch (RecordStoreException ex1) {
ex1.printStackTrace();
}
} catch (RecordStoreException ex) {
ex.printStackTrace();
}
}
public int saveInFile(String value) throws
RecordStoreNotOpenException, RecordStoreFullException, RecordStoreException{
// Este será o dado a ser guardado
// String newItem = “Record #” + recStore.getNextRecordID();
// Converte a String para o array de bytes
byte[] bytes = value.getBytes();
// Grava o dado no RecordStore e retorna seu registro
return recStore.addRecord(bytes, 0, bytes.length);
}
public int saveInFile(Hashtable hashtable) throws
RecordStoreNotOpenException, RecordStoreFullException, RecordStoreException{
//encryptData vai colocar os dados em um vetor unidimensinal para escre-
//ver os dados no arquivo de forma a poupar mais espaço.
byte[] bytes = encryptData(hashtable);
// Grava o dado no RecordStore e retorna seu registro
return recStore.addRecord(bytes, 0, bytes.length);
}
public void closeRecordStore() throws RecordStoreNotOpenException, RecordStoreException{
recStore.closeRecordStore();
}
public boolean recordStoreIsEmpty() {
try {
if (readAllFile().length == 0){
return true;
}else{
return false;
}
} catch (RecordStoreNotOpenException ex) {
ex.printStackTrace();
} catch (InvalidRecordIDException ex) {
ex.printStackTrace();
} catch (RecordStoreException ex) {
ex.printStackTrace();
}
//caso acontecer um erro ele vai retornar true, que está vaziu
return true;
}
private byte[] encryptData(Hashtable hashtable) {
Enumeration keys = hashtable.keys();
Enumeration elements = hashtable.elements();
String[] stringKeys = new String[hashtable.size()];
Object[] objectStringElements = new Object[hashtable.size()];
for (int i = 0; i < stringKeys.length; i++ ){
stringKeys[i] = (String)keys.nextElement();
// objectStringElements = new Object[((String[])hashtable.get(stringKeys[i])).length];
objectStringElements[i] = elements.nextElement();
}
/**************** Conta quantos bytes o array terá ********************/
int counter = 0;
for (int i = 0; i < stringKeys.length; i++, counter++){
for (int j = 0; j < stringKeys[i].length(); j++){
++counter;
}
++counter;
//for das dimenções nome/numeral quantas dimensoes tem
for (int k = 0; k < ((Object[])objectStringElements[i]).length; k++){
int currentDimension = ((Object[])((Object[])objectStringElements[i])[k]).length;
for (int l = 0; l < currentDimension; l++){
int stringSize = ((String)((Object[])((Object[])objectStringElements[i])[k])[l]).length();
for (int m = 0; m < stringSize; m++){
++counter;
}
++counter;// ver isso
}
//counter;// foi comentado porque precisa
}
}
/**********************************************************************/
int currentDimension2;
byte[] reg = new byte[counter];
for (int i = 0, count = 0; i < stringKeys.length; i++, count++){
reg[count] = KEY_VALUE;
for (int j = 0; j < stringKeys[i].length(); j++){
reg[++count] = (byte) stringKeys[i].charAt(j);
}
reg[++count] = ELEMENT_START;
for (int k = 0; k < ((Object[])objectStringElements[i]).length; k++){
currentDimension2 = ((Object[])((Object[])objectStringElements[i])[k]).length;
for (int l = 0; l < currentDimension2; l++){
int stringSize = ((String)((Object[])((Object[])objectStringElements[i])[k])[l]).length();
for (int m = 0; m < stringSize; m++){
reg[++count] = (byte) ((String)((Object[])((Object[])objectStringElements[i])[k])[l]).charAt(m);
}
reg[++count] = ELEMENT_COMMA;
}
reg[count] = ELEMENT_DIMENSION;
}
reg[count] = ELEMENT_END;
}
return reg;
}
private Hashtable decryptData(byte[] bytesFromDisk) {
Hashtable hash = new Hashtable();
String key = "";
String element = "";
java.util.Vector elements = new java.util.Vector(50, 10);
java.util.Vector dimensions = new java.util.Vector(2, 1);
int CURRENT_TAG = 0;
for (int i = 0; i < bytesFromDisk.length; i++){
switch(bytesFromDisk[i]){
case KEY_VALUE:
//limpa a key da Hashtable
key = "" ;
//salva a tag atual
CURRENT_TAG = KEY_VALUE;
break;
case ELEMENT_START:
//limpa o elemento;
element = "";
//salva a tag atual
CURRENT_TAG = ELEMENT_START;
break;
case ELEMENT_COMMA:
//adiciona no vector
elements.addElement(element);
//limpa o elemento;
element = "";
//salva a tag atual
CURRENT_TAG = ELEMENT_COMMA;
break;
case ELEMENT_DIMENSION:
//adiciona no vector
elements.addElement(element);
//limpa o elemento;
element = "";
//reduz o tamanho do array
elements.trimToSize();
//adiciona o elements no vector das dimesões
dimensions.addElement(elements);
elements = new java.util.Vector(50, 10);
break;
case ELEMENT_END:
//adiciona no vector
elements.addElement(element);
//limpa o elemento;
element = "";
//salva a hashtable, pois tem a chave e todos os elementos completos ]
//reduz o tamanho do array
elements.trimToSize();
dimensions.trimToSize();
//adiciona o elements no vector das dimesões
dimensions.addElement(elements);
String[][] matrix = new String[dimensions.size()][];
for (int z = 0; z < dimensions.size(); z++){
matrix[z] = new String[((java.util.Vector)dimensions.elementAt(z)).size()];
((java.util.Vector)dimensions.elementAt(z)).copyInto(matrix[z]);
}
//devolve os dados em um array de String
//String[] values = new String[elements.size()];
//elements.copyInto(values);
//salva na tabela hash
hash.put(key, matrix);
//tenque zerar o vetor para nao repitir os dados.
elements = new java.util.Vector(50, 10);
dimensions = new java.util.Vector(2, 1);
break;
default:
switch(CURRENT_TAG){
case KEY_VALUE:
key += String.valueOf((char)((int) bytesFromDisk[i]& 0xff));
break;
case ELEMENT_START:
element += String.valueOf((char)((int) bytesFromDisk[i]& 0xff));
break;
case ELEMENT_COMMA:
element += String.valueOf((char)((int) bytesFromDisk[i]& 0xff));
break;
}
break;
}
}
return hash;
}
}[/code]