This example shows how to sort mixed records in RMS.

 /*
J2ME: The Complete Reference

James Keogh

Publisher: McGraw-Hill

ISBN 0072227109

*/
//jad file (please verify the jar size)
/*
MIDlet-Name: SortMixedRecordDataTypeExample
MIDlet-Version: 1.0
MIDlet-Vendor: MyCompany
MIDlet-Jar-URL: SortMixedRecordDataTypeExample.jar
MIDlet-1: SortMixedRecordDataTypeExample, ,
           SortMixedRecordDataTypeExample
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0
MIDlet-JAR-SIZE: 100

*/

import javax.microedition.rms.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.io.*;

public class SortMixedRecordDataTypeExample 
         extends MIDlet implements CommandListener
{
  private Display display;
  private Alert alert;
  private Form form; 
  private Command exit; 
  private Command start;
  private RecordStore recordstore = null;
  private RecordEnumeration recordEnumeration = null;
  private Comparator comparator = null;
  public SortMixedRecordDataTypeExample ()
  {
    display = Display.getDisplay(this);
    exit = new Command("Exit", Command.SCREEN, 1);
    start = new Command("Start", Command.SCREEN, 1);
    form = new Form("Mixed RecordEnumeration");
    form.addCommand(exit);
    form.addCommand(start);
    form.setCommandListener(this);
  }
  public void startApp()
  {
    display.setCurrent(form);
  }
  public void pauseApp()
  {
  }
  public void destroyApp( boolean unconditional )
  {
  }
  public void commandAction(Command command, Displayable displayable)
  {
    if (command == exit)
    {
      destroyApp(true);
      notifyDestroyed();
    }
    else if (command == start)
    {
      try
      {
        recordstore = RecordStore.openRecordStore(
                   "myRecordStore", true );
      }
      catch (Exception error)
      {
        alert = new Alert("Error Creating", 
                  error.toString(), null, AlertType.WARNING); 
        alert.setTimeout(Alert.FOREVER); 
        display.setCurrent(alert);
      }
      try
      {
        byte[] outputRecord;
        String outputString[] = {"Mary", "Bob", "Adam"};
        int outputInteger[] = {15, 10, 5};
        ByteArrayOutputStream outputStream = 
                new ByteArrayOutputStream();
        DataOutputStream outputDataStream = 
                 new DataOutputStream(outputStream);
        for (int x = 0; x < 3; x++)
        {
          outputDataStream.writeUTF(outputString[x]);
          outputDataStream.writeInt(outputInteger[x]); 
          outputDataStream.flush();               
          outputRecord = outputStream.toByteArray();
          recordstore.addRecord(outputRecord, 0, 
                 outputRecord.length);
          outputStream.reset();
        }  
        outputStream.close();
        outputDataStream.close();
      }
      catch ( Exception error)
      {
        alert = new Alert("Error Writing", 
              error.toString(), null, AlertType.WARNING); 
        alert.setTimeout(Alert.FOREVER); 
        display.setCurrent(alert);
      }
      try
      {
         String[] inputString = new String[3];
         int z = 0;
         byte[] byteInputData = new byte[300]; 
         ByteArrayInputStream inputStream = 
                    new ByteArrayInputStream(byteInputData);
         DataInputStream inputDataStream = 
                    new DataInputStream(inputStream);
         StringBuffer buffer = new StringBuffer();
         comparator = new Comparator();
         recordEnumeration = recordstore.enumerateRecords( 
                             null, comparator, false);
         while (recordEnumeration.hasNextElement())
         { 
          recordstore.getRecord( recordEnumeration.nextRecordId(), 
                                  byteInputData, 0);
          buffer.append(inputDataStream.readUTF());
          buffer.append(inputDataStream.readInt());
          buffer.append("\n");
          inputDataStream.reset();
         }
         alert = new Alert("Reading", buffer.toString(), null, 
                            AlertType.WARNING); 
         alert.setTimeout(Alert.FOREVER); 
         display.setCurrent(alert);
         inputDataStream.close();
         inputStream.close();
      }
      catch (Exception error)
      {
        alert = new Alert("Error Reading", 
                            error.toString(), null, AlertType.WARNING); 
        alert.setTimeout(Alert.FOREVER); 
        display.setCurrent(alert);
      }
      try
      {
        recordstore.closeRecordStore();
      }
      catch (Exception error)
      {
        alert = new Alert("Error Closing", 
                     error.toString(), null, AlertType.WARNING); 
        alert.setTimeout(Alert.FOREVER); 
        display.setCurrent(alert);
      }
      if (RecordStore.listRecordStores() != null)
      {
        try
        {
          RecordStore.deleteRecordStore("myRecordStore");
          comparator.compareClose();
          recordEnumeration.destroy();
        }
        catch (Exception error)
        {
         alert = new Alert("Error Removing", 
                   error.toString(), null, AlertType.WARNING); 
         alert.setTimeout(Alert.FOREVER); 
         display.setCurrent(alert);
        }
      }      
    }
  }     
}
class Comparator implements RecordComparator
{
  private byte[] comparatorInputData = new byte[300];
  private ByteArrayInputStream comparatorInputStream = null;
  private DataInputStream comparatorInputDataType = null;
  public int compare(byte[] record1, byte[] record2)
  {
    int record1int, record2int;
    try
    {
      int maxlen = Math.max(record1.length, record2.length);
      if (maxlen > comparatorInputData.length)
      {
        comparatorInputData = new byte[maxlen];
      }
      comparatorInputStream = new ByteArrayInputStream(record1);
      comparatorInputDataType = 
               new DataInputStream(comparatorInputStream);
      comparatorInputDataType.readUTF();
      record1int = comparatorInputDataType.readInt();  
      comparatorInputStream = new ByteArrayInputStream(record2);
      comparatorInputDataType = 
              new DataInputStream(comparatorInputStream);
      comparatorInputDataType.readUTF();
      record2int = comparatorInputDataType.readInt();  
      if (record1int == record2int)
      {
        return RecordComparator.EQUIVALENT;
      }
      else if (record1int < record2int)
      {
        return RecordComparator.PRECEDES;
      }
      else
      {
        return RecordComparator.FOLLOWS;
      }
    }      
    catch (Exception error)
    { 
      return RecordComparator.EQUIVALENT;
    } 
  }
  public void compareClose()
  {
    try
    {
      if (comparatorInputStream!= null)
      {
        comparatorInputStream.close();
      }
      if (comparatorInputDataType!= null)
      {
        comparatorInputDataType.close();
      }
    }
    catch (Exception error)
    {
    }
  }
}

 

 

 

 

 Related Tips