这个函数已反复应用于多个手机应用软件平台

用法：参数定义：str——要分割的字符串
                        font——字体
                        rowMaxW——分割后每行宽度
         支持标示符：
         \n    换行
         \t     插入两个汉字长度的空格

public static final String[] clipString(String str,Font font,int rowMaxW){
  if(str == null)
   return null;
  if(rowMaxW < font.charWidth('哈'))
   rowMaxW = font.charWidth('哈');         
  int strID = 0;
  int rowW = 0;
  Vector strManager = new Vector();
  char ch = ' ';
  while(str.length() > strID){
   ch = str.charAt(strID);
   switch(ch)
   {
   case '\n':
    strManager.addElement(str.substring(0,strID));
    str = str.substring(strID+1);
    rowW = 0;
    strID = 0;
    break;
   case '\t':
    StringBuffer sb = new StringBuffer(str);
    sb.deleteCharAt(strID);
    sb.insert(strID,"       ");
    str = sb.toString();
    break;
   default:
    if(rowW + font.charWidth(ch) > rowMaxW){
     strManager.addElement(str.substring(0,strID));
     str = str.substring(strID);
     rowW = 0;
     strID = 0;
    }else{
     rowW += font.charWidth(ch);
     strID++;
    }
   }
  }
  strManager.addElement(str);
  String[] o_Str = new String[strManager.size()];
  strManager.copyInto(o_Str);
  return o_Str;
}



返回结果是一个已切割好的String数组，只要用一个循环打印出来就可以了
public static final void drawClipString(Graphics g,String[] clipStr,Font font,int color,int x,int y){
  if(clipStr == null){
     System.out.println("drawClipString");
     return;
  }
  int FONTH = font.getHeight();
  g.setFont(font);
  g.setColor(color);
  for(int i=0;i<clipStr.length;i++)
     g.drawString(clipStr[ i ],x,y+i*FONTH,0);
}

参数定义：clipStr——先前分割好的字符串数组
               font——字体
               color——颜色
               x,y——打印的屏幕位置

注意，切割和打印函数的字体参数必须保持一致！

半透明技术（限MIDP2.0）

// 获得半透明图片，透明度从0到10共分为11个等级
public static final Image alfImage(Image img,int alf){
  if(img == null){
   System.out.println("alfImage");
   return null;
  }
  if(alf < 0)
   alf = 0;
  else if(alf > 10)
   alf = 10;
  int imgW = img.getWidth();
  int imgH = img.getHeight();
  int[] RGBData = new int[imgW*imgH];
  img.getRGB(RGBData,0,imgW,0,0,imgW,imgH);
  int tmp = ((alf*255/10) << 24)|0x00ffffff;
  for(int i=0;i<RGBData.length;i++)
   RGBData &= tmp;
  Image o_Img = Image.createRGBImage(RGBData,imgW,imgH,true);
  return o_Img;
}

灰度图转化函数// 得到灰度图
public static final Image grayImage(Image img){
  if(img == null){
   System.out.println("grayAlfImage");
   return null;
  }
  int imgW = img.getWidth();
  int imgH = img.getHeight();
  int[] imgRGBData = new int[imgW*imgH];
  img.getRGB(imgRGBData,0,imgW,0,0,imgW,imgH);
  int ALF = 0;
  int R = 0;
  int G = 0;
  int B = 0;
  int GRAY = 0;
  for(int i=0;i<imgRGBData.length;i++){
   ALF = (imgRGBData >> 24) & 0xFF;
   R = (imgRGBData >> 16) & 0xFF;
   G = (imgRGBData >> 8) & 0xFF;
   B = imgRGBData & 0xFF;
   GRAY = (R*77+G*151+B*28 + 128)>>8;
   imgRGBData = (ALF<<24)|(GRAY<<16)|(GRAY<<8)|GRAY;
  }
  return Image.createRGBImage(imgRGBData,imgW,imgH,true);
}

在本系列文章的第四部分中，您学会如何遍历一个记录存储，按照有用的次序排序记录，以及使用过滤器选择期望的记录。本文探索各种用于发现符合指定准则的一个或多个记录的策略。

搜索策略

很明显，搜索一个特定记录或者记录集合的最简单方式是使用过滤器。该过滤器需要知道数据是如何存储在一个记录中的，因此您将希望在任何可能的情况下重用您的数据映射类。例如，在第 3 部分中我们定义 FieldList 和 FieldBasedStore 类来处理读写任意数据到一个记录存储。进行一下重构，我们可以将不是特定于记录存储的代码移动到一个新的基类，FieldBasedRecordMapper：

package j2me.rms;

import java.io.*;
import javax.microedition.rms.*;
import j2me.io.*;

// A base class for writing and reading arbitrary
// data as defined by a FieldList

public abstract class FieldBasedRecordMapper {

    // Some useful constants

    public static Boolean TRUE = new Boolean( true );
    public static Boolean FALSE = new Boolean( false );

    // Markers for the types of string we support

    private static final byte NULL_STRING_MARKER = 0;
    private static final byte UTF_STRING_MARKER = 1;

    // Constructs the mapper for the given list

    protected FieldBasedRecordMapper(){
    }

    // Prepares for input by setting the data buffer.

    protected void prepareForInput( byte[] data ){
        if( _bin == null ){
            _bin = new DirectByteArrayInputStream( data );
            _din = new DataInputStream( _bin );
        } else {
            _bin.setByteArray( data );
        }
    }

    // Prepares the store for output. The streams are reused.

    protected void prepareForOutput(){
        if( _bout == null ){
            _bout = new DirectByteArrayOutputStream();
            _dout = new DataOutputStream( _bout );
        } else {
            _bout.reset();
        }
    }

    // Reads a field from the buffer.

    protected Object readField( int type ) throws IOException {
        switch( type ){
            case FieldList.TYPE_BOOLEAN:
                return _din.readBoolean() ? TRUE : FALSE;
            case FieldList.TYPE_BYTE:
                return new Byte( _din.readByte() );
            case FieldList.TYPE_CHAR:
                return new Character( _din.readChar() );
            case FieldList.TYPE_SHORT:
                return new Short( _din.readShort() );
            case FieldList.TYPE_INT:
                return new Integer( _din.readInt() );
            case FieldList.TYPE_LONG:
                return new Long( _din.readLong() );
            case FieldList.TYPE_STRING: {
                byte marker = _din.readByte();
                if( marker == UTF_STRING_MARKER ){
                    return _din.readUTF();
                }
            }
        }

        return null;
    }

    // Converts an object to a boolean value.

    public static boolean toBoolean( Object value ){
        if( value instanceof Boolean ){
            return ((Boolean) value).booleanValue();
        } else if( value != null ){
            String str = value.toString().trim();

            if( str.equals( "true" ) ) return true;
            if( str.equals( "false" ) ) return false;

            return( toInt( value ) != 0 );
        }

        return false;
    }

    // Converts an object to a char.

    public static char toChar( Object value ){
        if( value instanceof Character ){
            return ((Character) value).charValue();
        } else if( value != null ){
            String s = value.toString();
            if( s.length() > 0 ){
                return s.charAt( 0 );
            }
        }

        return 0;
    }

    // Converts an object to an int. This code
    // would be much simpler if the CLDC supported
    // the java.lang.Number class.

    public static int toInt( Object value ){
        if( value instanceof Integer ){
            return ((Integer) value).intValue();
        } else if( value instanceof Boolean ){
            return ((Boolean) value).booleanValue() ? 1 : 0;
        } else if( value instanceof Byte ){
            return ((Byte) value).byteValue();
        } else if( value instanceof Character ){
            return ((Character) value).charValue();
        } else if( value instanceof Short ){
            return ((Short) value).shortValue();
        } else if( value instanceof Long ){
            return (int) ((Long) value).longValue();
        } else if( value != null ){
            try {
                return Integer.parseInt( value.toString() );
            }
            catch( NumberFormatException e ){
            }
        }

        return 0;
    }

    // Converts an object to a long. This code
    // would be much simpler if the CLDC supported
    // the java.lang.Number class.

    public static long toLong( Object value ){
        if( value instanceof Integer ){
            return ((Integer) value).longValue();
        } else if( value instanceof Boolean ){
            return ((Boolean) value).booleanValue() ? 1 : 0;
        } else if( value instanceof Byte ){
            return ((Byte) value).byteValue();
        } else if( value instanceof Character ){
            return ((Character) value).charValue();
        } else if( value instanceof Short ){
            return ((Short) value).shortValue();
        } else if( value instanceof Long ){
            return ((Long) value).longValue();
        } else if( value != null ){
            try {
                return Long.parseLong( value.toString() );
            }
            catch( NumberFormatException e ){
            }
        }

        return 0;
    }

    // Writes a field to the output buffer.

    protected void writeField( int type, Object value )
                                 throws IOException {
        switch( type ){
            case FieldList.TYPE_BOOLEAN:
                _dout.writeBoolean( toBoolean( value ) );
                break;
            case FieldList.TYPE_BYTE:
                _dout.write( (byte) toInt( value ) );
                break;
            case FieldList.TYPE_CHAR:
                _dout.writeChar( toChar( value ) );
                break;
            case FieldList.TYPE_SHORT:
                _dout.writeShort( (short) toInt( value ) );
                break;
            case FieldList.TYPE_INT:
                _dout.writeInt( toInt( value ) );
                break;
            case FieldList.TYPE_LONG:
                _dout.writeLong( toLong( value ) );
                break;
            case FieldList.TYPE_STRING:
                if( value != null ){
                    String str = value.toString();
                    _dout.writeByte( UTF_STRING_MARKER );
                    _dout.writeUTF( str );
                } else {
                    _dout.writeByte( NULL_STRING_MARKER );
                }
                break;
        }
    }

    // Writes a set of fields to the output stream.

    protected byte[] writeStream( FieldList list, 
                                  Object[] fields )
                                       throws IOException {
        int count = list.getFieldCount();
        int len = ( fields != null ? fields.length : 0 );

        prepareForOutput();

        for( int i = 0; i < count; ++i ){
            writeField( list.getFieldType( i ),
                        ( i < len ? fields[i] : null ) );
        }

        return _bout.getByteArray();
    }

    private DirectByteArrayInputStream  _bin;
    private DirectByteArrayOutputStream _bout;
    private DataInputStream             _din;
    private DataOutputStream            _dout;
}

现在，我们扩展 FieldBasedRecordMapper 以创建另一个抽象类，FieldBasedFilter，这是我们过滤器的基类：

package j2me.rms;

import javax.microedition.rms.*;

// A record filter for filtering records whose data
// is mapped to a field list. The actual filter will
// extend this class and implement the matchFields
// method appropriately.

public abstract class FieldBasedFilter
                      extends FieldBasedRecordMapper
                      implements RecordFilter {

    // Constructs the filter. The optional byte
    // array is an array that we want ignored,
    // usually the first record in the record store
    // where we store the field information.

    protected FieldBasedFilter(){
        this( null );
    }

    protected FieldBasedFilter( byte[] ignore ){
        _ignore = ignore;
    }

    // Compares two byte arrays.

    private boolean equal( byte[] a1, byte[] a2 ){
        int len = a1.length;

        if( len != a2.length ) return false;

        for( int i = 0; i < len; ++i ){
            if( a1[i] != a2[i] ) return false;
        }

        return true;
    }

    // Called to filter a record.

    public boolean matches( byte[] data ){
        if( _ignore != null ){
            if( equal( _ignore, data ) ) return false;
        }

        prepareForInput( data );
        return matchFields();
    }

    // The actual filter implements this method.

    protected abstract boolean matchFields();

    private byte[] _ignore;
}

假设我们这样定义一个如下的 FieldList 实例：

...
FieldList empFields = new FieldList( 5 );

empFields.setFieldType( 0, FieldList.TYPE_INT );
empFields.setFieldName( 0, "ID" );
empFields.setFieldType( 1, FieldList.TYPE_STRING );
empFields.setFieldName( 1, "Given Name" );
empFields.setFieldType( 2, FieldList.TYPE_STRING );
empFields.setFieldName( 2, "Last Name" );
empFields.setFieldType( 3, FieldList.TYPE_BOOLEAN );
empFields.setFieldName( 3, "Active" );
empFields.setFieldType( 4, FieldList.TYPE_CHAR );
empFields.setFieldName( 4, "Sex" );
...

一个匹配特定姓氏的过滤器看起来类似于：

package j2me.rms;

import java.io.IOException;

// A filter that matches a specific last name
// in an employee record.

public class MatchLastName extends FieldBasedFilter {
    public MatchLastName( String name ){
        this( name, null );
    }

    public MatchLastName( String name, byte[] ignore ){
        super( ignore );
        _name = name;
    }

    protected boolean matchFields(){
        try {
            readField( FieldList.TYPE_INT );
            readField( FieldList.TYPE_STRING );

            String ln = (String)
                       readField( FieldList.TYPE_STRING );

            return ln.equals( _name );
        }
        catch( IOException e ){
            return false;
        }
    }

    private String _name;
}

发现匹配的记录是一件简单的事情：

...
RecordStore employees = ... // list of employees
RecordFilter lname = new MatchLastName( "Smith" );
RecordEnumeration enum =
      employees.enumerateRecords( lname, null, false );

while( enum.hasNextElement() ){
    int id = enum.nextRecordId();
    ... // etc. etc./
}

enum.destroy();
...

仔细地编码，您可以避免打开任何不需要的记录。您可以采取的一个方法是在内存中缓存最近访问的记录。例如，每当过滤器匹配一个记录时，打开该记录并且将它的已打开形式存储到缓存中，这种打开形式通常是一个表示单一实体的对象，例如雇员。将它的记录 ID 用作关键字 —— 当然，您需要在记录中存储 ID。当您遍历该枚举时，在访问底层记录存储之前检查已打开记录的缓存。

实际上，使用枚举方式将匹配记录收集和打开为单独的列表可能更为简单。考虑我们在第 2 部分中定义的 Contact 类，它的简单的 toByteArray() 和 fromByteArray() 方法用于在实例和字节数组之间进行映射：

package j2me.example;

import java.io.*;

// The contact information for a person

public class Contact {
    private String _firstName;
    private String _lastName;
    private String _phoneNumber;

    public Contact(){
    }

    public Contact( String firstName, String lastName,
                    String phoneNumber )
    {
        _firstName = firstName;
        _lastName = lastName;
        _phoneNumber = phoneNumber;
    }

    public String getFirstName(){
        return _firstName != null ? _firstName : "";
    }

    public String getLastName(){
        return _lastName != null ? _lastName : "";
    }

    public String getPhoneNumber(){
        return _phoneNumber != null ? _phoneNumber : "";
    }

    public void setFirstName( String name ){
        _firstName = name;
    }

    public void setLastName( String name ){
        _lastName = name;
    }

    public void setPhoneNumber( String number ){
        _phoneNumber = number;
    }

    public void fromByteArray( byte[] data ) 
                                throws IOException {
        ByteArrayInputStream bin = 
                        new ByteArrayInputStream( data );
        DataInputStream din = new DataInputStream( bin );

        fromDataStream( din );
        din.close();
    }

    public byte[] toByteArray() throws IOException {
        ByteArrayOutputStream bout = 
                        new ByteArrayOutputStream();
        DataOutputStream dout = new DataOutputStream( bout );

        toDataStream( dout );
        dout.close();

        return bout.toByteArray();
    }

    public void fromDataStream( DataInputStream din ) 
                                throws IOException {
        _firstName = din.readUTF();
        _lastName = din.readUTF();
        _phoneNumber = din.readUTF();
    }

    public void toDataStream( DataOutputStream dout ) 
                              throws IOException {
        dout.writeUTF( getFirstName() );
        dout.writeUTF( getLastName() );
        dout.writeUTF( getPhoneNumber() );
    }
}

下面的类使用记录过滤器作为一种发现和存储匹配记录的方式。它返回 false 以指示一个空的枚举，从而立即被丢弃：

package j2me.example;

import java.io.*;
import java.util.*;
import javax.microedition.rms.*;

// Finds the contacts whose first and/or last
// names match the given values.

public class FindContacts {

    // Constructs the finder for the given names. If
    // both names are non-null, both names must match,
    // otherwise only the given name needs to match.

    public FindContacts( String fname, String lname ){
        _fname = normalize( fname );
        _lname = normalize( lname );
    }

    // Traverses the data in the record store and
    // returns a list of matching Contact objects.

    public Vector list( RecordStore rs )
                        throws RecordStoreException,
                               IOException {

        Vector v = new Vector();
        Filter f = new Filter( v );
        RecordEnumeration enum =
               rs.enumerateRecords( f, null, false );

        // The enum will never have any elements in it,
        // but we call this to force it to traverse
        // its list.

        enum.hasNextElement();
        enum.destroy();

        return v;
    }

    // Returns whether or not a given Contact
    // instance matches our criteria.

    public boolean matchesContact( Contact c ){
        boolean sameFirst = false;
        boolean sameLast = false;

        if( _fname != null ){
            sameFirst =
               c.getFirstName().toLowerCase().equals(_fname);
        }

        if( _lname != null ){
            sameLast =
               c.getLastName().toLowerCase().equals( _lname );
        }

        if( _fname != null && _lname != null ){
            return sameFirst && sameLast;
        }

        return sameFirst || sameLast;
    }

    // Normalize our name data

    private static String normalize( String name ){
        return( name != null ? 
                name.trim().toLowerCase() : null );
    }

    private String _fname;
    private String _lname;

    // A record filter that always returns false but
    // whenever it finds a matching contact it adds it
    // to the given list.

    private class Filter implements RecordFilter {
        private Filter( Vector list ){
            _list = list;
        }

        public boolean matches( byte[] data ){
            try {
                Contact c = new Contact();
                c.fromByteArray( data );

                if( matchesContact( c ) ){
                    _list.addElement( c );
                }
            }
            catch( IOException e ){
            }

            return false;
        }

        private Vector _list;
    }
}

不幸的是，内存限制可能阻止每次缓存更多的对象。您可以通过使用索引搜索一张单独维护的表，从而获得某些性能。这个表将记录 ID 与关键字值例如联系名相配对。一个索引通常足够的小，以便于将它保持在内存中，并且省去您每次需要发现特定记录时都要使用枚举的麻烦。  

关于作者

Eric Giguere 是 iAnywhere Solutions 的一名软件开发人员，iAnywhere Solutions 是 Sybase 的一个子公司，他在那里从事关于手持设备和无线计算的 Java 技术。他拥有 Waterloo 大学计算机科学的学士和硕士学位，并广泛撰写有关计算主题的文章。

为了读或写一条记录，您需要知道它的记录 ID。在第 1 部分中，您了解到记录 ID 是一个整数值，它唯一地标识在记录存储中的一条记录 － 并且它不是记录存储中的索引。这个差异具有某些重要的含义。

如果具有 N 个记录的存储被索引，那么每条记录都将具有一个索引，其范围是 0 到 N-1 或者 1 到 N，这取决于范围是从 0 还是从 1 开始的。每当一条记录被删除或者插入的时候，在存储中的位于后面的记录索引将会相应的改变。该范围将会收缩或者增长，但是保持连续。

与索引不同的是，在记录存储中，无论在一条记录之前插入或者去除多少个其他的记录，该记录 ID 并不改变。增加到记录存储中的第一条记录将其记录 ID 赋值为 1，下一条记录 ID 为 2，等等。如果您删除一条记录，它的记录 ID 变为无效，并且任何访问该记录的企图都会抛出 InvalidRecordIDException。无效的记录 ID 不会保持连续。

由于它们唯一地标识记录，因此您可以通过将一个记录的 ID 存储为另一条记录中的数据值，从而使用记录 ID 将两个或者更多记录连接到一起。您还可以使用记录 ID 来同步数据和外部应用程序，正如您将在第 6 部分中所看到的。

记录 ID 的主要缺点是它们使记录存储遍历变得复杂化；您不能像在数组中那样，在一个索引集合中进行迭代。您必须使用两种遍历技术之一：强制或者枚举。

为了保证记录以一种一致的、可预测的次序被返回，您必须排序该枚举。您向该枚举提供一个比较器，这是一个实现 RecordComparator 接口的对象。比较器的 compare() 方法返回一条记录是否先于、等于或者后于其他记录：

public class MyComparator implements RecordComparator {
    public int compare( byte[] r1, byte[] r2 ){
        int salary1 = getSalary( r1 );
        int salary2 = getSalary( r2 );

        if( salary1 < salary2 ){
            return PRECEDES;
        } else if( salary1 == salary2 ){
            return EQUIVALENT;
        } else {
            return FOLLOWS;
        }
        }

        private int getSalary( byte[] data ){
            ... // code to get salary info
        }
    }

注意常量 PRECEDES、EQUIVALENT 和 FOLLOWS 的使用。这些常量是通过 RecordComparator接口定义的。为了使用一个比较器，将它作为第二个参数传递给enumerateRecords()：

...
enum = rs.enumerateRecords( null, new MyComparator(), false );
...

利用过滤器，没有记录标识符会被传递给比较器，只是原始的记录数据。

当您创建枚举时，可以提供过滤器和比较器。如果您这样做的话，在数据被排序之前应用过滤器。

本系列中的 第二部分 介绍了数据映射的基本知识。您学会了如何在字节数组（byte array）中存储原始数据类型的数值，如何使用流向记录库（record store）中存储对象和从记录库中检索对象以及如何从字节数组中抽取已存储的数值。在本文中，您将学会如何使您的应用程序远离这些低级操作，方法是对核心类进行扩展使其包含读写操作，创建并使用字段列表来存储和检索对象。

扩展核心类

J2ME 开发人员的目标之一是最小化应用程序对内存的使用。理想情况下，在任何给定的时间内，内存中应该只含有某个数据块的一个副本。然而，当您向 ByteArrayOutputStream 写数据时，您从来无法访问其基本的字节数组－－调用 toByteArray() 返回该数组的一个拷贝。如果您紧接着就将该字节数组保存到记录库中，则会造成没必要的内存浪费。要直接访问该数组，只需要对类 ByteArrayOutputStream 进行简单的扩展即可，扩展后的类称为 DirectByteArrayOutputStream：

package j2me.io;

import java.io.*;

// A version of ByteArrayOutputStream that gives you
// direct access to the underlying byte array if
// you need it.

public class DirectByteArrayOutputStream 
                       extends ByteArrayOutputStream {

    // Constructs a byte array output stream of default size

    public DirectByteArrayOutputStream(){
        super();
    }

    // Constructs a byte array output stream of given size

    public DirectByteArrayOutputStream( int size ){
        super( size );
    }

    // Returns a reference to the underlying byte array.
    // The actual amount of data in the byte array is
    // obtained via the size method.

    public synchronized byte[] getByteArray(){
        return buf;
    }

    // Swaps in a new byte array for the old one, resetting
    // the count as well.

    public synchronized byte[] swap( byte[] newBuf ){
        byte[] oldBuf = buf;
        buf = newBuf;
        reset();
        return oldBuf;
    }
}

记住调用 size() 方法查看存储在字节数组中的实际数据的多少：

...
DirectByteArrayOutputStream bout = ... 
RecordStore rs = ...

int numBytes = bout.size();
byte[] data = bout.getByteArray();

rs.addRecord( data, 0, numBytes );
...

未来保持一致性，您可以用类似的方法对 ByteArrayInputStream 类进行扩展：

package j2me.io;

import java.io.*;

// A version of ByteArrayInputStream that lets you
// replace the underlying byte array.

public class DirectByteArrayInputStream 
                  extends ByteArrayInputStream {

    // Constructs an output stream from the given array

    public DirectByteArrayInputStream( byte buf[] ){
        super( buf );
    }

    // Constructs an output stream from the given subarray

    public DirectByteArrayInputStream( byte buf[],
                                       int offset, 
                                       int length ){
        super( buf, offset, length );
    }

    // Resets the array the stream reads from

    public synchronized void setByteArray( byte[] buf ){
        this.buf = buf;
        this.pos = 0;
        this.count = buf.length;
        this.mark = 0;
    }

    // Resets the array the stream reads from

    public synchronized void setByteArray( byte[] buf, 
                                           int offset,
                                           int length ){
        this.buf = buf;
        this.pos = offset;
        this.count = Math.min( offset + length, buf.length );
        this.mark = offset;
    }
}

注意类ByteArrayInputStream和类 ByteArrayOutputStream以及以上所写的两个扩展类都使用了用于线程安全的同步方法。尽管在大多数情况下只有单一线程使用这些流，同步也就没有必要了。如果您的应用程序需要读写大量的数据，可考虑创建基于这些类的非同步的版本以获得较快的速度。

您也可以很容易的对 DataInputStream 和 DataOutputStream 进行扩展。例如，如果您需要在多个地方写整型数组，请使用 DataOutputStream 的以下扩展：

package j2me.io;

import java.io.*;

public class ExtendedDataOutputStream extends DataOutputStream {
    public ExtendedDataOutputStream( OutputStream out ){
        super( out );
    }

    public final void writeIntArray( int[] arr ) 
                                     throws IOException {
        int size = arr.length;
        writeInt( size );
        for( int i = 0; i < size; ++i ){
            writeInt( arr[i] );
        }
    }
}

相反，您可以将这种代码放入一个帮助器类，因为您不需要访问任何的 protected members。

创建记录字段

现在您已经拥有了创建基于字段的记录库的所有工具，记录库中的每条记录都是一组指定类型的命名字段。您利用两个类来管理该记录库。其中的第一个类 FieldList 管理字段自身的信息－－元数据：

package j2me.rms;

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

// Maintains information about the fields in a
// field-based record store. Currently just a list of
// field types and (optional) field names, but could
// easily be expanded to store other information.

public class FieldList {

    private static final int VERSION = 1;

    // The basic field types.

    public static final byte TYPE_BOOLEAN = 1;
    public static final byte TYPE_BYTE = 2;
    public static final byte TYPE_CHAR = 3;
    public static final byte TYPE_SHORT = 4;
    public static final byte TYPE_INT = 5;
    public static final byte TYPE_LONG = 6;
    public static final byte TYPE_STRING = 7;

    // Constructs an empty list.

    public FieldList(){
    }

    // Constructs a list of the given size.

    public FieldList( int numFields ){
        if( numFields < 0 || numFields > 255 ){
            throw new IllegalArgumentException( 
                       "Bad number of fields" );
        }

        _types = new byte[ numFields ];
        _names = new String[ numFields ];
    }

    // Returns the number of fields.

    public int getFieldCount(){
        return _types != null ? _types.length : 0;
    }

    // Returns the name of a field.

    public String getFieldName( int index ){
        String name = _names[ index ];
        return name != null ? name : "";
    }

    // Returns the type of a field.

    public byte getFieldType( int index ){
        return _types[ index ];
    }

    // Reads the field list from a byte array.

    public void fromByteArray( byte[] data )
                               throws IOException {
        ByteArrayInputStream bin = 
                  new ByteArrayInputStream( data );
        fromDataStream( new DataInputStream( bin ) );
        bin.close();
    }

    // Reads the fields list from a data stream.

    public void fromDataStream( DataInputStream din )
                                throws IOException {
        int version = din.readUnsignedByte();
        if( version != VERSION ){
            throw new IOException( "Incorrect version " +
                  version + " for FieldList, expected " +
                  VERSION );
        }

        int numFields = din.readUnsignedByte();

        _types = new byte[ numFields ];
        _names = new String[ numFields ];

        if( numFields > 0 ){
            din.readFully( _types );
    
            for( int i = 0; i < numFields; ++i ){
                _names[i] = din.readUTF();
            }
        }
    }

    // Reads a field list from a record store.

    public void fromRecordStore( RecordStore rs, int index )
                                 throws IOException, 
                                        RecordStoreException {
        fromByteArray( rs.getRecord( index ) );
    }

    // Sets the name of a field.

    public void setFieldName( int index, String name ){
        _names[ index ] = name;
    }

    // Sets the type of a field.

    public void setFieldType( int index, byte type ){
        _types[ index ] = type;
    }

    // Stores the fields list to a byte array

    public byte[] toByteArray() throws IOException {
        ByteArrayOutputStream bout = 
                     new ByteArrayOutputStream();
        toDataStream( new DataOutputStream( bout ) );
        byte[] data = bout.toByteArray();
        bout.close();
        return data;
    }

    // Stores the fields list to a data stream

    public void toDataStream( DataOutputStream out )
                              throws IOException {
        out.writeByte( VERSION );

        int count = getFieldCount();

        out.writeByte( count );

        if( count > 0 ){
            out.write( _types, 0, count );

            for( int i = 0; i < count; ++i ){
                out.writeUTF( getFieldName( i ) );
            }
        }
    }

    // Writes a field list to a record store.

    public int toRecordStore( RecordStore rs, int index )
                               throws IOException, 
                                      RecordStoreException {
        byte[]  data = toByteArray();
        boolean add = true;

        if( index > 0 ){
            try {
                rs.setRecord( index, data, 0, data.length );
                add = false;
            }
            catch( InvalidRecordIDException e ){
            }
        }

        // If the record doesn't actually exist yet,
        // go ahead and create it by inserting dummy
        // records ahead of it

        if( add ){
            synchronized( rs ){
                int nextID = rs.getNextRecordID();
                if( index <= 0 ) index = nextID;
    
                while( nextID < index ){
                    rs.addRecord( null, 0, 0 );
                }
    
                if( nextID == index ){
                    rs.addRecord( data, 0, data.length );
                }
            }
        }

        return index;
    }

    private String[] _names;
    private byte[]   _types;
}

实际上，一个 FieldList 实例只是两个数组的一个包装器。

在其核心，一个 FieldList 实例只是两个数组的一个包装器。第一个数组存储每个字段的类型，第二个数组存储每个字段的名称。名称是可选的，重要的是类型，因为它决定如何将数据写入记录和从记录中读出。所有标准的 Java 原始数据类型都支持，还有 String 类型。下面是对存储某个组织的部门列表的字段的定义：

...
FieldList depts = new FieldList( 3 );
depts.setFieldType( 0, FieldList.TYPE_SHORT );
depts.setFieldName( 0, "ID" );
depts.setFieldType( 1, FieldList.TYPE_STRING );
depts.setFieldName( 1, "Name" );
depts.setFieldType( 2, FieldList.TYPE_INT );
depts.setFieldName( 2, "ManagerID" );
...

一个 FieldList

实例可存储在一个数据流、一个字节数组或者一个记录库中。如果您将字段列表存储为记录库中的第一条记录，则任何可打开该记录库的代码就可以读取该记录以决定其余字段的字段布局。要使这个策略起到作用，您必须在创建记录库后立即存储记录列表：

...
FieldList list = ... // a field list
RecordStore rs = RecordStore.openRecordStore( "foo", true );
if( rs.getNumRecords() == 0 ){ // empty, store it
    list.toRecordStore( rs, -1 );
}
...

toRecordStore() 方法的第二个参数确定了保存字段数据所使用的记录。负值表示将要添加一条新的记录。

管理基于字段的记录库所需的第二个类是 FieldBasedStore，它将管理实际的读写操作：

package j2me.rms;

import java.io.*;
import javax.microedition.rms.*;
import j2me.io.*;

// A wrapper class for a record store that allows the
// records to be accessed as a set of fields. The field
// definitions are maintained separately using a FieldList
// object, which can be stored as part of the record store
// or separately.

public class FieldBasedStore {

    // Some useful constants

    public static Boolean TRUE = new Boolean( true );
    public static Boolean FALSE = new Boolean( false );

    // Markers for the types of string we support

    private static final byte NULL_STRING_MARKER = 0;
    private static final byte UTF_STRING_MARKER = 1;

    // Constructs a field store where the field list is
    // assumed to be stored in the first record.

    public FieldBasedStore( RecordStore rs )
                            throws IOException,
                                   RecordStoreException {
        this( rs, 1 );
    }

    // Constructs a field store where the field list is
    // stored in the given record.

    public FieldBasedStore( RecordStore rs, int fieldListID )
                            throws IOException,
                                   RecordStoreException {
        this( rs, loadFieldList( rs, fieldListID ) );
    }

    // Constructs a field store with the given field list.

    public FieldBasedStore( RecordStore rs, FieldList list ){
        _rs = rs;
        _fieldList = list;
    }

    // Adds a new record to the store. Returns the new
    // record ID.

    public synchronized int addRecord( Object[] fields )
                                 throws IOException,
                                        RecordStoreException {
        writeStream( fields );
        byte[] data = _bout.getByteArray();
        return _rs.addRecord( data, 0, data.length );
    }

    // Returns the current field list.

    public FieldList getFieldList(){
        return _fieldList;
    }

    // Returns the record store.

    public RecordStore getRecordStore(){
        return _rs;
    }

    // Loads the field list from the record store.

    private static FieldList loadFieldList( RecordStore rs,
                                            int fieldListID )
                                 throws IOException,
                                        RecordStoreException {
        FieldList list = new FieldList();
        list.fromRecordStore( rs, fieldListID );
        return list;
    }

    // Prepares the store for input by making sure that
    // the data buffer is big enough. The streams are
    // reused.

    private void prepareForInput( int size ){
        if( _buffer == null || _buffer.length < size ){
            _buffer = new byte[ size ];
        }

        if( _bin == null ){
            _bin = new DirectByteArrayInputStream( _buffer );
            _din = new DataInputStream( _bin );
        } else {
            _bin.setByteArray( _buffer );
        }
    }

    // Prepares the store for output. The streams are reused.

    private void prepareForOutput(){
        if( _bout == null ){
            _bout = new DirectByteArrayOutputStream();
            _dout = new DataOutputStream( _bout );
        } else {
            _bout.reset();
        }
    }

    // Reads a field from the buffer.

    private Object readField( int type ) throws IOException {
        switch( type ){
            case FieldList.TYPE_BOOLEAN:
                return _din.readBoolean() ? TRUE : FALSE;
            case FieldList.TYPE_BYTE:
                return new Byte( _din.readByte() );
            case FieldList.TYPE_CHAR:
                return new Character( _din.readChar() );
            case FieldList.TYPE_SHORT:
                return new Short( _din.readShort() );
            case FieldList.TYPE_INT:
                return new Integer( _din.readInt() );
            case FieldList.TYPE_LONG:
                return new Long( _din.readLong() );
            case FieldList.TYPE_STRING: {
                byte marker = _din.readByte();
                if( marker == UTF_STRING_MARKER ){
                    return _din.readUTF();
                }
            }
        }

        return null;
    }

    // Reads the record at the given ID and returns it as
    // a set of objects that match the types in the 
    // field list.

    public synchronized Object[] readRecord( int recordID )
                                 throws IOException,
                                        RecordStoreException {
        prepareForInput( _rs.getRecordSize( recordID ) );
        _rs.getRecord( recordID, _buffer, 0 );

        int count = _fieldList.getFieldCount();
        Object[] fields = new Object[ count ];

        for( int i = 0; i < count; ++i ){
            fields[i] = readField(_fieldList.getFieldType(i));
        }

        return fields;
    }

    // Converts an object to a boolean value.

    public static boolean toBoolean( Object value ){
        if( value instanceof Boolean ){
            return ((Boolean) value).booleanValue();
        } else if( value != null ){
            String str = value.toString().trim();

            if( str.equals( "true" ) ) return true;
            if( str.equals( "false" ) ) return false;

            return( toInt( value ) != 0 );
        }

        return false;
    }

    // Converts an object to a char.

    public static char toChar( Object value ){
        if( value instanceof Character ){
            return ((Character) value).charValue();
        } else if( value != null ){
            String s = value.toString();
            if( s.length() > 0 ){
                return s.charAt( 0 );
            }
        }

        return 0;
    }

    // Converts an object to an int. This code
    // would be much simpler if the CLDC supported
    // the java.lang.Number class.

    public static int toInt( Object value ){
        if( value instanceof Integer ){
            return ((Integer) value).intValue();
        } else if( value instanceof Boolean ){
            return ((Boolean) value).booleanValue() ? 1 : 0;
        } else if( value instanceof Byte ){
            return ((Byte) value).byteValue();
        } else if( value instanceof Character ){
            return ((Character) value).charValue();
        } else if( value instanceof Short ){
            return ((Short) value).shortValue();
        } else if( value instanceof Long ){
            return (int) ((Long) value).longValue();
        } else if( value != null ){
            try {
                return Integer.parseInt( value.toString() );
            }
            catch( NumberFormatException e ){
            }
        }

        return 0;
    }

    // Converts an object to a long. This code
    // would be much simpler if the CLDC supported
    // the java.lang.Number class.

    public static long toLong( Object value ){
        if( value instanceof Integer ){
            return ((Integer) value).longValue();
        } else if( value instanceof Boolean ){
            return ((Boolean) value).booleanValue() ? 1 : 0;
        } else if( value instanceof Byte ){
            return ((Byte) value).byteValue();
        } else if( value instanceof Character ){
            return ((Character) value).charValue();
        } else if( value instanceof Short ){
            return ((Short) value).shortValue();
        } else if( value instanceof Long ){
            return ((Long) value).longValue();
        } else if( value != null ){
            try {
                return Long.parseLong( value.toString() );
            }
            catch( NumberFormatException e ){
            }
        }

        return 0;
    }

    // Writes a field to the output buffer.

    private void writeField( int type, Object value )
                                 throws IOException {
        switch( type ){
            case FieldList.TYPE_BOOLEAN:
                _dout.writeBoolean( toBoolean( value ) );
                break;
            case FieldList.TYPE_BYTE:
                _dout.write( (byte) toInt( value ) );
                break;
            case FieldList.TYPE_CHAR:
                _dout.writeChar( toChar( value ) );
                break;
            case FieldList.TYPE_SHORT:
                _dout.writeShort( (short) toInt( value ) );
                break;
            case FieldList.TYPE_INT:
                _dout.writeInt( toInt( value ) );
                break;
            case FieldList.TYPE_LONG:
                _dout.writeLong( toLong( value ) );
                break;
            case FieldList.TYPE_STRING:
                if( value != null ){
                    String str = value.toString();
                    _dout.writeByte( UTF_STRING_MARKER );
                    _dout.writeUTF( str );
                } else {
                    _dout.writeByte( NULL_STRING_MARKER );
                }
                break;
        }
    }

    // Writes a set of fields to the given record. The
    // fields must be compatible with the types in
    // the field list.

    public synchronized void writeRecord( int recordID,
                                          Object[] fields )
                                 throws IOException,
                                        RecordStoreException {
        writeStream( fields );
        byte[] data = _bout.getByteArray();
        _rs.setRecord( recordID, data, 0, data.length );
    }

    // Writes a set of fields to the output stream.

    private void writeStream( Object[] fields )
                                       throws IOException {
        int count = _fieldList.getFieldCount();
        int len = ( fields != null ? fields.length : 0 );

        prepareForOutput();

        for( int i = 0; i < count; ++i ){
            writeField( _fieldList.getFieldType( i ),
                        ( i < len ? fields[i] : null ) );
        }
    }

    private DirectByteArrayInputStream  _bin;
    private DirectByteArrayOutputStream _bout;
    private byte[]                      _buffer;
    private DataInputStream             _din;
    private DataOutputStream            _dout;
    private FieldList                   _fieldList;
    private RecordStore                 _rs;
}

要创建一个 FieldBasedStore，你需要一个 RecordStore 实例和一个 FieldList 实例。您可以在构造 FieldBasedStore 的过程中隐式地从记录库自身中读取后者：

...
RecordStore rs = ... // an open record store
FieldBasedStore fstore = new FieldBasedStore( rs );
...

或者您可以对其进行显式指定：

...
RecordStore rs = ... // an open record store
FieldList list = ... // a field list
FieldBasedStore fstore = new FieldBasedStore( rs, list );
...

FieldBasedStore 将每条记录作为一个对象数组来处理。数组中的数据类型和字段列表中所描述的字段类型相匹配。在上面的部门列表中，每一个都含有一个部门标识符、一个部门名称以及一个经理标识符。您可以用如下方法添加一条记录：

...
Object[] fields = new Object[]{
    new Short( 1 ), "Accounting", new Integer( 100 )
};

int recordID = fstore.addRecord( fields );
...

注意 FieldBasedStore 中的写记录代码是具有智能性的，它可以执行“明显的”数据转换，所以您也可以用以下方法进行：

...
Object[] fields = new Object[]{ "1", "Accounting", "100" };
int recordID = fstore.addRecord( fields );
...

读取记录也同样简单：

...
Object[] fields = fstore.readRecord( recordID );
for( int i = 0; i < fields.length; ++i ){
    System.out.println( "Field: " +
       fstore.getFieldList().getFieldName( i ) +
       " Value: " + fields[i] );
}
...

您可以在任何时候重写该数组来修改记录：

...
Object[] fields = fstore.readRecord( recordID );
fields[2] = "134"; // change the manager
fstore.writeRecord( recordID, fields );
...

这里有一个 MIDlet 的示例，它使用了一对基于字段的记录库来存储和检索雇员和部门数据。它也可使用 第一部分 所述的 RMSAnalyzer 类将记录库中的内容倒出，只是向您表明记录是如何被存储的。

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

// A simple MIDlet for testing RMS mappings
// done using the FieldBasedStore class.

public class RMSMappings extends MIDlet
                 implements CommandListener {

    private Display    display;

    public static final Command exitCommand =
                         new Command( "Exit",
                                      Command.EXIT, 1 ); 
    public static final Command testCommand =
                         new Command( "Test",
                                      Command.SCREEN, 1 );

    private static Object[][] empList = {
        new Object[]{ "1", "Mary", "CEO", "100", "F" },
        new Object[]{ "2", "John", "CFO", "200", "M" },
        new Object[]{ "3", "Pat", "Closem", "300", "F" },
        new Object[]{ "4", "PJ", "Admin", "100", "M" },
    };

    private static Object[][] deptList = {
        new Object[]{ "100", "Executive", "1" },
        new Object[]{ "200", "Operations", "2" },
        new Object[]{ "300", "Sales", "1" },
    };

    public RMSMappings(){
    }

    public void commandAction( Command c,
                               Displayable d ){
        if( c == exitCommand ){
            exitMIDlet();
        } else if( c == testCommand ){
            runTest();
        }
    }

    protected void destroyApp( boolean unconditional )
                       throws MIDletStateChangeException {
        exitMIDlet();
    }

    public void exitMIDlet(){
        notifyDestroyed();
    }

    public Display getDisplay(){ return display; }

    protected void initMIDlet(){
        display.setCurrent( new MainForm() );
    }

    protected void pauseApp(){
    }

    private void printRecord( FieldBasedStore store,
                              int recordID ){
        try {
            FieldList list = store.getFieldList();
            Object[]  fields = store.readRecord( recordID );

            if( fields.length != list.getFieldCount() ){
                System.out.println( "Error: bad count" );
                return;
            }

            System.out.println( "Record " + recordID + ":" );

            for( int i = 0; i < fields.length; ++i ){
                System.out.println( "  " +
                      list.getFieldName( i ) + ": " +
                      fields[i] );
            }
        }
        catch( RecordStoreException e  ){
        }
        catch( IOException e ){
        }
    }

    private void runTest(){
        // First delete the record stores...

        System.out.println( "Deleting record stores..." );

        String[] names = RecordStore.listRecordStores();

        for( int i = 0; i < names.length; ++i ){
            try {
                RecordStore.deleteRecordStore( names[i] );
            } catch( RecordStoreException e ){
                System.out.println( "Could not delete " +
                                    names[i] );
            }
        }

        // Create two record stores, one with a field list
        // stored in the first record and the second with
        // a field list stored separately (in the app)

        RecordStore     empRS = null;
        RecordStore     deptRS = null;
        FieldList       empFields = new FieldList( 5 );
        FieldList       deptFields = new FieldList( 3 );
        FieldBasedStore employees;
        FieldBasedStore departments;

        empFields.setFieldType( 0, FieldList.TYPE_INT );
        empFields.setFieldName( 0, "ID" );
        empFields.setFieldType( 1, FieldList.TYPE_STRING );
        empFields.setFieldName( 1, "Given Name" );
        empFields.setFieldType( 2, FieldList.TYPE_STRING );
        empFields.setFieldName( 2, "Last Name" );
        empFields.setFieldType( 3, FieldList.TYPE_BOOLEAN );
        empFields.setFieldName( 3, "Active" );
        empFields.setFieldType( 4, FieldList.TYPE_CHAR );
        empFields.setFieldName( 4, "Sex" );

        System.out.println( "Initializing employees" );

        try {
            empRS = RecordStore.openRecordStore( "empRS",
                                                 true );
            // now store the field list in the RS
            empFields.toRecordStore( empRS, -1 );
            employees = new FieldBasedStore( empRS );
        }
        catch( RecordStoreException e ){
            System.out.println( "Could not create empRS" );
            return;
        }
        catch( IOException e ){
            System.out.println( "Error storing field list" );
            return;
        }

        System.out.println( "Initializing departments" );

        deptFields.setFieldType( 0, FieldList.TYPE_INT );
        deptFields.setFieldName( 0, "ID" );
        deptFields.setFieldType( 1, FieldList.TYPE_STRING );
        deptFields.setFieldName( 1, "Name" );
        deptFields.setFieldType( 2, FieldList.TYPE_INT );
        deptFields.setFieldName( 2, "Manager" );

        try {
            deptRS = RecordStore.openRecordStore( "deptRS",
                                                  true );
            departments = new FieldBasedStore( deptRS,
                                               deptFields );
        }
        catch( RecordStoreException e ){
            System.out.println( "Could not create deptRS" );
            return;
        }

        int[] empRecordID;
        int[] deptRecordID;
        int   i;

        // Add the data...

        try {
            empRecordID = new int[ empList.length ];

            for( i = 0; i < empList.length; ++i ){
                empRecordID[i] =
                       employees.addRecord( empList[i] );
            }

            deptRecordID = new int[ deptList.length ];

            for( i = 0; i < deptList.length; ++i ){
                deptRecordID[i] =
                    departments.addRecord( deptList[i] );
            }
        }
        catch( RecordStoreException e ){
            System.out.println( "Error adding record" );
            return;
        }
        catch( IOException e ){
            System.out.println( "Error writing field" );
            return;
        }

        // Now fetch the data back and print it...

        System.out.println( "---- Employee data ----" );

        for( i = 0; i < empRecordID.length; ++i ){
            printRecord( employees, empRecordID[i] );
        }

        System.out.println( "---- Department data ----" );
    
        for( i = 0; i < deptRecordID.length; ++i ){
            printRecord( departments, deptRecordID[i] );
        }
    
        System.out.println( "Closing empRS" );

        try {
            empRS.closeRecordStore();
        }
        catch( RecordStoreException e ){
            System.out.println( "Error closing empRS" );
        }

        System.out.println( "Closing deptRS" );

        try {
            deptRS.closeRecordStore();
        }
        catch( RecordStoreException e ){
            System.out.println( "Error closing deptRS" );
        }

        System.out.println( "Dumping record stores..." );

        // Analyze them...

        RMSAnalyzer analyzer = new RMSAnalyzer(
                      new RMSAnalyzer.SystemLogger( 10 ) );
        analyzer.analyzeAll();
    }

    protected void startApp()
                      throws MIDletStateChangeException {
        if( display == null ){ 
            display = Display.getDisplay( this );
            initMIDlet();
        }
    }

    public class MainForm extends Form {
        public MainForm(){
            super( "RMSMappings" );

            addCommand( exitCommand );
            addCommand( testCommand );

            setCommandListener( RMSMappings.this );
        }
    }
}

正如它们现在所表明的，FieldBasedStore 和 FieldList 类可以使用一些改善。例如，基于字段的库也可以基于游标，像一个 JDBC 结果集，并使您在记录之间移动并抽取单个字段值。记录库可以缓冲记录。字段列表可以返回给定名称的字段的索引。当然，这些和其他的改进都是有同样代价的，于是您不得不在需要什么和什么会在您的平台上起作用之间进行平衡。当您预先不知道数据结构时，一个通用的基于字段的方法是最合适的。当然，预先不知道数据结构的情况并不常出现。通常，最好的方案是在一个持久存储对象中封装已知的对象类型。我在这里提出通用的方法，主要是告诉您最多能做些什么。

下一部分提要

第四节将讨论使用 RMS 的更高级的方面：遍历记录库和筛选记录。

关于作者

Eric Giguere  是来自 Sybase 子公司 iAnywhere Solutions 的一个软件开发人员，主要从事用于手持设备和无线计算的 Java 技术。他拥有 Waterloo 大学的 BMath 和 MMath 学位，并广泛撰写有关计算主题的文章。

数据库和 MIDP，第二部分：数据映射

作者：Eric Giguere

正如 第一部分 所述，移动信息设备描述 (Mobile Information Device Profile，MIDP) 通过记录管理系统 (Record Management System，RMS) 提供数据持久存储。MIDP 对持久存储的支持局限于简单的字节数组 (byte array)，且记录的读写是按整体进行，而不是按字段进行的。因此，RMS 应用程序编程接口 (API) 非常简单，但它要求应用程序使用一个非常简单的二进制格式进行数据存储。

本文将描述封装低级存储操作的数据映射策略，目的是提高应用程序存储和检索持久数据的效率。

数据操作的核心类

实际上，将数据写到一个记录库 (record store) 和通过网络向服务器发送数据包并没有什么区别。MIDP 基于其上的有限连接设备配置 (Connected Limited Device Configuration，CLDC) 包括源自 J2SE 核心库的标准数据操作类，这些类对于 RMS 操作十分有用。使用通用接口的一个很大的好处是，MIDlet 可以更容易地和运行在标准和企业 Java 平台上的应用程序进行互操作。

字节数组流

ByteArrayInputStream 对象可以将字节数组转换成输入流 (input stream)，举例如下：

...
byte[] data = new byte[]{ 1, 2, 3 };
ByteArrayInputStream bin = new ByteArrayInputStream( data );

int b;

while( ( b = bin.read() ) != -1 ){
    System.out.println( b );
}

try {
    bin.close();
} catch( IOException e ){
    // never thrown in this case
}
...

输入流将顺序返回该数组中的每个字节，直到数组的尾部。利用 mark() 和 reset()，可以在任何时候重新定位字节数组中的流 (stream)。

对象 ByteArrayOutputStream 可以捕获内存缓冲区中的数据，以便以后转换成字节数组：

...
ByteArrayOutputStream bout = new ByteArrayOutputStream();

bout.write( 1 );
bout.write( 2 );
bout.write( 3 );

byte[] data = bout.toByteArray();

for( int i = 0; i < data.length; ++i ){
    System.out.println( data[i] );
}

try {
    bout.close();
} catch( IOException e ){
    // never thrown in this case
}
...

随着数据不断地写入流中，ByteArrayOutputStream 的缓冲区的大小会自动增长。toByteArray() 方法将捕获到的数据拷贝到字节数组中。通过调用 reset()，我们就可以重用内部缓冲区，以便进行更多的数据捕获。

数据流

DataInputStream 可以将一个原始输入流转换成为原始数据类型和字符串：

...
InputStream in = ... // an input stream
DataInputStream din = new DataInputStream( in );    

try {
    int custID = din.readInt();
    String lastName = din.readUTF();
    String firstName = din.readUTF();
    long timestamp = din.readLong();

    din.close();
}
catch( IOException e ){
    // handle the error here
}
...

只有以 DataInputStream 所期望的与机器无关的格式写入 stream 中的数据，数据才可以读取。该类的方法可以读取大多数简单 Java 数据类型，这些方法包括 readBoolean()、readByte()、readChar()、readShort()、readInt() 和 readLong()。CLDC 1.1 实现额外支持 readFloat() 和 readDouble()。也有方法用来读取字节数组和无符号值，这些方法是 readFully()、readUnsignedByte() 和 readUnsignedShort()。 

readUTF() 方法可读取 UTF-8 格式的字符串，字符串含有的字符数可达 65,535。如果要读取一个两字节字符值的序列的字符串，应用程序必须多次调用 readChar()，它既可将一个分隔符看做字符串的结尾，也可认为字符串的长度已知。长度可以是一个固定的值，也可以写入字符串前部的 stream 中。

用来读取数据的应用程序必须知道原始数据的写入顺序，以便调用正确的方法。

DataOutputStream 可将字符串和原始数据类型写入一个输出流 (output stream)：

...
OutputStream out = ... // an output stream
DataOutputStream dout = new DataOutputStream( out );

try {
    dout.writeInt( 100 );
    dout.writeUTF( "Smith" );
    dout.writeUTF( "John" );
    dout.writeLong( System.currentTimeMillis() );

    dout.close();
}
catch( IOException e ){
    // handle the error here
}
...

这些数据用 DataInputStream 所期望的相同的与机器无关的格式写入。该类的方法可以写入大多数简单的 Java 数据类型，这些方法是：writeBoolean()、writeByte()、writeChar()、writeShort()、writeInt() 和 writeLong()。 CLDC 1.1 实现额外支持 writeFloat() 和 writeDouble()。

可调用两个方法来写字符串。您可以用 writeUTF() 写一个用 UTF-8 格式编码的最多含有 65,535 个字符的字符串，或者调用 writeChars() 来写一个两字节字符的序列。

基本数据映射

标准数据操作类可使基本数据映射变得容易..将数据写入记录库只需要将 DataOutputStream 与 ByteArrayOutputStream 合并，并存储得到的字节数组：

...
RecordStore rs = ... // a record store
ByteArrayOutputStream bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream( bout );

try {
    dout.writeInt( 100 );
    dout.writeUTF( "Smith" );
    dout.writeUTF( "John" );
    dout.writeLong( System.currentTimeMillis() );
    dout.close();

    byte[] data = bout.toByteArray();
    rs.addRecord( data, 0, data.length );
}
catch( RecordStoreException e ){
    // handle RMS error here
}
catch( IOException e ){
    // handle IO error here
}
...

数据的读取是上述的步骤逆过程，它使用一个 DataInputStream 和一个 ByteArrayInputStream：

...
RecordStore rs = ... // a record store
int recordID = ... // the record to read
ByteArrayInputStream bin;
DataInputStream din;

try {
    byte[] data = rs.getRecord( recordID );
     
    bin = new ByteArrayInputStream( data );
    din = new DataInputStream( bin );
    
    int id = din.readInt();
    String lastName = din.readUTF();
    String firstName = din.readUTF();
    long timestamp = din.readLong();

    din.close();

    ... // process data here
}
catch( RecordStoreException e ){
    // handle RMS error here
}
catch( IOException e ){
    // handle IO error here
}
...

当写字符串时，需要注意 null 值。在大多数情况下，您会反而写一个空字符串。否则，您将需要用标记字节 (marker byte) 将 null 字符串和空字符串分别开来。

简单对象映射

在许多情况下，您要保存的数据被封装到一个对象实例中。例如，Contact 类含有某个人的联系信息：

package j2me.example;

// The contact information for a person

public class Contact {
    private String _firstName;
    private String _lastName;
    private String _phoneNumber;

    public Contact(){
    }

    public Contact( String firstName, String lastName,
                    String phoneNumber )
    {
        _firstName = firstName;
        _lastName = lastName;
        _phoneNumber = phoneNumber;
    }

    public String getFirstName(){
        return _firstName != null ? _firstName : "";
    }

    public String getLastName(){
        return _lastName != null ? _lastName : "";
    }

    public String getPhoneNumber(){
        return _phoneNumber != null ? _phoneNumber : "";
    }

    public void setFirstName( String name ){
        _firstName = name;
    }

    public void setLastName( String name ){
        _lastName = name;
    }

    public void setPhoneNumber( String number ){
        _phoneNumber = number;
    }
}

如果类可以修改，那么引入持久存储的最简单的方法是添加方法，以实现对象和字节数组之间的相互映射：

public void fromByteArray( byte[] data ) throws IOException {
    ByteArrayInputStream bin = new ByteArrayInputStream(data);
    DataInputStream din = new DataInputStream( bin );

    _firstName = din.readUTF();
    _lastName = din.readUTF();
    _phoneNumber = din.readUTF();

    din.close();
}

public byte[] toByteArray() throws IOException {
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    DataOutputStream dout = new DataOutputStream( bout );

    dout.writeUTF( getFirstName() );
    dout.writeUTF( getLastName() );
    dout.writeUTF( getPhoneNumber() );

    dout.close();

    return bout.toByteArray();
}

那么，存储一个对象就成了一个简单的操作：

...
Contact contact = ... // the contact to store
RecordStore rs = ... // the record store to use

try {
    byte[] data = contact.toByteArray();
    rs.addRecord( data, 0, data.length );
}
catch( RecordStoreException e ){
    // handle the RMS error here
}
catch( IOException e ){
    // handle the IO error here
}
...

对象的检索也同样容易：

...
RecordStore rs = ... // the record store to use
int recordID = ... // the record ID to read from
Contact contact = new Contact();

try {
    byte[] data = rs.getRecord( recordID );
    contact.fromByteArray( data );
}
catch( RecordStoreException e ){
    // handle the RMS error here
}
catch( IOException e ){
    // handle the IO error here
}
...

如果类不可修改，如标准 Vector 或 Hashtable 类，您就需要写一个帮助器类。例如，这里有一个帮助器类，它可将一组非空字符串映射到一个字节数组：

package j2me.example;

import java.io.*;
import java.util.*;

// A helper class that converts transforms string
// vectors (vectors whose elements are instances of
// String or StringBuffer ) into byte arrays and vice-versa.

public class StringVectorHelper {

    // Reconstitutes a vector from a byte array.

    public Vector fromByteArray( byte[] data )
                                 throws IOException {
        ByteArrayInputStream bin =
                 new ByteArrayInputStream( data );
        DataInputStream din = new DataInputStream( bin );

        int count = din.readInt();
        Vector v = new Vector( count );

        while( count-- > 0 ){
            v.addElement( din.readUTF() );
        }

        din.close();

        return v;
    }

    // Transforms a vector into a byte array.

    public byte[] toByteArray( Vector v )
                               throws IOException {
        ByteArrayOutputStream bout =
                   new ByteArrayOutputStream();
        DataOutputStream dout = new DataOutputStream( bout );

        dout.writeInt( v.size() );

        Enumeration e = v.elements();
        while( e.hasMoreElements() ){
            Object o = e.nextElement();
            dout.writeUTF( o != null ? o.toString() : "" );
        }

        dout.close();

        return bout.toByteArray();
    }
}

当然，您这里所做的一切都是为了开发一个对象串行化框架。一个完整的框架超出了本文的讨论范围，然而当您进行对象持久存储时，以下的问题还是值得仔细研究考虑的：

• 对象创建。CLDC 并不含有反射 API (reflection API)，所以您需要重建持久对象。它可以是一个接收 stream 或者字节数组的构造器，也可以是一个更加复杂的 factory 类。
• 版本化。如果一个对象的数据布局可以变化，那么您将需要在字节数组的开始处存储一个数字，该数用来标识所存储的对象的版本。
• 对象引用。如果一个对象引用了另一个对象，那么它们的关系必须保持。在有些情况下，可以用一个索引或者一个键来替代对象引用，索引和键可以在反串行化后对被引用的对象进行定位。否则，您就必须存储一个完整的对象图，而不仅仅是一个单一的对象。

您可以避免这些问题，或者将它们的影响降低到最低，方法就是只保存和恢复原始 Java 数据类型和简单的、独立的对象。fromByteArray() 和 toByteArray() 方法简单，但它们却是进行对象持久存储的简单有效的方法。您也可以使用这些技术通过网络进行对象的拷贝：一旦对象以字节数组的形式存在，那么，利用网络连接将数组发送到另一个设备或者一个外部服务器，并在另一端重建对象，就成为一个简单的事情。例如，您为 J2ME 应用程序所开发的数据类可以很容易的用于为 J2EE 所开发的 servlet 中。

使用数据流

以上的示例直接处理字节数组。尽管它们在保存和恢复一组数据方面很方便，然而，当需要存储多组数据（例如，一组对象）时，对字节数组的处理就成为任务繁重的工作了。一个更好的方法是将字节数组的管理和数据的读写分开。例如，可以向 Contact 类添加如下的方法：

public void fromDataStream( DataInputStream din ) 
                            throws IOException {
    _firstName = din.readUTF();
    _lastName = din.readUTF();
    _phoneNumber = din.readUTF();
}

public void toDataStream( DataOutputStream dout ) 
                          throws IOException {
    dout.writeUTF( getFirstName() );
    dout.writeUTF( getLastName() );
    dout.writeUTF( getPhoneNumber() );
}

为方便起见，我们可以保持现有的 fromByteArray 和 toByteArray 方法，但是我们应该对它们进行重写以便使用新的面向 stream 的方法：

public void fromByteArray( byte[] data ) throws IOException {
    ByteArrayInputStream bin = new ByteArrayInputStream(data);
    DataInputStream din = new DataInputStream( bin );

    fromDataStream( din );
    din.close();
}

public byte[] toByteArray() throws IOException {
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    DataOutputStream dout = new DataOutputStream( bout );

    toDataStream( dout );
    dout.close();

    return bout.toByteArray();
}

集中数据的读写以确保其一致性。

下一部分提要

在本部分中，您已经学习了一些基本数据映射技术。在 第三部分 中，您将了解到一个更成熟的方法来管理持久存储数据，该方法可使您的应用程序存储和检索由多个包含不同数据类型的字段所组成的对象。

关于作者

Eric Giguere 是来自 Sybase 子公司 iAnywhere Solutions 的一个软件开发人员，主要从事用于手持设备和无线计算的 Java 技术。他拥有 Waterloo 大学的 BMath 和 MMath 学位，并广泛撰写有关计算主题的文章。